From 83ef875f4c8b3a84f090d33e891abd4ff7c1bd00 Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Tue, 21 Mar 2023 14:44:03 +0100 Subject: [PATCH 01/87] WIP: exact games from Castro et al. 2009 --- CHANGELOG.md | 4 + src/pydvl/value/shapley/games.py | 353 +++++++++++++++++++++++++++++++ 2 files changed, 357 insertions(+) create mode 100644 src/pydvl/value/shapley/games.py diff --git a/CHANGELOG.md b/CHANGELOG.md index cff8d31d3..f5dc0a8cb 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,9 @@ # Changelog +## Unreleased + +- Implemented exact games in Castro et al. 2009 and 2017 + ## 0.6.0 - 🆕 New algorithms, cleanup and bug fixes 🏗 - Fixes in `ValuationResult`: bugs around data names, semantics of diff --git a/src/pydvl/value/shapley/games.py b/src/pydvl/value/shapley/games.py new file mode 100644 index 000000000..2792afb8f --- /dev/null +++ b/src/pydvl/value/shapley/games.py @@ -0,0 +1,353 @@ +""" +This module provides several predefined games and their Shapley values, for +benchmarking purposes. +""" +from __future__ import annotations + +from dataclasses import dataclass + +import numpy as np +import scipy as sp +from numpy.typing import NDArray + +from pydvl.utils import Scorer, Status +from pydvl.utils.dataset import Dataset +from pydvl.utils.types import SupervisedModel +from pydvl.utils.utility import Utility +from pydvl.value import ValuationResult + +__all__ = [ + "symmetric_voting_game", + "asymmetric_voting_game", + "shoes_game", + "airport_game", + "minimum_spanning_tree_game", + "SolvedGame", +] + + +@dataclass +class SolvedGame: + u: Utility + values: ValuationResult + + +def _dummy_dataset(num_samples: int, description: str) -> Dataset: + x = np.arange(0, num_samples, 1).reshape(-1, 1) + nil = np.zeros_like(x) + return Dataset( + x, + nil.copy(), + nil.copy(), + nil.copy(), + feature_names=["x"], + target_names=["y"], + description=description, + ) + + +class DummyModel(SupervisedModel): + def __init__(self): + pass + + def fit(self, x: NDArray, y: NDArray): + pass + + def predict(self, x: NDArray) -> NDArray: + return x + + +def symmetric_voting_game(num_samples: int = 1000) -> SolvedGame: + """A symmetric voting game defined in :footcite:t:`castro_polynomial_2009` + Section 4.1 + + Under this model the utility of a coalition is 1 if its cardinality is + greater than num_samples/2, or 0 otherwise. + """ + if num_samples % 2 != 0: + raise ValueError("num_samples must be an even number.") + + data = _dummy_dataset( + num_samples, "Dummy data for the symmetric voting game in Castro " "et al. 2009" + ) + + def symmetric_voting_score(model: SupervisedModel, x: NDArray, y: NDArray) -> float: + return 1 if len(x) > len(data) // 2 else 0 + + u = Utility( + DummyModel(), + data, + scorer=Scorer(symmetric_voting_score, range=(0, 1)), + catch_errors=False, + show_warnings=True, + enable_cache=False, + ) + values = ValuationResult( + algorithm="exact_shapley", + status=Status.Converged, + indices=data.indices, + values=np.ones_like(data.x_train) / len(data.x_train), + variances=np.zeros_like(data.x_train), + counts=np.zeros_like(data.x_train), + ) + + return SolvedGame(u, values) + + +def asymmetric_voting_game() -> SolvedGame: + """An asymmetric voting game defined in :footcite:t:`castro_polynomial_2009` + Section 4.2. + """ + n = 51 + ranges = [ + range(0, 1), + range(1, 2), + range(2, 3), + range(3, 5), + range(5, 6), + range(6, 7), + range(7, 9), + range(9, 10), + range(10, 12), + range(12, 15), + range(15, 16), + range(16, 20), + range(20, 24), + range(24, 26), + range(26, 30), + range(30, 34), + range(34, 35), + range(35, 44), + range(44, 51), + ] + + ranges_weights = [ + 45, + 41, + 27, + 26, + 25, + 21, + 17, + 14, + 13, + 12, + 11, + 10, + 9, + 8, + 7, + 6, + 5, + 4, + 3, + ] + ranges_values = [ + "0.08831", + "0.07973", + "0.05096", + "0.04898", + "0.047", + "0.03917", + "0.03147", + "0.02577", + "0.02388", + "0.022", + "0.02013", + "0.01827", + "0.01641", + "0.01456", + "0.01272", + "0.01088", + "0.009053", + "0.00723", + "0.005412", + ] + + weight_table = np.zeros(n) + exact_values = np.zeros(n) + for r, w, v in zip(ranges, ranges_weights, ranges_values): + weight_table[r] = w + exact_values[r] = v + + threshold = np.sum(weight_table) / 2 + + def assymetric_voting_game_score( + model: SupervisedModel, x: NDArray, y: NDArray + ) -> float: + return 1 if np.sum(weight_table[x]) > threshold else 0 + + data = _dummy_dataset( + n, "Dummy data for the asymmetric voting game in Castro et al. 2009" + ) + + u = Utility( + model=DummyModel(), + data=data, + scorer=Scorer(assymetric_voting_game_score, range=(0, 1)), + catch_errors=False, + show_warnings=True, + enable_cache=False, + ) + + values = ValuationResult( + algorithm="exact_shapley", + status=Status.Converged, + indices=data.indices, + values=exact_values, + variances=np.zeros_like(data.x_train), + counts=np.zeros_like(data.x_train), + ) + + return SolvedGame(u, values) + + +def shoes_game(num_samples: int = 1000) -> SolvedGame: + """A shoes game defined in :footcite:t:`castro_polynomial_2009` + + The utility of a coalition is the minimum of the number of left shoes or + right shoes in a coalition. A player is a left shoe iff its index is among + the first half, or a right shoe otherwise. + """ + if num_samples % 2 != 0: + raise ValueError("num_samples must be an even number.") + + data = _dummy_dataset( + num_samples, "Dummy data for the shoe game in Castro et al. 2009" + ) + + m = len(data) // 2 + + def shoe_game_score(model: SupervisedModel, x: NDArray, y: NDArray) -> float: + left_shoes = np.sum(x < m).item() + right_shoes = np.sum(x >= m).item() + return min(left_shoes, right_shoes) + + u = Utility( + model=DummyModel(), + data=data, + scorer=Scorer(shoe_game_score, range=(0, m)), + catch_errors=False, + show_warnings=True, + enable_cache=False, + ) + + values = ValuationResult( + algorithm="exact_shapley", + status=Status.Converged, + indices=data.indices, + values=np.ones_like(data.x_train) * 0.5, + variances=np.zeros_like(data.x_train), + counts=np.zeros_like(data.x_train), + ) + + return SolvedGame(u, values) + + +def airport_game() -> SolvedGame: + """An airport game defined in :footcite:t:`castro_polynomial_2009`, + Section 4.3""" + ranges = [ + range(0, 8), + range(8, 20), + range(20, 26), + range(26, 40), + range(40, 48), + range(48, 57), + range(57, 70), + range(70, 80), + range(80, 90), + range(90, 100), + ] + exact = [ + 0.01, + 0.020869565, + 0.033369565, + 0.046883079, + 0.063549745, + 0.082780515, + 0.106036329, + 0.139369662, + 0.189369662, + 0.289369662, + ] + c = list(range(1, 10)) + score_table = np.zeros(100) + exact_values = np.zeros(100) + + for r, v in zip(ranges, exact): + score_table[r] = c + exact_values[r] = v + + def airport_game_score(model: SupervisedModel, x: NDArray, y: NDArray) -> float: + return max(score_table[x]) + + data = _dummy_dataset(100, "A dummy dataset for...") + + u = Utility( + model=DummyModel(), + data=data, + scorer=Scorer(airport_game_score, range=(0, 100)), + catch_errors=False, + show_warnings=True, + enable_cache=False, + ) + + values = ValuationResult( + algorithm="exact_shapley", + status=Status.Converged, + indices=data.indices, + values=exact_values, + variances=np.zeros_like(data.x_train), + counts=np.zeros_like(data.x_train), + ) + + return SolvedGame(u, values) + + +def minimum_spanning_tree_game() -> SolvedGame: + data = _dummy_dataset(101, "A dummy dataset for...") + n = 101 + graph = np.zeros(shape=(n, n)) + + for i in range(n): + for j in range(n): + if ( + i == j + 1 + or i == j - 1 + or (i == 1 and j == n - 1) + or (i == n - 1 and j == 1) + ): + graph[i, j] = 1 + elif i == 0 or j == 0: + graph[i, j] = 0 + else: + graph[i, j] = np.inf + assert np.all(graph == graph.T) + + def minimum_spanning_tree_score( + model: SupervisedModel, x: NDArray, y: NDArray + ) -> float: + partial_graph = sp.sparse.csr_array(graph[np.ix_(x, x)]) + span_tree = sp.sparse.csgraph.minimum_spanning_tree(partial_graph) + return span_tree.sum() + + u = Utility( + model=DummyModel(), + data=data, + scorer=Scorer(minimum_spanning_tree_score, range=(0, np.inf)), + catch_errors=False, + show_warnings=True, + enable_cache=False, + ) + + values = ValuationResult( + algorithm="exact_shapley", + status=Status.Converged, + indices=data.indices, + values=2 * np.ones_like(data.x_train), + variances=np.zeros_like(data.x_train), + counts=np.zeros_like(data.x_train), + ) + + return SolvedGame(u, values) From 39043e21310bf525966012f5990f4fc6404be8cd Mon Sep 17 00:00:00 2001 From: Miguel de Benito Delgado Date: Sun, 27 Aug 2023 19:39:26 +0200 Subject: [PATCH 02/87] Fix types --- src/pydvl/value/shapley/games.py | 38 ++++++++++++++++++-------------- 1 file changed, 21 insertions(+), 17 deletions(-) diff --git a/src/pydvl/value/shapley/games.py b/src/pydvl/value/shapley/games.py index 2792afb8f..21082bf11 100644 --- a/src/pydvl/value/shapley/games.py +++ b/src/pydvl/value/shapley/games.py @@ -56,6 +56,10 @@ def fit(self, x: NDArray, y: NDArray): def predict(self, x: NDArray) -> NDArray: return x + def score(self, x: NDArray, y: NDArray) -> float: + # Dummy, will be overriden + return 0 + def symmetric_voting_game(num_samples: int = 1000) -> SolvedGame: """A symmetric voting game defined in :footcite:t:`castro_polynomial_2009` @@ -71,8 +75,8 @@ def symmetric_voting_game(num_samples: int = 1000) -> SolvedGame: num_samples, "Dummy data for the symmetric voting game in Castro " "et al. 2009" ) - def symmetric_voting_score(model: SupervisedModel, x: NDArray, y: NDArray) -> float: - return 1 if len(x) > len(data) // 2 else 0 + def symmetric_voting_score(model: SupervisedModel, X: NDArray, y: NDArray) -> float: + return 1 if len(X) > len(data) // 2 else 0 u = Utility( DummyModel(), @@ -82,7 +86,7 @@ def symmetric_voting_score(model: SupervisedModel, x: NDArray, y: NDArray) -> fl show_warnings=True, enable_cache=False, ) - values = ValuationResult( + values: ValuationResult[np.int_, int] = ValuationResult( algorithm="exact_shapley", status=Status.Converged, indices=data.indices, @@ -173,9 +177,9 @@ def asymmetric_voting_game() -> SolvedGame: threshold = np.sum(weight_table) / 2 def assymetric_voting_game_score( - model: SupervisedModel, x: NDArray, y: NDArray + model: SupervisedModel, X: NDArray, y: NDArray ) -> float: - return 1 if np.sum(weight_table[x]) > threshold else 0 + return 1 if np.sum(weight_table[X]) > threshold else 0 data = _dummy_dataset( n, "Dummy data for the asymmetric voting game in Castro et al. 2009" @@ -190,7 +194,7 @@ def assymetric_voting_game_score( enable_cache=False, ) - values = ValuationResult( + values: ValuationResult[np.int_, int] = ValuationResult( algorithm="exact_shapley", status=Status.Converged, indices=data.indices, @@ -218,9 +222,9 @@ def shoes_game(num_samples: int = 1000) -> SolvedGame: m = len(data) // 2 - def shoe_game_score(model: SupervisedModel, x: NDArray, y: NDArray) -> float: - left_shoes = np.sum(x < m).item() - right_shoes = np.sum(x >= m).item() + def shoe_game_score(model: SupervisedModel, X: NDArray, y: NDArray) -> float: + left_shoes = np.sum(X < m).item() + right_shoes = np.sum(X >= m).item() return min(left_shoes, right_shoes) u = Utility( @@ -232,7 +236,7 @@ def shoe_game_score(model: SupervisedModel, x: NDArray, y: NDArray) -> float: enable_cache=False, ) - values = ValuationResult( + values: ValuationResult[np.int_, int] = ValuationResult( algorithm="exact_shapley", status=Status.Converged, indices=data.indices, @@ -279,8 +283,8 @@ def airport_game() -> SolvedGame: score_table[r] = c exact_values[r] = v - def airport_game_score(model: SupervisedModel, x: NDArray, y: NDArray) -> float: - return max(score_table[x]) + def airport_game_score(model: SupervisedModel, X: NDArray, y: NDArray) -> float: + return max(score_table[X]) or 0.0 data = _dummy_dataset(100, "A dummy dataset for...") @@ -293,7 +297,7 @@ def airport_game_score(model: SupervisedModel, x: NDArray, y: NDArray) -> float: enable_cache=False, ) - values = ValuationResult( + values: ValuationResult[np.int_, int] = ValuationResult( algorithm="exact_shapley", status=Status.Converged, indices=data.indices, @@ -326,11 +330,11 @@ def minimum_spanning_tree_game() -> SolvedGame: assert np.all(graph == graph.T) def minimum_spanning_tree_score( - model: SupervisedModel, x: NDArray, y: NDArray + model: SupervisedModel, X: NDArray, y: NDArray ) -> float: - partial_graph = sp.sparse.csr_array(graph[np.ix_(x, x)]) + partial_graph = sp.sparse.csr_array(graph[np.ix_(X, X)]) span_tree = sp.sparse.csgraph.minimum_spanning_tree(partial_graph) - return span_tree.sum() + return span_tree.sum() or 0 u = Utility( model=DummyModel(), @@ -341,7 +345,7 @@ def minimum_spanning_tree_score( enable_cache=False, ) - values = ValuationResult( + values: ValuationResult[np.int_, int] = ValuationResult( algorithm="exact_shapley", status=Status.Converged, indices=data.indices, From 8557a558cecefe61309db8850acbbbbcb5c98494 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Sun, 12 Nov 2023 13:09:53 +0000 Subject: [PATCH 03/87] Bump pillow from 9.3.0 to 10.0.1 Bumps [pillow](https://github.com/python-pillow/Pillow) from 9.3.0 to 10.0.1. - [Release notes](https://github.com/python-pillow/Pillow/releases) - [Changelog](https://github.com/python-pillow/Pillow/blob/main/CHANGES.rst) - [Commits](https://github.com/python-pillow/Pillow/compare/9.3.0...10.0.1) --- updated-dependencies: - dependency-name: pillow dependency-type: direct:production ... Signed-off-by: dependabot[bot] --- requirements-notebooks.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements-notebooks.txt b/requirements-notebooks.txt index c45e0a104..4f4201e64 100644 --- a/requirements-notebooks.txt +++ b/requirements-notebooks.txt @@ -1,4 +1,4 @@ torch==2.0.1 torchvision==0.15.2 datasets==2.14.6 -pillow==9.3.0 +pillow==10.0.1 From da236a080bfa6d8daf75962442d287c2069500ad Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Tue, 19 Dec 2023 18:31:20 +0100 Subject: [PATCH 04/87] WIP porting ekfac method --- notebooks/influence_wine.ipynb | 352 +++++++++++++++--- src/pydvl/influence/torch/__init__.py | 1 + .../torch/influence_function_model.py | 266 ++++++++++++- src/pydvl/influence/torch/util.py | 55 +++ 4 files changed, 615 insertions(+), 59 deletions(-) diff --git a/notebooks/influence_wine.ipynb b/notebooks/influence_wine.ipynb index 19bd90408..9645ffa99 100644 --- a/notebooks/influence_wine.ipynb +++ b/notebooks/influence_wine.ipynb @@ -45,7 +45,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 30, "id": "cef17bfc", "metadata": { "editable": true, @@ -56,14 +56,23 @@ "hide-input" ] }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], "source": [ "%load_ext autoreload" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 31, "id": "be813151", "metadata": { "editable": true, @@ -86,16 +95,22 @@ "import torch.nn.functional as F\n", "from support.common import plot_losses\n", "from support.torch import TorchMLP, fit_torch_model\n", - "from pydvl.influence.torch import DirectInfluence, CgInfluence\n", + "from pydvl.influence.torch import (\n", + " DirectInfluence,\n", + " CgInfluence,\n", + " ArnoldiInfluence,\n", + " EkfacInfluence,\n", + ")\n", "from support.shapley import load_wine_dataset\n", "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, f1_score\n", "from torch.optim import Adam, lr_scheduler\n", - "from torch.utils.data import DataLoader, TensorDataset" + "from torch.utils.data import DataLoader, TensorDataset\n", + "from scipy.stats import pearsonr, spearmanr" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 32, "id": "02254f9c", "metadata": { "editable": true, @@ -118,7 +133,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 33, "id": "a656363e", "metadata": { "editable": true, @@ -138,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 34, "id": "df5159e6", "metadata": { "editable": true, @@ -166,7 +181,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 35, "id": "0d3e96ca", "metadata": { "editable": true, @@ -184,7 +199,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 36, "id": "cac906e3-aed6-4d11-b563-1b9a91132d29", "metadata": { "editable": true, @@ -213,7 +228,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 37, "id": "7b95fdf0", "metadata": {}, "outputs": [], @@ -235,7 +250,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 38, "id": "816f688d", "metadata": {}, "outputs": [], @@ -260,7 +275,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 39, "id": "00dc59af", "metadata": { "editable": true, @@ -273,18 +288,11 @@ }, "outputs": [ { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "68f03653c21d46859cba901374e7a323", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Model fitting: 0%| | 0/300 [00:00" ] @@ -365,7 +373,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 41, "id": "08f1cba4", "metadata": { "editable": true, @@ -380,7 +388,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -411,7 +419,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 42, "id": "ca48f9d5", "metadata": {}, "outputs": [ @@ -421,7 +429,7 @@ "0.9906846833902615" ] }, - "execution_count": 13, + "execution_count": 42, "metadata": {}, "output_type": "execute_result" } @@ -453,7 +461,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 43, "id": "218d0983", "metadata": { "editable": true, @@ -493,7 +501,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 44, "id": "9169c2dc", "metadata": {}, "outputs": [], @@ -512,7 +520,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 45, "id": "233a57da", "metadata": { "editable": true, @@ -527,7 +535,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -560,7 +568,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 46, "id": "8bc72789", "metadata": { "editable": true, @@ -576,8 +584,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average influence of corrupted points: -0.053697485\n", - "Average influence of other points: 0.03469002\n" + "Average influence of corrupted points: -0.051812828\n", + "Average influence of other points: 0.033997897\n" ] } ], @@ -612,7 +620,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 47, "id": "462d545e", "metadata": { "editable": true, @@ -631,7 +639,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 48, "id": "1e096222", "metadata": { "editable": true, @@ -646,7 +654,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -689,7 +697,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 49, "id": "efdb4050", "metadata": { "editable": true, @@ -702,18 +710,18 @@ }, "outputs": [ { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "0da71feb6d10426fb93a45c4da2002d8", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Conjugate gradient: 0%| | 0/53 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(mean_ekfac_train_influences, color=\"red\")\n", + "plt.plot(mean_train_influences, color=\"blue\")\n", + "plt.legend([\"ekfac\", \"direct\"])\n", + "plt.xlabel(\"Feature index\")\n", + "plt.ylabel(\"Influence Score\")\n", + "plt.title(\"Influence of training points - EK-FAC vs direct method\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "8537c4b1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pearson Correlation EK-FAC vs direct 0.19388048831254523\n", + "Spearman Correlation EK-FAC vs direct 0.3658280922431866\n" + ] + } + ], + "source": [ + "print(\n", + " f\"Pearson Correlation EK-FAC vs direct\",\n", + " pearsonr(mean_ekfac_train_influences, mean_train_influences).statistic,\n", + ")\n", + "print(\n", + " f\"Spearman Correlation EK-FAC vs direct\",\n", + " spearmanr(mean_ekfac_train_influences, mean_train_influences).statistic,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "3a88b8c5", + "metadata": {}, + "source": [ + "The correlation between the EK-FAC and the direct method is quite good, and it improves significantly if we just keep the points with highest absolute influence." + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "a3256f00", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pearson Correlation EK-FAC vs direct 0.10598500963131875\n", + "Spearman Correlation EK-FAC vs direct -0.03157894736842105\n" + ] + } + ], + "source": [ + "highest_inlfuence_idxs = np.argsort(np.abs(mean_train_influences))[-20:]\n", + "print(\n", + " f\"Pearson Correlation EK-FAC vs direct\",\n", + " pearsonr(\n", + " mean_ekfac_train_influences[highest_inlfuence_idxs],\n", + " mean_train_influences[highest_inlfuence_idxs],\n", + " ).statistic,\n", + ")\n", + "print(\n", + " f\"Spearman Correlation EK-FAC vs direct\",\n", + " spearmanr(\n", + " mean_ekfac_train_influences[highest_inlfuence_idxs],\n", + " mean_train_influences[highest_inlfuence_idxs],\n", + " ).statistic,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "9a0629d3", + "metadata": {}, + "source": [ + "When we calculate influence scores, typically we are more interested in assessing which training points have the highest or lowest impact on the model rather than having a precise estimate of the influence value. EK-FAC then provides a fast and memory-efficient way to calculate a coarse influence ranking of the training points which scales very well even to the largest neural networks." + ] + }, + { + "cell_type": "markdown", + "id": "03728578", + "metadata": {}, + "source": [ + "## Conclusions" + ] + }, { "attachments": {}, "cell_type": "markdown", @@ -799,7 +1037,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.18" + "version": "3.9.16" }, "vscode": { "interpreter": { diff --git a/src/pydvl/influence/torch/__init__.py b/src/pydvl/influence/torch/__init__.py index 9e90fd9df..6caf74d92 100644 --- a/src/pydvl/influence/torch/__init__.py +++ b/src/pydvl/influence/torch/__init__.py @@ -2,5 +2,6 @@ ArnoldiInfluence, CgInfluence, DirectInfluence, + EkfacInfluence, LissaInfluence, ) diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index 3b7c0a688..330ca0047 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -8,7 +8,7 @@ import logging from abc import ABC, abstractmethod -from typing import Callable, Optional +from typing import Callable, Dict, Optional, Tuple import torch from torch import nn as nn @@ -32,7 +32,11 @@ hessian, model_hessian_low_rank, ) -from .util import flatten_dimensions +from .util import ( + EkfacRepresentation, + empirical_cross_entropy_loss_fn, + flatten_dimensions, +) logger = logging.getLogger(__name__) @@ -876,3 +880,261 @@ def to(self, device: torch.device): return ArnoldiInfluence( self.model.to(device), self.loss, self.low_rank_representation.to(device) ) + + +class EkfacInfluence(TorchInfluenceFunctionModel): + + ekfac_representation: EkfacRepresentation + + def __init__( + self, + model: nn.Module, + hessian_regularization: float = 0.0, + ): + + super().__init__(model, empirical_cross_entropy_loss_fn) + self.hessian_regularization = hessian_regularization + self.active_layers = self._parse_active_layers() + + @property + def is_fitted(self): + try: + return self.ekfac_representation is not None + except AttributeError: + return False + + def _parse_active_layers(self) -> Dict[str, torch.nn.Module]: + active_layers: Dict[str, torch.nn.Module] = {} + for m_name, module in self.model.named_modules(): + if len(list(module.children())) == 0 and len(list(module.parameters())) > 0: + layer_requires_grad = [ + param.requires_grad for param in module.parameters() + ] + if all(layer_requires_grad): + active_layers[m_name] = module + elif any(layer_requires_grad): + raise RuntimeError( + f"Layer {m_name} has some parameters that require grad and some that do not." + f"This is not supported. Please set all parameters of the layer to require grad." + ) + return active_layers + + @staticmethod + def init_layer_kfac_blocks( + module: torch.nn.Module, + ) -> Tuple[torch.Tensor, torch.Tensor]: + if isinstance(module, nn.Linear): + with_bias = module.bias is not None + sG = module.out_features + sA = module.in_features + int(with_bias) + forward_x_layer = torch.zeros((sA, sA), device=module.weight.device) + grad_y_layer = torch.zeros((sG, sG), device=module.weight.device) + else: + raise NotImplementedError( + f"Only Linear layers are supported, but found module {module} requiring grad." + ) + return forward_x_layer, grad_y_layer + + @staticmethod + def get_layer_kfac_hooks( + m_name: str, + module: torch.nn.Module, + forward_x: Dict[str, torch.Tensor], + grad_y: Dict[str, torch.Tensor], + ) -> Tuple[Callable, Callable]: + if isinstance(module, nn.Linear): + with_bias = module.bias is not None + + def input_hook(m, x, y): + x = x[0] + if with_bias: + x = torch.cat( + (x, torch.ones((x.shape[0], 1), device=module.weight.device)), + dim=1, + ) + forward_x[m_name] += torch.mm(x.t(), x) + + def grad_hook(m, m_grad, m_out): + m_out = m_out[0] + grad_y[m_name] += torch.mm(m_out.t(), m_out) + + else: + raise NotImplementedError( + f"Only Linear layers are supported, but found module {module} requiring grad." + ) + return input_hook, grad_hook + + def get_kfac_blocks( + self, + data: DataLoader, + ) -> Tuple[Dict[str, torch.Tensor], Dict[str, torch.Tensor]]: + forward_x = {} + grad_y = {} + hooks = [] + data_len = 0 + + for m_name, module in self.active_layers.items(): + forward_x[m_name], grad_y[m_name] = self.init_layer_kfac_blocks(module) + layer_input_hook, layer_grad_hook = self.get_layer_kfac_hooks( + m_name, module, forward_x, grad_y + ) + hooks.append(module.register_forward_hook(layer_input_hook)) + hooks.append(module.register_full_backward_hook(layer_grad_hook)) + + for x, _ in data: + data_len += x.shape[0] + pred_y = self.model(x) + loss = self.loss(pred_y) + loss.backward() + + for key in forward_x.keys(): + forward_x[key] /= data_len + grad_y[key] /= data_len + + for hook in hooks: + hook.remove() + + return forward_x, grad_y + + def fit(self, data: DataLoader) -> EkfacInfluence: + forward_x, grad_y = self.get_kfac_blocks(data) + layers_evecs_a = {} + layers_evect_g = {} + layers_diags = {} + for key in self.active_layers.keys(): + evals_a, evecs_a = torch.linalg.eigh(forward_x[key]) + evals_g, evecs_g = torch.linalg.eigh(grad_y[key]) + layers_evecs_a[key] = evecs_a + layers_evect_g[key] = evecs_g + layers_diags[key] = torch.kron(evals_g.view(-1, 1), evals_a.view(-1, 1)) + + self.ekfac_representation = EkfacRepresentation( + self.active_layers.keys(), + self.active_layers.values(), + layers_evect_g.values(), + layers_evecs_a.values(), + layers_diags.values(), + ) + return self + + @staticmethod + def init_layer_diag(module: torch.nn.Module) -> torch.Tensor: + if isinstance(module, nn.Linear): + with_bias = module.bias is not None + sG = module.out_features + sA = module.in_features + int(with_bias) + layer_diag = torch.zeros((sA * sG), device=module.weight.device) + else: + raise NotImplementedError( + f"Only Linear layers are supported, but found module {module} requiring grad." + ) + return layer_diag + + def get_layer_diag_hooks( + self, + m_name: str, + module: torch.nn.Module, + last_x_kfe: Dict[str, torch.Tensor], + diags: Dict[str, torch.Tensor], + ) -> Tuple[Callable, Callable]: + + evecs_a, evecs_g = self.ekfac_representation.get_layer_evecs() + if isinstance(module, nn.Linear): + with_bias = module.bias is not None + + def input_hook(m, x, y): + x = x[0] + if with_bias: + x = torch.cat( + (x, torch.ones((x.shape[0], 1), device=module.weight.device)), + dim=1, + ) + last_x_kfe[m_name] = torch.mm(x, evecs_a[m_name]) + + def grad_hook(m, m_grad, m_out): + m_out = m_out[0] + gy_kfe = torch.mm(m_out, evecs_g[m_name]) + diags[m_name] += torch.mm( + gy_kfe.t() ** 2, last_x_kfe[m_name] ** 2 + ).view(-1) + + else: + raise NotImplementedError( + f"Only Linear layers are supported, but found module {module} requiring grad." + ) + return input_hook, grad_hook + + def update_diag( + self, + data: DataLoader, + ) -> EkfacInfluence: + + if not self.is_fitted: + raise ValueError( + "EkfacInfluence must be fitted before calling update_diag on it. " + "Please call fit first." + ) + diags = {} + last_x_kfe: Dict[str, torch.Tensor] = {} + hooks = [] + data_len = 0 + + for m_name, module in self.active_layers.items(): + diags[m_name] = self.init_layer_diag(module) + input_hook, grad_hook = self.get_layer_diag_hooks( + m_name, module, last_x_kfe, diags + ) + hooks.append(module.register_forward_hook(input_hook)) + hooks.append(module.register_full_backward_hook(grad_hook)) + + for x, _ in data: + data_len += x.shape[0] + pred_y = self.model(x) + loss = self.loss(pred_y) + loss.backward() + + for key in diags.keys(): + diags[key] /= data_len + + for hook in hooks: + hook.remove() + + self.ekfac_representation.diags = diags.values() + + return self + + def _solve_hvp(self, rhs: torch.Tensor) -> torch.Tensor: + x = rhs.clone() + start_idx = 0 + for _, (_, evecs_a, evecs_g, diag) in self.ekfac_representation: + end_idx = start_idx + diag.shape[0] + rhs_layer = rhs[:, start_idx : end_idx - evecs_g.shape[0]].reshape( + rhs.shape[0], evecs_g.shape[0], -1 + ) + bias_layer_b = rhs[:, end_idx - evecs_g.shape[0] : end_idx] + rhs_layer = torch.cat([rhs_layer, bias_layer_b.unsqueeze(2)], dim=2) + v_kfe = torch.einsum( + "bij,jk->bik", + torch.einsum("ij,bjk->bik", evecs_g.t(), rhs_layer), + evecs_a, + ) + inv_diag = 1 / ( + diag.reshape(*v_kfe.shape[1:]) + self.hessian_regularization + ) + inv_kfe = torch.einsum("bij,ij->bij", v_kfe, inv_diag) + inv = torch.einsum( + "bij,jk->bik", + torch.einsum("ij,bjk->bik", evecs_g, inv_kfe), + evecs_a.t(), + ) + x[:, start_idx:end_idx] = torch.cat( + [inv[:, :, :-1].reshape(rhs.shape[0], -1), inv[:, :, -1]], dim=1 + ) + start_idx = end_idx + x.detach_() + return x + + def to(self, device: torch.device): + return EkfacInfluence( + self.model.to(device), self.ekfac_representation.to(device) + ) diff --git a/src/pydvl/influence/torch/util.py b/src/pydvl/influence/torch/util.py index 757cb7fbb..12a1d03b7 100644 --- a/src/pydvl/influence/torch/util.py +++ b/src/pydvl/influence/torch/util.py @@ -1,5 +1,6 @@ import logging import math +from dataclasses import dataclass from functools import partial from typing import ( Collection, @@ -453,3 +454,57 @@ def __call__( ) ) ) + + +@dataclass(frozen=True) +class EkfacRepresentation: + r""" + Container class for the EKFAC representation of the Hessian. + It can be iterated over to get the layers names and their corresponding module, + eigenvectors and diagonal elements of the factorized Hessian matrix. + + Args: + layer_names: Names of the layers. + layers_module: The layers. + evecs_a: The a eigenvectors of the ekfac representation. + evecs_g: The g eigenvectors of the ekfac representation. + diags: The diagonal elements of the factorized Hessian matrix. + """ + layer_names: Iterable[str] + layers_module: Iterable[torch.nn.Module] + evecs_a: Iterable[torch.Tensor] + evecs_g: Iterable[torch.Tensor] + diags: Iterable[torch.Tensor] + + def __iter__(self): + return iter( + zip( + self.layer_names, + zip(self.layers_module, self.evecs_g, self.evecs_a, self.diags), + ) + ) + + def get_layer_evecs(self): + evecs_a_dict = {layer_name: evec_a for layer_name, (_, evec_a, _, _) in self} + evecs_g_dict = {layer_name: evec_g for layer_name, (_, _, evec_g, _) in self} + return evecs_a_dict, evecs_g_dict + + def to(self, device: torch.device): + return EkfacRepresentation( + self.layer_names, + [layer.to(device) for layer in self.layers_module], + [evec_a.to(device) for evec_a in self.evecs_a], + [evec_g.to(device) for evec_g in self.evecs_g], + [diag.to(device) for diag in self.diags], + ) + + +def empirical_cross_entropy_loss_fn( + model_output: torch.Tensor, *args, **kwargs +) -> torch.Tensor: + probs_ = torch.softmax(model_output, dim=1) + log_probs_ = torch.log(probs_) + log_probs_ = torch.where( + torch.isfinite(log_probs_), log_probs_, torch.zeros_like(log_probs_) + ) + return torch.sum(log_probs_ * probs_.detach() ** 0.5) From 5cd81f852b5f46f5b204159eaeec7aeff57d51cd Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Tue, 19 Dec 2023 18:55:35 +0100 Subject: [PATCH 05/87] fix EkfacRepresentation ordering --- src/pydvl/influence/torch/influence_function_model.py | 2 +- src/pydvl/influence/torch/util.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index 330ca0047..edabd01a1 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -1011,8 +1011,8 @@ def fit(self, data: DataLoader) -> EkfacInfluence: self.ekfac_representation = EkfacRepresentation( self.active_layers.keys(), self.active_layers.values(), - layers_evect_g.values(), layers_evecs_a.values(), + layers_evect_g.values(), layers_diags.values(), ) return self diff --git a/src/pydvl/influence/torch/util.py b/src/pydvl/influence/torch/util.py index 12a1d03b7..8c87b24d0 100644 --- a/src/pydvl/influence/torch/util.py +++ b/src/pydvl/influence/torch/util.py @@ -480,7 +480,7 @@ def __iter__(self): return iter( zip( self.layer_names, - zip(self.layers_module, self.evecs_g, self.evecs_a, self.diags), + zip(self.layers_module, self.evecs_a, self.evecs_g, self.diags), ) ) From e65937ad0fc7061cda595791ca3387c58b0c3f14 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Wed, 20 Dec 2023 00:25:45 +0100 Subject: [PATCH 06/87] minor changes to torch.py --- notebooks/influence_wine.ipynb | 2 +- notebooks/support/torch.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/notebooks/influence_wine.ipynb b/notebooks/influence_wine.ipynb index 9645ffa99..6c08878f9 100644 --- a/notebooks/influence_wine.ipynb +++ b/notebooks/influence_wine.ipynb @@ -193,7 +193,7 @@ "outputs": [], "source": [ "training_data, val_data, test_data, feature_names = load_wine_dataset(\n", - " train_size=0.3, test_size=0.6\n", + " train_size=0.6, test_size=0.3\n", ")" ] }, diff --git a/notebooks/support/torch.py b/notebooks/support/torch.py index d90ea4895..018b6807c 100644 --- a/notebooks/support/torch.py +++ b/notebooks/support/torch.py @@ -74,7 +74,7 @@ def __init__( layers.append(nn.Tanh()) layers.pop() - layers.append(nn.Softmax(dim=-1)) + # layers.append(nn.Softmax(dim=-1)) self.layers = nn.Sequential(*layers) From d16e5df1c2e624066bacd3f1907ef4c1cc51c06e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Wed, 20 Dec 2023 21:05:59 +0100 Subject: [PATCH 07/87] Use different loss function in init of EkfacInfluence to fix broken gradient computation --- src/pydvl/influence/torch/influence_function_model.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index edabd01a1..a74565444 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -12,7 +12,7 @@ import torch from torch import nn as nn -from torch.utils.data import DataLoader +from torch.utils.data import DataLoader, TensorDataset from tqdm.auto import tqdm from pydvl.utils.progress import log_duration @@ -892,7 +892,7 @@ def __init__( hessian_regularization: float = 0.0, ): - super().__init__(model, empirical_cross_entropy_loss_fn) + super().__init__(model, torch.nn.functional.cross_entropy) self.hessian_regularization = hessian_regularization self.active_layers = self._parse_active_layers() @@ -984,7 +984,7 @@ def get_kfac_blocks( for x, _ in data: data_len += x.shape[0] pred_y = self.model(x) - loss = self.loss(pred_y) + loss = empirical_cross_entropy_loss_fn(pred_y) loss.backward() for key in forward_x.keys(): From eb269803ed21ba677c77d5b1967ed1ebb223f25f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Wed, 20 Dec 2023 20:47:39 +0100 Subject: [PATCH 08/87] Fix wrong averaging in hessian computation --- src/pydvl/influence/torch/functional.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/pydvl/influence/torch/functional.py b/src/pydvl/influence/torch/functional.py index 0d88e1197..544f0eff0 100644 --- a/src/pydvl/influence/torch/functional.py +++ b/src/pydvl/influence/torch/functional.py @@ -407,6 +407,7 @@ def hessian( flat_params = flatten_dimensions(params.values()) if use_hessian_avg: + n_samples = 0 hessian = to_model_device( torch.zeros((n_parameters, n_parameters), dtype=model_dtype), model ) @@ -418,11 +419,12 @@ def flat_input_batch_loss_function( return blf(align_with_model(p, model), t_x, t_y) for x, y in iter(data_loader): - hessian += torch.func.hessian(flat_input_batch_loss_function)( + n_samples += x.shape[0] + hessian += x.shape[0] * torch.func.hessian(flat_input_batch_loss_function)( flat_params, to_model_device(x, model), to_model_device(y, model) ) - hessian /= len(data_loader) + hessian /= n_samples else: def flat_input_empirical_loss(p: torch.Tensor): From 23517554eafdc3867288962abe2376591144b6e7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Wed, 20 Dec 2023 21:12:02 +0100 Subject: [PATCH 09/87] Use correct loss in update_diag method of EkfacInfluence, make EkfacRepresentation not frozen --- src/pydvl/influence/torch/influence_function_model.py | 2 +- src/pydvl/influence/torch/util.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index a74565444..d1cbced53 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -1090,7 +1090,7 @@ def update_diag( for x, _ in data: data_len += x.shape[0] pred_y = self.model(x) - loss = self.loss(pred_y) + loss = empirical_cross_entropy_loss_fn(pred_y) loss.backward() for key in diags.keys(): diff --git a/src/pydvl/influence/torch/util.py b/src/pydvl/influence/torch/util.py index 8c87b24d0..550387fab 100644 --- a/src/pydvl/influence/torch/util.py +++ b/src/pydvl/influence/torch/util.py @@ -456,7 +456,7 @@ def __call__( ) -@dataclass(frozen=True) +@dataclass class EkfacRepresentation: r""" Container class for the EKFAC representation of the Hessian. From 46a11047d523b821b6ef481a3d32b03fdb705873 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristof=20Schr=C3=B6der?= Date: Thu, 21 Dec 2023 12:24:19 +0100 Subject: [PATCH 10/87] =?UTF-8?q?Bump=20version:=200.8.0=20=E2=86=92=200.8?= =?UTF-8?q?.1.dev0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .bumpversion.cfg | 2 +- setup.py | 2 +- src/pydvl/__init__.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.bumpversion.cfg b/.bumpversion.cfg index d059d740e..e6cb651b4 100644 --- a/.bumpversion.cfg +++ b/.bumpversion.cfg @@ -1,5 +1,5 @@ [bumpversion] -current_version = 0.8.0 +current_version = 0.8.1.dev0 commit = False tag = False allow_dirty = False diff --git a/setup.py b/setup.py index c0d6766f6..37631787e 100644 --- a/setup.py +++ b/setup.py @@ -12,7 +12,7 @@ package_data={"pydvl": ["py.typed"]}, packages=find_packages(where="src"), include_package_data=True, - version="0.8.0", + version="0.8.1.dev0", description="The Python Data Valuation Library", install_requires=[ line diff --git a/src/pydvl/__init__.py b/src/pydvl/__init__.py index 84ff4a221..370991569 100644 --- a/src/pydvl/__init__.py +++ b/src/pydvl/__init__.py @@ -7,4 +7,4 @@ The two main modules you will want to look at are [value][pydvl.value] and [influence][pydvl.influence]. """ -__version__ = "0.8.0" +__version__ = "0.8.1.dev0" From 43a093316a1062523e5ab1b60d3a6f1428f7c3f9 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Thu, 21 Dec 2023 18:31:38 +0100 Subject: [PATCH 11/87] ekfac tests --- notebooks/influence_wine.ipynb | 1 + notebooks/support/torch.py | 2 - tests/influence/torch/test_influence_model.py | 124 +++++++++++++++++- 3 files changed, 123 insertions(+), 4 deletions(-) diff --git a/notebooks/influence_wine.ipynb b/notebooks/influence_wine.ipynb index 6c08878f9..9686b0c18 100644 --- a/notebooks/influence_wine.ipynb +++ b/notebooks/influence_wine.ipynb @@ -859,6 +859,7 @@ " hessian_regularization=0.1,\n", ")\n", "ekfac_influence_model = ekfac_influence_model.fit(training_data_loader)\n", + "ekfac_influence_model = ekfac_influence_model.update_diag(training_data_loader)\n", "ekfac_train_influences = ekfac_influence_model.influences(\n", " *test_data, *training_data, mode=\"up\"\n", ")\n", diff --git a/notebooks/support/torch.py b/notebooks/support/torch.py index 018b6807c..cf3dfc6a8 100644 --- a/notebooks/support/torch.py +++ b/notebooks/support/torch.py @@ -74,8 +74,6 @@ def __init__( layers.append(nn.Tanh()) layers.pop() - # layers.append(nn.Softmax(dim=-1)) - self.layers = nn.Sequential(*layers) def forward(self, x: torch.Tensor) -> torch.Tensor: diff --git a/tests/influence/torch/test_influence_model.py b/tests/influence/torch/test_influence_model.py index 2ea33b75d..5ee6915e2 100644 --- a/tests/influence/torch/test_influence_model.py +++ b/tests/influence/torch/test_influence_model.py @@ -10,6 +10,7 @@ ArnoldiInfluence, CgInfluence, DirectInfluence, + EkfacInfluence, LissaInfluence, ) from tests.influence.torch.conftest import minimal_training @@ -19,6 +20,7 @@ import torch import torch.nn.functional as F from pytest_cases import fixture, parametrize, parametrize_with_cases +from scipy.stats import pearsonr, spearmanr from torch import nn from torch.utils.data import DataLoader, TensorDataset @@ -61,6 +63,21 @@ def create_simple_nn_regr(): return nn.Sequential(nn.Linear(10, 10), nn.Linear(10, 3), nn.Linear(3, 1)) +def create_conv1d_no_grad(): + return nn.Sequential( + nn.Conv1d(in_channels=5, out_channels=3, kernel_size=2).requires_grad_(False), + nn.Flatten(), + nn.Linear(6, 3), + ) + + +def create_simple_nn_no_grad(): + return nn.Sequential( + nn.Linear(10, 10).requires_grad_(False), + nn.Linear(10, 5), + ) + + class TestCase(NamedTuple): module_factory: Callable[[], nn.Module] input_dim: Tuple[int, ...] @@ -146,6 +163,26 @@ def case_simple_nn_pert(self) -> TestCase: mode=InfluenceMode.Perturbation, ) + def case_conv1d_no_grad_up(self) -> TestCase: + return TestCase( + module_factory=create_conv1d_no_grad, + input_dim=(5, 3), + output_dim=3, + loss=nn.CrossEntropyLoss(), + mode=InfluenceMode.Up, + ) + + def case_simple_nn_class_up(self) -> TestCase: + return TestCase( + module_factory=create_simple_nn_no_grad, + input_dim=(10,), + output_dim=5, + loss=nn.CrossEntropyLoss(), + mode=InfluenceMode.Up, + train_data_len=100, + test_data_len=30, + ) + @fixture @parametrize_with_cases( @@ -169,9 +206,17 @@ def model_and_data( torch.Tensor, ]: x_train = torch.rand((test_case.train_data_len, *test_case.input_dim)) - y_train = torch.rand((test_case.train_data_len, test_case.output_dim)) x_test = torch.rand((test_case.test_data_len, *test_case.input_dim)) - y_test = torch.rand((test_case.test_data_len, test_case.output_dim)) + if isinstance(test_case.loss, nn.CrossEntropyLoss): + y_train = torch.randint( + 0, test_case.output_dim, (test_case.train_data_len,), dtype=torch.long + ) + y_test = torch.randint( + 0, test_case.output_dim, (test_case.test_data_len,), dtype=torch.long + ) + else: + y_train = torch.rand((test_case.train_data_len, test_case.output_dim)) + y_test = torch.rand((test_case.test_data_len, test_case.output_dim)) train_dataloader = DataLoader( TensorDataset(x_train, y_train), batch_size=test_case.batch_size @@ -474,3 +519,78 @@ def test_influences_arnoldi( arnoldi_influence.influences(x_test, y_test, x=x_train, mode=test_case.mode) with pytest.raises(ValueError): arnoldi_influence.influences(x_test, y_test, y=y_train, mode=test_case.mode) + + +def test_influences_ekfac( + test_case: TestCase, + model_and_data: Tuple[ + torch.nn.Module, + Callable[[torch.Tensor, torch.Tensor], torch.Tensor], + torch.Tensor, + torch.Tensor, + torch.Tensor, + torch.Tensor, + ], + direct_influences, + direct_sym_influences, +): + model, loss, x_train, y_train, x_test, y_test = model_and_data + + train_dataloader = DataLoader( + TensorDataset(x_train, y_train), batch_size=test_case.batch_size + ) + + ekfac_influence = EkfacInfluence( + model, + hessian_regularization=test_case.hessian_reg, + ) + + with pytest.raises(NotFittedException): + ekfac_influence.influences( + x_test, y_test, x_train, y_train, mode=test_case.mode + ) + + with pytest.raises(NotFittedException): + ekfac_influence.influence_factors(x_test, y_test) + + def is_active_layers_linear(): + for module in model.modules(): + if not isinstance(module, nn.Linear): + param_requires_grad = [p.requires_grad for p in module.parameters()] + if any(param_requires_grad): + with pytest.raises(NotImplementedError): + ekfac_influence.fit(train_dataloader) + return False + return True + + def check_correlations(true_infl, approx_infl, threshold=0.95): + for axis in range(0, true_infl.ndim): + mean_true_infl = np.mean(true_infl, axis=axis) + mean_approx_infl = np.mean(approx_infl, axis=axis) + assert np.all( + pearsonr(mean_true_infl, mean_approx_infl).statistic > threshold + ) + assert np.all( + spearmanr(mean_true_infl, mean_approx_infl).statistic > threshold + ) + + if is_active_layers_linear and isinstance(loss, nn.CrossEntropyLoss): + ekfac_influence = ekfac_influence.fit(train_dataloader) + ekfac_influence = ekfac_influence.update_diag(train_dataloader) + ekfac_influence_values = ekfac_influence.influences( + x_test, y_test, x_train, y_train, mode=test_case.mode + ).numpy() + + ekfac_self_influence = ekfac_influence.influences( + x_train, y_train, mode=test_case.mode + ).numpy() + + ekfac_factors = ekfac_influence.influence_factors(x_test, y_test) + + influence_from_factors = ekfac_influence.influences_from_factors( + ekfac_factors, x_train, y_train, mode=test_case.mode + ).numpy() + + assert np.allclose(ekfac_influence_values, influence_from_factors) + check_correlations(direct_influences, ekfac_influence_values) + check_correlations(direct_sym_influences, ekfac_self_influence) From 3e6e46f9e86fe0bbbf9a0528760ed17226f5566e Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Thu, 21 Dec 2023 18:36:13 +0100 Subject: [PATCH 12/87] including scatter plot --- notebooks/influence_wine.ipynb | 131 +++++++++++++++++---------------- 1 file changed, 69 insertions(+), 62 deletions(-) diff --git a/notebooks/influence_wine.ipynb b/notebooks/influence_wine.ipynb index 9686b0c18..4ead5a255 100644 --- a/notebooks/influence_wine.ipynb +++ b/notebooks/influence_wine.ipynb @@ -45,7 +45,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 1, "id": "cef17bfc", "metadata": { "editable": true, @@ -56,23 +56,14 @@ "hide-input" ] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], + "outputs": [], "source": [ "%load_ext autoreload" ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 2, "id": "be813151", "metadata": { "editable": true, @@ -81,7 +72,16 @@ }, "tags": [] }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/fabio/miniconda3/envs/pydvl_env/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], "source": [ "%autoreload\n", "%matplotlib inline\n", @@ -110,7 +110,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 3, "id": "02254f9c", "metadata": { "editable": true, @@ -133,7 +133,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 4, "id": "a656363e", "metadata": { "editable": true, @@ -153,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 5, "id": "df5159e6", "metadata": { "editable": true, @@ -181,7 +181,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 6, "id": "0d3e96ca", "metadata": { "editable": true, @@ -199,7 +199,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 7, "id": "cac906e3-aed6-4d11-b563-1b9a91132d29", "metadata": { "editable": true, @@ -228,7 +228,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 8, "id": "7b95fdf0", "metadata": {}, "outputs": [], @@ -250,7 +250,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 9, "id": "816f688d", "metadata": {}, "outputs": [], @@ -275,7 +275,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 10, "id": "00dc59af", "metadata": { "editable": true, @@ -291,7 +291,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Model fitting: 100%|██████████| 300/300 [00:01<00:00, 272.65it/s]\n" + "Model fitting: 100%|██████████| 300/300 [00:01<00:00, 173.02it/s]\n" ] } ], @@ -333,7 +333,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 11, "id": "f4b57b77", "metadata": { "editable": true, @@ -347,7 +347,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABSMAAAKvCAYAAACRY9qRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABrCElEQVR4nO3dd3glV30//vfxrnu5NjZuuFwIBgwGXOhgcAADiei9ht5TCCURab+BJKAAIQlfSEIHh2Yg1IgSIHSMAWMDDmBMERiMu31d1/buzu+POzcry9KutNJt0uv1PPOMzsy5M59dZi/r954zp9R1HQAAAACAftth2AUAAAAAAGuDMBIAAAAAGAhhJAAAAAAwEMJIAAAAAGAghJEAAAAAwEAIIwEAAACAgRBGAgAAAAADIYwEAAAAAAZi/bALGLZSSklycJIrhl0LAAAAAIypPZOcW9d1vbVOaz6MTDeI/PWwiwAAAACAMXdIkt9srYMwcsuIyENidCQAAAAALNWe6Q7222a2Jozc4oq6ri8fdhEAAAAAME66b0FcHAvYAAAAAAADIYwEAAAAAAZCGAkAAAAADIQwEgAAAAAYCAvYAAAAADCyTjvttB2S7JNk3xhYN2ibk/z2uOOO2+Yq2YtV6rpeqWuNpVLKXkk6SVpW0wYAAAAYDU0I+bAddtjhJaWUA0spBtUNXl3X9fWbNm06KcmrjjvuuM3zdVpKvuZ/RAAAAABG0V/suOOOz9t7771Lq9W6Yv369RtKKcOuaU2p67pcddVVu5133nnPv/7665Pk75Z7TSMjjYwEAAAAGCmnnXbaXuvWrfvGQQcdtPsBBxxw8bDrWesuuOCCfc8999zrN23adNx8U7aXkq+ZZw8AAADAqDmwlLLHHnvscdWwCyHZfffdry6l7JjkoOVeSxgJAAAAwKjZIUlMyx4NpZQ6SckKZInCSAAAAABgIISRAAAAAMBACCMBAAAAYJV51KMe1b7ZzW52+2HXMdf6YRcAAAAAAGtFKeW4xfT75Cc/+ZMHP/jBN1q5etwJIwEAAABgQN70pjf9Ynb7ve99777f+MY39pp7/I53vOM1y7nP+973vl9u3rx5OZfoC2EkAAAAAAzIC17wgktmt7/5zW/u8Y1vfONGx+e64oordthzzz0XnS7uvPPO9fbW2E/eGQkAAAAAI+Qud7nLrY844ojbffWrX93tTne606133XXXY/7kT/7kZknynve8Z+8TTjjhlvvvv/8ddtppp2MPPfTQo172spcdtHHjxhtcY+47I88666ydSinH/c3f/M0Br3vd6/Y79NBDj9ppp52OPeqoo4788pe/vNugfm1GRgIAAADAiLnsssvWPexhDzvioQ996CWPf/zjLz7wwAM3Jsm73/3ufXfffffNz3ve887fY489Nn/pS1/a83Wve93Bl19++bo3v/nNv97WdT/84Q/f5Kqrrlr31Kc+9cJSSt74xjce+LjHPe6Wv/zlL38wiNGUwkgAAAAAxsLmus7V124cmZm+u+28fvMOpfTl2hdddNGOr3nNa375spe97KLZxz/60Y/+fI899vi/0PDP/uzPLnziE5942EknnXTTf/7nf/7NrrvuutVA8be//e1OP/nJT8686U1vuilJbnOb22x48pOffMuPfOQjez3hCU/o9OUXM4swEgAAAICxcPW1G3c4qvrvY4ZdR8+Z1QNO32OXHfuySsxOO+1U/9Ef/dHFc4/PDiIvvfTSHTZs2LDD8ccff+X73//+m55xxhm73P3ud9/qwjcPfvCDL+0FkUnygAc84Mok+dnPfrbzSta/EGEkAAAAAIyY/fff/7pddtnlRqMcv/Od7+zy8pe//Gbf/OY397zyyivXzT532WWXrZvbf67DDjvsutntXjB56aWXbvOzK0EYCQAAAMBY2G3n9ZvPrB5w+rDr6Nlt5/V9GRWZJPMFkRdddNG6E0888da777775j/7sz8795a3vOW1u+666+bvfOc7u/393//9IZs2bdrmnPF169bNO427ruv+zDefQxgJAAAAwFjYoZT0a1r0OPj0pz+952WXXbb+fe9731m/93u/d2Xv+KCmWK+EkXnhZ5KUUu5dSvlkKeXcUkpdSnn4NvofVEp5XynlJ6WUzaWUfx5MpeOjPTm9Q3ty+mHtyen7DbsWAAAAALZfb1Tj5s1b8tgNGzaUt73tbfsPraglGrWRkbsn+V6SdyT5yCL675zkwiR/l+RP+1jXOPvDJP+S5HvtyeljZqYm+r5EOwAAAAAr7773ve+Ve+2116bnPOc5N3/2s599QSmlPvnkk/et6/GJe0ZqZGRd15+u6/qv6rr+6CL7z9R1/Sd1XZ+UpO9Lj4+p9yS5Kskdk/zekGsBAAAAYDsdeOCBmz784Q+ffdOb3vT6f/iHfzj4TW9604H3uc99Ln/Vq17162HXtlhlVJPTUkqd5BF1XX9skf2/lOSMuq5ftI1+O6c7orJnzyS/TtKq6/ry7Sp2xLUnp1+X5CVJvjYzNXH8sOsBAAAA2JrTTjvtNuvXr//MEUccceVuu+22Ydj1rHVXX331LmefffYeGzdufNBxxx3347nnSyl7pTtQcJv52kiNjByQl6f7m9PbxiY5XobXJ7kuyb3ak9PCSAAAAACGYi2Gka9O0pq1HTLccvpvZmri3CTvapovH2IpAAAAAKxhay6MrOv62rquL+9tSa4Ydk0D8pokm5P8Xnty+phhFwMAAADA2rPmwsg1p2rtkar16JldnnhUkpObo5PDLAkAAACAtWmkwshSyh6llKNLKUc3h27etA9rzr+6lHLSnM/0+u+R5KZN+7YDLXy0PTbJh5L8TZKp5thj2pPTtxpeSQAAAACsRSMVRia5U5LTmy3pLrxyepJXNu2Dkhw25zO9/scleWLz86f6Xun4+GS607OPndnliZcl+a8kJd1wEgAAAAAGZqTCyLquv1TXdZlne1pz/ml1XZ8w5zPz9W8PofzRVHUuTPL1pvWwJFXz85Pak9PHDaUmAAAAANakkQoj6ZuPNfuHz0xNnJbkvU37de3J6TKckgAAAABYa4SRa8PHmv19UrX2TfIXSa5NckKSBw+pJgAAAADWGGHkWlB1fp7k+0nWJZmYmZr4VZJ/as6+tj05vePQagMAAABgzRBGrh0fa/YPb/avTnJhklsnefYQ6gEAAABgjRFGrh0fa/YPStXabWZq4vJsWczmFe3J6dZQqgIAAABgu5111lk7lVKOe8Mb3rDvsGtZDGHk2nFGkl8m2TXJic2xtyb5cZL9krxyOGUBAAAArB33ve99b7nrrrsec+mlly6Yyz30oQ+9+Y477njseeedt26QtQ2CMHKtqDp15kzVnpmauD7JHzfH/rA9OX3c4AsDAAAAWDue8IQnXLxhw4Yd3vve9+4z3/krrrhih89//vN7H3/88ZcfeOCBmwZdX78JI9eWjzX7h6RqrU+SmamJzyV5f7rPwpvbk9OrLnEHAAAAGBVPeMITLtt99903n3zyyTeZ7/z73ve+va+55podnvCEJ1w86NoGQRi5tnwtycVJ9k1yz1nHX5ykk+S4JC8cQl0AAAAAa8Iee+xRP/CBD7z0lFNO2fM3v/nN+rnnTz755Jvsvvvum+9///tf+ZznPOeQW93qVrfdbbfdjtljjz2Oufe9733EKaecsusw6l4pwsi1pOpsTPLJpvWo3uGZqYnzkvx50/y79uT0zQZdGgAAAMBa8eQnP/mSTZs2lXe/+903mKp9/vnnr/vqV7+61wMe8IBLzznnnB0/85nP7H3iiSd2XvnKV57z/Oc//7yzzjpr1wc84AG3npmZ2XFYtS/XjdJXVr0PJXlaksemar24CSiT7mI2T01y9yT/kuTRwykPAAAAYAH15uS6q0ZncN1Ou29OWXo5D3nIQy6/6U1vev2HPvShff/iL/7iwt7xk046aZ+NGzeWJz/5yZfc+c53vuYXv/jFmevWbXmj3rOe9ayL73CHOxz1pje9ab/Xvva1v12ZX8RgCSPXns+lO1X7gCS/27QzMzWxuT05/bwk303yqPbk9MNmpiY+PrwyAQAAAOa47qod8upDjhl2Gf/n5b8+PTvvuXmpH1u/fn0e+tCHXvL2t7/9gLPOOmunW9/61tclyQc/+MF99913340PfehDL1+/fktst3Hjxlx00UXr9tprr83tdnvDGWecsdsK/ioGanSSZAaj6lyf5INN60mzT81MTXw/yWub5r+2J6f3HmBlAAAAAGvGU5/61EuS5J3vfOdNkuRnP/vZjqeddtoeD33oQy9Zv359Nm3alFe84hX7H3744Uftsssuxx100EFHH3zwwXf8yU9+susVV1wxtgsQGxm5Nr0vyfOTPDJV6/mpOtfMOvfKJI9Mcqskr0nynCHUBwAAAHBjO+2+OS//9enDLuP/7LT7kkdF9hx//PFX3/zmN9/wkY985CZTU1Pnvetd77pJXdd56lOfenGSvPzlLz/ota997cGPecxjLrr//e//m/3222/TDjvsUL/sZS87bPPmzWXlfhGDJYxcm76R5JdJDk8ykeTDvRMzUxPXtCenn5XkK0me3Z6c/sDM1MT/DKdMAAAAgFnKDtmeadGj6tGPfvQlr33taw8+9dRTd/3whz+87+GHH37tfe5zn6uT5BOf+MQ+d73rXa/44Ac/+MvZn3nuc5+7bp999tk4/xVHn2naa1HV2Zzk/U3riXNPz0xNfDXJm5rmW9uT07sPqjQAAACAteIZz3jGxUnyl3/5lwf/+Mc/3vVRj3rUxb1z69atq+u6vkH/d7zjHftccMEFY7uSdiKMXMve1+wnUrX2mef8y5Ock+QW6U7dBgAAAGAF3eY2t7numGOOueoLX/jC3kny9Kc//ZLeuQc84AGdb33rW3s++tGPbv/jP/7jfk972tMOffGLX3z4IYcccu3QCl4Bwsi1qur8IMkPkuyU7jsib2BmauKKJM9tmi9qT07fdYDVAQAAAKwJj33sYy9Oktvf/vZXHXXUUf8XNL7qVa/67bOf/ezzv/KVr+z1V3/1V4f+4Ac/2O0///M/zz7ooIOuH161y1fmDvdca0opeyXpJGnVdX35sOsZqKo1meTVSf4nVed+83VpT06flOQpSf43ybEzUxPXDbBCAAAAYA067bTTbrN+/frPHHHEEVfutttuG4Zdz1p39dVX73L22WfvsXHjxgcdd9xxP557fin5mpGRa9sHmv3vpmodvECfP01yYZLbpTt1GwAAAAC2izByLas6M0m+nqSkO/rxRmamJi5O8odN8y/bk9NHDaY4AAAAAFYbYSRvb/bPStVa6Hn4UJKPJdkxyTvak9PrBlEYAAAAAKuLMJIPJrk8yS2TnDBfh5mpiTrJC9Od+3/nJH88qOIAAAAAWD2EkWtd1bkqyfua1rMX6jYzNXFukpc2zVe2J6cXesckAAAAAMxLGEmSvLXZPzJVa7+t9HtHkm8m2SPJa/teFQAAAACrijCSpOp8N8lpSXZK8gcLdZuZmtic7mI2dZIntien7zOYAgEAAIA1pk6Suq6HXQe5wf8Om5d7LWEkPb3Rkc9O1SoLdZqZmjgtyZub5hvbk9Pr+14ZAAAAsNZcWtf1xuuvv37HYRdCsnHjxvV1XW9MctFyryWMpOf9Sa5Ocpsk99pG379McnGSo9Jd2AYAAABgxRx33HEXbN68+XuXXXZZy+jI4et0OnvWdX1eksuWe62y1v8HLaXsle4q0a26ri8fdj1DVbXenuQZSf4jVWfB6dpJ0p6cfnaSt6S7EvetZ6YmzhtAhQAAAMAacdppp524bt26f91777333HvvvTs77rjj9aUsOJmTPqjrOldeeeXu559//vrrr7/+D4877riPz9dvKfmaKbbM9pZ0w8jHpGq9KFXnkq30fUeS5yS5U5L/L8nzB1AfAAAAsEYcd9xxnzvttNNecMkllzz3sssuO7qUsvOwa1qL6rq+ctOmTe9P8smVuJ6RkUZGbtF9V+R3kxydZDJV5x+21r09OX3vJF9OsjHJkTNTEz/te40AAADAmnPaaaftn2TveOXgoG1Oct5xxx231cxsKfmaMFIYeUNV62lJ3pnk10lukapz/da6tyenP5Xk95K8f2Zq4on9LxAAAACAUbKUfE2azFwfSHJhkkOSPGIR/f+y2T+hPTl9x75VBQAAAMDYE0ZyQ1VnQ5J/a1p/sq3uM1MTpyc5uWn+fb/KAgAAAGD8CSOZz78luT7JPVK17ryI/n+dZFOSifbk9L36WhkAAAAAY0sYyY1VnfPSna6dLG505Nnprq6dJK9uT06XfpUGAAAAwPgSRrKQf2n2j0vVOngR/V+ZZEOSeyW5b9+qAgAAAGBsCSOZX9U5LcnXkqxP8vxtdZ+Zmvh1krc1zZf1sTIAAAAAxpQwkq3552b//FSt3RfR//VJNid5YHty+g59qwoAAACAsSSMZGs+luTnSfZN8oxtdZ6ZmvhFkg83zZf2rywAAAAAxpEwkoVVnU1JXtu0XpqqteMiPtXr/4T25PSh/SkMAAAAgHEkjGRb3pXk/CSHJXn8tjrPTE18J8mX0n3X5DZX4gYAAABg7RBGsnVVZ0O2rKz956lai3lmeqMjn9OenG71pzAAAAAAxo0wksX4tyRXJLldkt9fRP9PJ/nfJHsmeW4f6wIAAABgjAgj2baqc1m6gWSSTG6r+8zURJ3kdU3zT9qT0+v7VBkAAAAAY0QYyWL9c5LrktwzVetei+j/viQXJjk4yUQf6wIAAABgTAgjWZyq89sk725af76t7jNTE9fN6v+sfpUFAAAAwPgQRrIUr01SJ3lwqtbtF9H/bc3+99uT04f0rywAAAAAxoEwksWrOmcn+XDT+rNtdZ+ZmjgryVfSfc6e3sfKAAAAABgDwkiW6h+a/RNStdqL6P/WZv/M9uS05w0AAABgDRMOsTRV57Qkn0+yLsmLF/GJ/0xyWZLDk9y/f4UBAAAAMOqEkWyPqWb/rFStm26t48zUxDVJ3tM0n93XqgAAAAAYacJItsf/JDktya5J/mgR/XtTtR/Wnpzev29VAQAAADDShJEsXdWps2V05B+mau2xte4zUxPfT/LtJDsmeWqfqwMAAABgRAkj2V4fTXJ2kn2yuOnXvdGRwkgAAACANUoYyfapOpuSvKZpvSRVa6dtfOJDSa5Pcrv25PTt+lobAAAAACNJGMly/EeS3ya5WZInbq3jzNTEZUk+0zQf19+yAAAAABhFwki2X9W5Nsk/Na0/T9Xa1vP0gWb/+PbkdOlfYQAAAACMImEky/XmJJ0kt0ny0G30/WSSDUmOSHJ0f8sCAAAAYNQII1meqnN5kn9tWpOpWguOeJyZmrgiyX81zcf3uzQAAAAARoswkpXwL0muTXLXJPfeRt+Tm/3jTNUGAAAAWFuEkSxf1Tk/yTua1uQ2en8qyZVJDk83vAQAAABgjRBGslJel2Rzkgelat1hoU4zUxNXJ/lE07SqNgAAAMAaIoxkZVSdnyf5cNP6k2307q2q/dj25LRnEAAAAGCNEASxkv652T8pVWv/rfT773RX4D44yb36XRQAAAAAo0EYyUr6ZpJvJdk5yfMW6jQzNXFtko82zUcPoC4AAAAARoAwkpVTdepsGR35glStnbfS+2PN/iFW1QYAAABYG4SRrLQPJzk3yQHZ+gI1n0+yIUk7ye36XxYAAAAAwyaMZGVVneuTvLFpvShVa95RjzNTE1cl+ULTfOggSgMAAABguISR9MNb0h31eEyS47fS75PN/iF9rwgAAACAoRNGsvKqzsVJTmpaf7qVnv/V7O/anpze2urbAAAAAKwCwkj65V+a/UNTtQ6dr8PM1MRvknw3SUkyMajCAAAAABgOYST9UXV+mOTL6T5jz9hKz080e1O1AQAAAFY5YST99NZm/8xUrXUL9Om9N/IB7cnpXQZQEwAAAABDIoykn/4zyaVJDk3ywAX6nJ7kN0l2T3LCYMoCAAAAYBiEkfRP1dmQ5N1N6znzdZmZmqizZSEbU7UBAAAAVjFhJP3Wm6r94FStgxfo05uq/ZD25HQZQE0AAAAADIEwkv7qLmTztSTrkjx9gV7/k+TqdKdz33FAlQEAAAAwYMJIBuEtzf5ZqVo3euZmpiauSfKFpvmAgVUFAAAAwEAJIxmEDye5LEk7yf0X6PO5Zn/iAOoBAAAAYAiEkfRf1bkmyX80rWcv0KsXRh7fnpzetf9FAQAAADBowkgG5R3N/iGpWq15zp+V5NdJdk5y/MCqAgAAAGBghJEMyveS/CjdsPHhc0/OTE3USf67aZqqDQAAALAKCSMZjKpTJ3lf03riAr28NxIAAABgFRNGMkgfaPb3S9U6YJ7zvRW179ienJ7vPAAAAABjTBjJ4FSdnyb5dpJ1SR4z9/TM1MSFSU5vmgutug0AAADAmBJGMmi9qdpPWOC8qdoAAAAAq5QwkkH7YJI6yT1StdrznP+/RWzak9NlYFUBAAAA0HfCSAar6pyb5ItN6/Hz9Ph6kg1JDk5y20GVBQAAAED/CSMZhvc3+xtN1Z6ZmtiQ5CtN01RtAAAAgFVEGMkw/GeS65PcIVXrdvOc995IAAAAgFVIGMngVZ1Lk3y6aT1unh69MPKE9uT0ToMpCgAAAIB+E0YyLB9p9g+e59z3k1yUZLckdxpYRQAAAAD0lTCSYfl0uqtqH5OqdbPZJ2amJupseW/kfQZdGAAAAAD9IYxkOKrOBUlObVoT8/T4UrM/YRDlAAAAANB/wkiG6b+a/XxTtb/c7O/ZnpzecUD1AAAAANBHwkiGqRdG3i9Va9c5585MckmS3ZMcO9CqAAAAAOgLYSTD9P0kv053oZoTZp+YmZrYnOSrTdN7IwEAAABWAWEkw1N16ixuqrYwEgAAAGAVEEYybFvCyKpV5pzrhZH3ak9OrxtgTQAAAAD0gTCSYfufJNckOSzJUXPOfS9JJ8leSY4ebFkAAAAArDRhJMNVda5J8oWmdYOp2jNTE5uSfK1pmqoNAAAAMOaEkYwC740EAAAAWAOEkYyCTzX7u6dq7TfnXC+MPL49Oe15BQAAABhjwh2Gr+qck+T7SUqS+885+90kVybZJ8ntB1wZAAAAACtIGMmo+J9mf4Pp2DNTExuTfH2+cwAAAACMF2Eko2Jr74b03kgAAACAVUAYyaj4arM/MlVr/znnvtLsj29PTpcB1gQAAADAChJGMhqqzsVJftC07j3n7GlJrkty0yS/M8iyAAAAAFg5wkhGybzTsWemJjYk+U7TvMdAKwIAAABgxQgjGSVbezfkN5r9PQdUCwAAAAArTBjJKOm9G/L2qVr7zjnXW1HbyEgAAACAMSWMZHRUnQuS/KhpHT/n7CnN/nbtyem9B1YTAAAAACtGGMmoWei9kecn+VmSkuRugy4KAAAAgOUbqTCylHLvUsonSynnllLqUsrDF/GZE0op3y2lXFtK+Wkp5Wn9r5Q+2tp7I03VBgAAABhjIxVGJtk9yfeSvHAxnUspN08yneSLSY5O8s9J3lZKeWCf6qP/emHk0alae885ZxEbAAAAgDE2UmFkXdefruv6r+q6/ugiP/K8JL+o6/oldV3/qK7rNyb5cJI/7V+V9FXV+W2Ss9Odjn2vOWd7IyPv2p6cXj/QugAAAABYtpEKI7fD3ZN8fs6xzzbH51VK2bmUsldvS7JnPwtkuyw0VfuHSS5PdwTtHQZaEQAAAADLNu5h5IFJzp9z7Pwke5VSdl3gMy9P0pm1/bp/5bGdFlrEZnO2rKrtvZEAAAAAY2bcw8jt8eokrVnbIcMth3n0wshjU7X2mHOuN1XbeyMBAAAAxsy4h5HnJTlgzrEDklxe1/U1832grutr67q+vLcluaLfRbJEVeecJL9Jsi7JMXPO9haxMTISAAAAYMyMexh5SpL7zTl2YrZM5WV8fbvZ33nO8VOTbE5yWHty2qhWAAAAgDEyUmFkKWWPUsrRpZSjm0M3b9qHNedfXUo5adZH/j3JLUopryml3KaU8oIkj03yT4OtnD74TrO/0+yDM1MTVyb5XtM0OhIAAABgjIxUGJlu8HR6syXJ65ufX9m0D0pyWK9zXde/SDKR7mjI7yV5SZJn1XX92UEVTN8sNDIy2TJV23sjAQAAAMbI+mEXMFtd119KUrZy/mkLfGbuewUZf6c1+1umau2TqnPprHPfSPLCJHcdfFkAAAAAbK9RGxkJXVXn4iQ/b1rHzTl7arM/pj05vfPgigIAAABgOYSRjLJ53xuZbkh5UZKdYlQsAAAAwNgQRjLK5n1v5MzURJ3km03zbgOtCAAAAIDtJoxklC00MjLZEkZ6byQAAADAmBBGMspOS1InOSxVa/8554yMBAAAABgzwkhGV9W5IsmPm9bc0ZHfTjeobLcnpw8caF0AAAAAbBdhJKOuN1V77nsjL0/yv03TVG0AAACAMSCMZNTNu4hN49Rmb6o2AAAAwBgQRjLqtixiU7XKnHPeGwkAAAAwRoSRjLozkmxKckCSQ+ac64WRd25PTq8bZFEAAAAALJ0wktFWda5JcmbTmruIzY+SXJFk9yS3G2RZAAAAACydMJJxMO97I2emJjYl+VbTNFUbAAAAYMQJIxkH866o3fDeSAAAAIAxIYxkHJzW7I+2iA0AAADA+BJGMg5+mGRzkv3SXchmtlOb/ZHtyem9B1kUAAAAAEsjjGT0VZ2rk5zdtO4w+9TM1MSFSX7eNO8yyLIAAAAAWBphJOPiB83+DvOcM1UbAAAAYAwIIxkX32/2t5/nXC+MvOuAagEAAABgOwgjGRe9MHKrIyPbk9NzF7gBAAAAYEQIIxkXvTDytqlaO845970k1ya5SZJbDrQqAAAAABZNGMm4+GWSK5LslORWs0/MTE1cl+S0pum9kQAAAAAjShjJeKg6m5Oc2bTme2/kqc1eGAkAAAAwooSRjJNFvTdyQLUAAAAAsETCSMbJYsLIO7Ynp3cbUD0AAAAALIEwknHSCyPnm6Z9TpLfJlmX5NiBVQQAAADAogkjGSe9d0Yelqq19+wTM1MTdUzVBgAAABhpwkjGR9W5LMmvmtZ8oyOFkQAAAAAjTBjJuLGIDQAAAMCYEkYybrb23sjTkmxKcrP25PQhgysJAAAAgMUQRjJuftDsbzQycmZq4qpZ542OBAAAABgxwkjGzZaRkVVrvufXVG0AAACAESWMZNz8JMl1SfZI0p7nvDASAAAAYEQJIxkvVWdjkv9tWltbUfu49uT0joMpCgAAAIDFEEYyjnrvhbzjPOfOTnJpkl2SHD2oggAAAADYNmEk46gXRh4198TM1MTmJKc0zXsMrCIAAAAAtkkYyTg6s9nfboHz32j2wkgAAACAESKMZBz13hl5q1StneY5//Vmf8/25HQZUE0AAAAAbIMwknH06ySXJ1mf5Ih5zn87yaYkN0ty6ADrAgAAAGArhJGMn6pTJ/lh07rRVO2ZqYmrkpzeNE3VBgAAABgRwkjGVW+q9rbeG3nPAdQCAAAAwCIIIxlXvTDyRitqNyxiAwAAADBihJGMq22NjOwtYnPH9uT0HgOoBwAAAIBtEEYyrnph5C1TtXaee3JmauLXSc5Jsi7JXQZZGAAAAADzE0Yyrs5Nclm6YeOtF+jTGx1pqjYAAADACBBGMp66K2pbxAYAAABgjAgjGWeLDSPv3p6c9qwDAAAADJmAhnG2rTDye0muTtJKcuRAKgIAAABgQcJIxtlWw8iZqYmNSU5tmqZqAwAAAAyZMJJx1gsjfydVa9cF+ljEBgAAAGBECCMZZ+cnuSTd5/g2C/SxiA0AAADAiBBGMr4Wt6L2KUnqJLdsT04fNJC6AAAAAJiXMJJxt633Rl6W5IymeZ8B1AMAAADAAoSRjLszm/1CIyOT5MvNXhgJAAAAMETCSMbdtqZpJ8JIAAAAgJEgjGTc9cLIm6dq7bZAn682+yPbk9P7D6AmAAAAAOYhjGS8VZ0Lk1yYpCQ5cr4uM1MTFyf5QdO894AqAwAAAGAOYSSrganaAAAAAGNAGMlq0Asjj9pKH2EkAAAAwJAJI1kNFjMy8ivN/vbtyel9+1wPAAAAAPMQRrIabDOMnJmauCDJj5rm8X2vCAAAAIAbEUayGvTCyMNTtfbYSj9TtQEAAACGSBjJ+Ks6Fyc5r2nddis9hZEAAAAAQySMZLVYyoraR7cnp/fubzkAAAAAzCWMZLVYzHsjf5vk7CQlyb0GURQAAAAAWwgjWS0WMzIyMVUbAAAAYGiEkawWiw0jv9Ts79u/UgAAAACYjzCS1aIXRh6aqtXaSr8vNPtj2pPT+/W5JgAAAABmEUayOlSdy5Kc27QWXFF7ZmrivCQ/SPe9kffrf2EAAAAA9AgjWU0WO1X7c83+xD7WAgAAAMAcwkhWkzOb/aLDyPbkdOljPQAAAADMIoxkNVnsyMivJLkuyWFJjuhrRQAAAAD8H2Ekq8miwsiZqYmrk3y9ad6/rxUBAAAA8H+EkawmP2z2B6dq7b2Nvt4bCQAAADBgwkhWj6pzeZJzmta2pmp/vtnftz05vb5/RQEAAADQI4xktelN1T5qG/2+m+TSJHsluXNfKwIAAAAgiTCS1Wex743clOQLTdNUbQAAAIABEEay2ix2Re3EeyMBAAAABkoYyWpzZrNfShh5t/bk9J59qgcAAACAhjCS1eZHzf6AVK39ttZxZmriF0l+lmR9khP6XBcAAADAmieMZHWpOlcm+UXTuv0iPvHfzf5B/SkIAAAAgB5hJKvRGc3+jovoO93sH9yenC79KQcAAACARBjJ6vS9Zn/0Ivp+McmGJIdlce+ZBAAAAGA7CSNZjXph5DZHRs5MTVyd5AtN88F9qwgAAAAAYSSrUi+MvG2q1o6L6N+bqj3Rp3oAAAAAiDCS1WkmyeVJdkpym0X074WR92hPTu/br6IAAAAA1jphJKtP1amzhPdGzkxN/CrJD9L982BVbQAAAIA+EUayWi36vZENU7UBAAAA+kwYyWq11DDyv5r977Unp9f3oR4AAACANU8YyWq1JYysWmUR/b+Z5JIkeye5e7+KAgAAAFjLhJGsVmcm2ZzkpkkO2lbnmamJTUk+3TQf3Me6AAAAANYsYSSrU9W5JslZTct7IwEAAABGgDCS1Wyp7438bJJNSW7Xnpy+eX9KAgAAAFi7hJGsZksKI2emJi5J8rWm+fB+FAQAAACwlgkjWc16YeTRS/jMR5r9I1e2FAAAAACEkaxmvTDyVqlauy7yMx9t9vdsT04f2IeaAAAAANYsYSSr2W+TXJjuc37UYj4wMzVxTpJvJylJHta/0gAAAADWHmEkq1fVqbP0RWyS5D+bvanaAAAAACtIGMlqtz1hZG+q9n3bk9P7rHA9AAAAAGuWMJLVbsmL2MxMTfwkyZlJ1id5cB9qAgAAAFiThJGsdmc0+zumai3lebeqNgAAAMAKE0ay2v0oyTVJ9kxyqyV8rhdGPqg9Ob37ilcFAAAAsAYJI1ndqs7GJKc3rTsv4ZPfT/LzJLskedBKlwUAAACwFgkjWQu+3ezvtNgPzExN1DFVGwAAAGBFCSNZC77T7JcyMjLZEkY+pD05vcsK1gMAAACwJgkjWQt6IyOPSdVav4TPnZrk1+m+b9JUbQAAAIBlEkayFpyd5PJ03/94u8V+aGZqYnOSDzXNx/WhLgAAAIA1RRjJ6ld1Nic5rWktdar2yc3+Ie3J6d1WrigAAACAtUcYyVqx5EVsGt9KMpNk9yQTK1kQAAAAwFojjGSt2K5FbJpVtT/YNE3VBgAAAFgGYSRrRW9k5O1TtZa6MnZvqvZEe3J6zxWsCQAAAGBNEUayVvwyycVJdkxyhyV+9vQkP013AZyHrHBdAAAAAGuGMJK1oerU2c73RjZTtXujI03VBgAAANhOwkjWku16b2SjF0Y+qD05vffKlAMAAACwtggjWUt6IyO3J4w8M8kPk+yU5GErVhEAAADAGjKSYWQp5YWllJlSyoZSyqmllLtspe+OpZS/KaX8rOn/vVLKgwZZL2OjNzLyyFStPZbyQVO1AQAAAJZv5MLIUsrjkrw+ySuSHJvke0k+W0rZf4GP/F2S5yb5oyS3TfLvST5aSjlmAOUyTqrOuUnOTfe5357noxdGntienN53xeoCAAAAWCNGLoxM8uIkb63r+p11Xf8wyfOSXJ3kGQv0f0qSV9V1/am6rn9e1/W/JflUkpcMplzGzHYtYpMkM1MTZ6Ubjq9P8oiVLAoAAABgLRipMLKUslOS45J8vnesruvNTfvuC3xs5yQb5hy7Jsm9FrjHzqWUvXpbkj2XXTjjpDdVe8Gp/9tgqjYAAADAdhqpMDLJfknWJTl/zvHzkxy4wGc+m+TFpZQjSik7lFJOTPLIJAct0P/lSTqztl8vu2rGyTeb/d228/O9MPK+7cnphV4dAAAAAMA8Ri2M3B5/kuTsJD9Ocl2SNyZ5Z5LNC/R/dZLWrO2QAdTI6PhWkjpJO1VrocB6QTNTEz9Pd3TlDkketcK1AQAAAKxqoxZGXpRkU5ID5hw/IMl5832grusL67p+eJLdkxye5DZJrkzy8wX6X1vX9eW9LckVK1Q746DqXJ7kB01roan/22KqNgAAAMB2GKkwsq7r65KcluR+vWOllB2a9inb+OyGuq5/k+7iIo9K8vE+lsp46z1L99jOz3+w2d+7PTl98ArUAwAAALAmjFQY2Xh9kmeXUp5aSjkyyb+lO+rxnUlSSjmplPLqXudSyl1LKY8spdyilHJ8ks+k++t6zRBqZzx8o9lv18jImamJX6UbaJYkj16pogAAAABWu5ELI+u6PjnJS5O8MskZSY5O8qC6rnuL2hyWGy5Os0uSv0vywyQfTfKbJPeq6/qywVTMGOqFkXdK1dp5O69hqjYAAADAEpW6roddw1CVUvZKd1XtVvMOSVa7qlWSXJDu6u33SNXZ6isA5tNMz/51uqMjD29GSwIAAACsOUvJ10ZuZCT0XdWps/yp2ucm+WrTfOxKlAUAAACw2gkjWauWu4hNknyg2T9hmbUAAAAArAnCSNaqLSMju9O2t8eHk2xKcmx7cvpWK1MWAAAAwOoljGSt+k6SjUkOTndRpCWbmZq4MMl/N02jIwEAAAC2QRjJ2lR1rk53tfZkO98b2Xh/s39Ce3J6e0dYAgAAAKwJwkjWst5U7eW8N/JjSTYkuXWSY5ZbEAAAAMBqtqwwspRyWCnlXnOO3bGUclIp5eRSysOXVR30V28Rm+0eGTkzNXFFkv9qmqZqAwAAAGzFckdGviFJ1WuUUg5I8sUkj0xy7yT/WUp55DLvAf3SGxl5TKrW7su4Tm+q9uPbk9NGGwMAAAAsYLnByV2SfG5W+w+S7JrkjkluluQLSV66zHtAv5yT5Nwk65LcaRnX+VSSy5MckuSeK1AXAAAAwKq03DDyJkkumNV+cJIv13X9s7quNyf5SJLbLPMe0B9Vp84KvDdyZmpiQ7rPepI8cbllAQAAAKxWyw0jL0xyeJKUUvZOcrckn511fn2zwaj6WrO/11Z7bVtvqvZj2pPTOy7zWgAAAACr0nLDyM8n+eNSyouTnNRc72Ozzt823amwMKp6YeQ9U7WW8+fhf9IdJbxvkvsvuyoAAACAVWi5YeRkkh8leV2SByR5aV3Xv0iSUsrOSR6b7nsjYVR9L8lVSVpJbre9F5mZmtiY5INN06raAAAAAPNYVhhZ1/X5dV3fM8k+Sfaq6/pf5lz7fpm12jaMnKqzMckpTWulpmo/oj05vesyrwUAAACw6ix3ZGSSpK7rTl3X1805dk1d19+r6/qSlbgH9NFKvTfylCS/TLJHuos5AQAAADDLssLIUsr9Sikvm3PsGaWUX5VSzi+l/FMpZd3ySoS+W5EwcmZqok7ygaZpqjYAAADAHMsdGVkluWOvUUq5fZI3p7vK9peS/HGSly7zHtBvpybZlOSwVK3Dlnmt3lTt329PTreWeS0AAACAVWW5YeSRSb4zq/2UJJcnOb6u68cleWuSP1jmPaC/qs6VSU5vWvdc5tW+n+SHSXZO8ohlXgsAAABgVVluGLl7uuFjz4OSfKau66ub9reTHL7Me8AgrORU7d7oyCcuqyIAAACAVWa5YeQ5Se6cJKWUWyY5Ksl/zzp/kyTXLvMeMAgrtYhNsuW9kfdrT04fsALXAwAAAFgVlhtGvjfJc0opn0jy2SSXJvn4rPPHJfnJMu8Bg/D1Zn/7VK29l3OhmamJn6Y7KniHJI9ZZl0AAAAAq8Zyw8i/TzKV5NAkv0ry8LquL0uSUspNkpyQ5BPLvAf0X9U5L8lPk5Qkd1+BK/amaltVGwAAAKCxrDCyruuNdV3/ZV3Xx9R1/bt1XX911rlL6ro+sK7rVy+/TBiIlZyqfXKSOsk92pPTt1iB6wEAAACMveWOjPw/pZQ9SilHNtseK3VdGKAVCyNnpibOTfL5pmlFeQAAAICsQBhZSrlzKeWL6b4v8sxmu7SU8j+llDst9/owQL0w8i6pWjuvwPXe3ez/oD05vWLBPwAAAMC4Wr+cD5dS7prkS0muS/K2JD9qTh2Z7rvyvlJKOaGu628t5z4wID9JclGS/ZIcm+SUZV7vo0muSHLzdEdbfmWZ1wMAAAAYayuxgM1vkty6ruvn13X9hmZ7fpJbJzm36QOjr+rUWdmp2lcn+VDTfOpyrwcAAAAw7pYbRt41yZvruj5v7om6rs9P8pYkd1vmPWCQVnIRm2TLVO3HtCend1uhawIAAACMpeWGkZuz9ane65o+MC56YeQ9U7VW4j2PX0vyiyR7JnnEClwPAAAAYGwtN2z5RpIXllIOn3uilHJYkhck+foy7wGDdHqSa5Lsm+6rBpZlZmpic5KTmqap2gAAAMCattww8i+StJL8uJTyvlJK1WzvT/LjJHsnefky7wGDU3WuS3Jq01qpqdq9MPL+7cnpQ1bomgAAAABjZ1lhZF3Xp6f73sjPJHlokr9ptoc0x+6Z5MJl1giDtqLvjZyZmvh5kq8mKUmevBLXBAAAABhHy34nXl3XP6zr+hFJ9kpyULPtVdf1I9MNJc9Z7j1gwFZ6EZtky0I2T2tPTpcVvC4AAADA2FiJBTqSJHVdb67r+vxms2gN4+yUdBdeukWq1sErdM0PJrkq3fdQHr9C1wQAAAAYKysWRsKqUXUuT/L9pnXPlbjkzNTEFUne3zSfsxLXBAAAABg3wkiYXz+mar+l2T+6PTm97wpeFwAAAGAsCCNhfv0II7+T5IwkOyd5ygpeFwAAAGAslLqul/aBUo5dQvdnJnleXdfrlnSTASql7JWkk6RV1/Xlw66HEVG1Dkl38aXNSfZO1bliJS7bnpx+fpJ/TfKjJLebmZpY2h9AAAAAgBGzlHxt/XZc/ztJFhuglCX0hdFRdX6dqjWTpJ3kbkk+t0JXfl+S1yU5Mt33UX5t690BAAAAVo/tCSOfvuJVwGj6Wrph5L2yQmHkzNREpz05/YEkz0h3IRthJAAAALBmLDmMrOv63f0oBEbQ15I8OSv73siku5DNM5I8tj05/aKZqYlLVvj6AAAAACPJAjawsK83+7ulau24gtf9VpLvp7uQzZNX8LoAAAAAI00YCQv7YZLLk+yW5KiVumizaM1bmuaz25PTZaWuDQAAADDKhJGwkKqzOcmpTevuK3z19ya5Jt2Q824rfG0AAACAkSSMhK07pdmvaGA4MzVxWZKTm+ZzVvLaAAAAAKNKGAlb981m34/Ri72p2o9rT07v3YfrAwAAAIwUYSRsXW+a9hGpWvut8LW/meTMJLsmedIKXxsAAABg5AgjYWuqziVJzmpad13JS89ZyOa5FrIBAAAAVjthJGxbP6dqvyfJhiS3T3KXPlwfAAAAYGQII2Hb+hZGzkxNXJrkg03TQjYAAADAqiaMhG3rrah911StdX24fm+q9uPbk9OtPlwfAAAAYCQII2Hb/jfJVUn2THJkH67/jSQ/TLJbLGQDAAAArGLCSNiWqrMxybebVj+malvIBgAAAFgThJGwOL2p2nfv0/VPSnchmztkhVftBgAAABgVwkhYnH6uqN1byObkpvm8ftwDAAAAYNiEkbA4vTDytqlae/fpHv/e7B/Xnpzep0/3AAAAABgaYSQsRtW5IMnPm9ad+3SXU5N8P8kuSZ7Sp3sAAAAADI0wEhavNzqyL++NbBayeXPTfJ6FbAAAAIDVRhgJi9fX90Y23pPkqiRHJrlXH+8DAAAAMHDCSFi8U5v9nVO1+jJqcWZq4vIk72+aFrIBAAAAVhVhJCze95NsTLJfksP6eJ/eVO1Htyen9+vjfQAAAAAGShgJi1V1NiT5QdO6U79uMzM18Z0kpyXZKclT+3UfAAAAgEETRsLSfLvZ92tF7Z7e6MjnWsgGAAAAWC2EkbA032n2fRsZ2Xh/kiuSHJHkd/t8LwAAAICBEEbC0mwJI/u0iE2SzExNXJnuytpJ8tx+3QcAAABgkISRsDRnJrk2SSvJ7/T5Xr2p2o9sT04f0Od7AQAAAPSdMBKWoupcn+SMptXX90bOTE18L8k3k6xP8vR+3gsAAABgEISRsHSDem9ksmV05HPak9P+vAIAAABjTbgBSzfIMPKDSTpJbp7kxAHcDwAAAKBvhJGwdN9u9selaq3r541mpiauTvLupmkhGwAAAGCsCSNh6X6c5Ookuye59QDu15uq/dD25PTBA7gfAAAAQF8II2Gpqs6mJN9tWn2fqj0zNfHDJF9Lsi7JM/t9PwAAAIB+EUbC9ulN1R7EeyOT5N+b/bPbk9N9nRoOAAAA0C/CSNg+vUVs7jyg+/1nkouTHJrk9wZ0TwAAAIAVJYyE7dMLI49O1dqx3zebmZrYEAvZAAAAAGNOGAnb56dJOkl2SXLbAd3zLc3+99uT04cN6J4AAAAAK0YYCduj6mxOclrTGshU7ZmpibOSfDHdP7fPGsQ9AQAAAFaSMBK2X2+q9qAWsUm2LGTzzPbk9PoB3hcAAABg2YSRsP2+2+yPGeA9P5bkgiQHJ3nwAO8LAAAAsGzCSNh+vWnadxzEIjZJMjM1cV2SdzbNFwzingAAAAArRRgJ2+/nSS5PsnOSIwd4339PsjnJie3J6UHeFwAAAGBZhJGwvbqL2JzetI4d1G1npiZmknyiaf7hoO4LAAAAsFzCSFie3nsjBxZGNv5fs39qe3K6NeB7AwAAAGwXYSQsz7DCyC8m+d8kuyd5+oDvDQAAALBdhJGwPL1FbI5O1Vo3qJvOTE3USd7QNP+oPTk9sHsDAAAAbC9hJCzPT5Jcne4IxVsN+N7vTXJZklsk+b0B3xsAAABgyYSRsBxVZ1OSM5rWQKdqz0xNXJXkbU3zjwd5bwAAAIDtIYyE5RvWeyOT5E1JNic5sT05feQQ7g8AAACwaMJIWL7eeyMHHkbOTE3MJPlE03zRoO8PAAAAsBTCSFi+LSMjq9Yw/ky9vtk/tT05fcAQ7g8AAACwKMJIWL4fJbk2yV7pLiYzaF9L8q0kOyd54RDuDwAAALAowkhYrqpzfZLvN61hTNWuk7y2ab6wPTm9+6BrAAAAAFgMYSSsjGEuYpMkH03y8yQ3SfK0IdUAAAAAsFXCSFgZQ1vEJklmpiY2Zcu7I1/cnpxeN4w6AAAAALZGGAkrY/YiNmVINbwzycXpvrfykUOqAQAAAGBBwkhYGWcm2Zhk3ySHDaOAmamJq5P8a9N8WXtyelihKAAAAMC8hJGwEqrOtekGksnw3huZJG9Md2XvOyc5YYh1AAAAANyIMBJWzlDfG5kkM1MTFyR5e9P8q2HVAQAAADAfYSSsnGGvqN3zmnSnjN+3PTl9jyHXAgAAAPB/hJGwckYijJyZmvhlknc3zb8eZi0AAAAAswkjYeV8P8nmJAemah085FpenWRTkge1J6fvPORaAAAAAJIII2HlVJ2rk/yoaQ17dOTPkryvaXp3JAAAADAShJGwsoa+iM0sr0pSJ3loe3L6jsMuBgAAAEAYCStrJN4bmSQzUxM/TvLBpvmXw6wFAAAAIBFGwkrrhZHHDbWKLf6u2T/G6EgAAABg2ISRsLLOSHdq9CGpWvsPuZbMTE2cmeTkpvn3w6wFAAAAQBgJK6nqXJHkJ03rmGGWMstfp7uy9kR7cvqewy4GAAAAWLuEkbDyRua9kUkyMzVxdpK3N81XtyenyzDrAQAAANYuYSSsvJEKIxuvTLIhyfFJHjTkWgAAAIA1ShgJK2/UFrHJzNTEb5K8sWm+qj057c8+AAAAMHACCVh5pzf7m6dq7TPUSm5oKsnlSY5O8tjhlgIAAACsRcJIWGlV59IkP29ao7KITWamJi5O8rqm+fftyemdh1kPAAAAsPYII6E/RvG9kUnyT0nOTXKLJC8abikAAADAWiOMhP4YyTByZmriyiQvb5p/2Z6cPnCY9QAAAABry0iGkaWUF5ZSZkopG0opp5ZS7rKN/i8qpZxVSrmmlHJOKeWfSim7DKpemMfILWIzy3uSfCvJnkn+bsi1AAAAAGvIyIWRpZTHJXl9klekO6rse0k+W0rZf4H+T0x3YY5XJDkyyTOTPC7JqwZSMMyvF0beKlVrr6FWMsfM1MTmbJmi/Yz25PTIvNcSAAAAWN1GLoxM8uIkb63r+p11Xf8wyfOSXJ3kGQv0v0eSr9d1/b66rmfquv7vJO9PstXRlNBXVefCJL9sWncaZinzmZmaOCXdPyclyb+0J6fLkEsCAAAA1oCRCiNLKTulO631871jdV1vbtp3X+Bj30hyXG8qdynlFkl+P8mnFrjHzqWUvXpbulNVoR9ObfajGoz/eZJrkhyf5DFDrgUAAABYA0YqjEyyX5J1Sc6fc/z8JPMutFHX9fuS/E2Sr5VSrk/ysyRfqut6oWnaL0/SmbX9egXqhvl8q9nfdahVLGBmauKcJP/QNP+pPTk9UtPJAQAAgNVn1MLIJSulnJDkL5K8IN13TD4yyUQp5a8X+Mirk7RmbYf0v0rWqFEfGZl0w8ifJjk4FrMBAAAA+mzUwsiLkmxKcsCc4wckOW+Bz/xtkv+o6/ptdV3/oK7rj6YbTr68lHKjX19d19fWdX15b0tyxQrWD7N9N93n+eBUrZEMvWemJjYkeX7T/MP25PSdh1kPAAAAsLqNVBhZ1/V1SU5Lcr/esSZQvF+SUxb42G5JNs85tqn38ZWuERat6lyd5AdNa2RHR85MTXw+yXvS/fPylvbk9PohlwQAAACsUiMVRjZen+TZpZSnllKOTPJvSXZP8s4kKaWcVEp59az+n0zy/FLK40spNy+lnJjuaMlP1nW9ae7FYcBG+r2Rs7wkyaVJjk7yR8MtBQAAAFitRi6MrOv65CQvTfLKJGekG448qK7r3qI2hyU5aNZH/i7JPzb7HyZ5e5LPJnnuYCqGrRqH90ZmZmrigiR/1jT/tj05ffgw6wEAAABWp1LX9bBrGKpSyl7prqrdat4hCSunah2V7lTtK5PsnaozsqN125PTOyT5UpLjk3wxyf1npibmvgIBAAAA4AaWkq+N3MhIWGV+lG4QuUeSI4dcy1Y1weMzklyV5HeT/MlwKwIAAABWG2Ek9FN3JOR3mtaovzcyM1MTP033/ZFJ8ur25PTthlkPAAAAsLoII6H/xuK9kbO8Jcmnk+yc5D/ak9M7DbkeAAAAYJUQRkL/jcuK2kmSmamJOskzk1yS5Jgkfz3cigAAAIDVQhgJ/dcbGXlUqtbuQ61kkWamJn6b5HlN8y/ak9P3G2Y9AAAAwOogjIR+qzq/SXJuknVJjh1yNYs2MzXxoSTvTPd74v3tyelDh1wSAAAAMOaEkTAY4/beyJ4XJjk9yU2TfKg9Ob3zkOsBAAAAxpgwEgZjrN4b2TMzNXFNkkcnuTTd2v9puBUBAAAA40wYCYPRGxl5j1StMtRKlmhmauLnSZ6UpE7y/Pbk9NOGWxEAAAAwroSRMBinJrk+yc2StIdbytLNTE18OskrmuZb2pPTvzvMegAAAIDxJIyEQag6Vyf5dtO6zzBLWYa/TfLhJDsm+Vh7cvr2Q64HAAAAGDPCSBicrzT7ew+1iu00MzWxOclTknw1yV5JPm2FbQAAAGAphJEwOL0wclxHRmZmamJDkocl+WG6U84/3Z6c3me4VQEAAADjQhgJg/P1JJuT3CJV65BhF7O9ZqYmLk3ye0nOTXK7dAPJ1nCrAgAAAMaBMBIGpepcnuT0pnX8MEtZrpmpiV8leVCSS5LcNclnBZIAAADAtggjYbC+3OzHdqp2z8zUxA+S3C9bAsn/FkgCAAAAWyOMhMEa60Vs5pqZmjgjyX2TXJzkLukGkt4hCQAAAMxLGAmD9dVmf2Sq1v5DrWSFzExNfC/dEZK9QPJr7cnpw4ZbFQAAADCKhJEwSFXnkiQ/aFpj/d7I2ZpA8oQkv0ly2ySntCen7zDUogAAAICRI4yEwVtVU7V7ZqYmzkxy9yT/m+TgJF9tT07fd7hVAQAAAKNEGAmD11vEZlWFkUkyMzVxTpJ7pftr3CvdVbZf2J6cLsOtDAAAABgFwkgYvN57I++YqrXqFnuZmZq4LMkDk7w/yfokb0zyzvbk9K7DrAsAAAAYPmEkDFrVOS/JWUlKknsOuZq+mJmauDbJk5K8LMnmJE9Nd2Gbw4daGAAAADBUwkgYjt57I08YZhH9NDM1Uc9MTbwuyYlJLkpybJLT25PTjxluZQAAAMCwCCNhOP6n2T9wqFUMwMzUxP8kOS7Jt5Lsk+SD7cnpd7Qnp/ccbmUAAADAoAkjYTj+O93py0elah067GL6bWZq4lfpLmzz90nqJE9Pd5TkPYZaGAAAADBQpa7rYdcwVKWUvZJ0krTqur582PWwhlStrye5R5LnpOq8ddjlDEp7cvreSf4jyWHpBpP/muQvZqYm/PkDAACAMbSUfM3ISBieTzf73x9qFQM2MzXxlSR3TPKudBfxeWGS/21PTj9kmHUBAAAA/WdkpJGRDEvVOi7Jd5JcmWTfVJ3rhlzRwLUnp++f5M1JbtEc+mSSl85MTfxkeFUBAAAAS2FkJIyH05NckGSPJPccci1DMTM18fkkt0/ymiQbkzwk3VGSr29PTu89zNoAAACAlSeMhGGpOpuzZar27w2zlGGamZq4emZq4s/TDSWnk6xP8qdJftaenP6z9uT07kMtEAAAAFgxwkgYrjUfRvbMTE38eGZq4sFJHpTkh0lukuQfkvy8PTn9ovbk9C5DLRAAAABYNu+M9M5Ihqlq3STJhen+w8BhqTrnDLmikdCenF6f5ElJ/iZb3id5XpI3JPn3mamJS4dVGwAAAHBDS8nXhJHCSIatan09yT2SPDdV5y3DLmeUtCend0zytCR/neTQ5vCVSd6W5F9mpiZmhlMZAAAA0COMXAJhJENXtf4qyd8m+ViqziOGXc4oak9O75TkcUlelu67JZOkTnea+78n+dTM1MSmIZUHAAAAa5owcgmEkQxd1To2yWnpjvjbN1XnuiFXNLLak9MlyQOSvCTJibNO/SrJu5P8x8zUxNnDqA0AAADWKmHkEggjGbqqtUOSc5MckOR+qTr/M+SKxkJ7cvqIJM9N8vR0F7vpOSXJfyT56MzUxHnDqA0AAADWEmHkEggjGQlV6x3phmpvTNX5o2GXM06aVbYfkeQP0h01uUNzqk7yjSQfTTeY/PlwKgQAAIDVTRi5BMJIRkLV+v0k00l+m+SQVJ3NQ65oLLUnpw9K8sR03y955zmnv58mmEzy/ZmpibX95QcAAAArRBi5BMJIRkLV2inJ+Un2TnLvVJ2vDreg8deenD4kycPTHTV5nyTrZp3+dZIv9LaZqYlzB14gAAAArBLCyCUQRjIyqta7kjw1yf9L1fnjIVezqrQnp/dN8uB0g8kHJtllTpcfZ0s4+aWZqYlLB1shAAAAjC9h5BIIIxkZVevBST6Z7mI2h5qq3R/tyeldk9wzyf2T3C/JcUnKrC51kh+muxBObztrZmrC/x4AAAAwD2HkEggjGRlVa+ckFyTZK8m9UnW+PuSK1oT25PQ+SU5IN5i8X5LbzNPtsiSnphtMfjvJd63UDQAAAF3CyCUQRjJSqtZJSZ6S5F9SdV405GrWpPbk9AFJ7pbk7s3+zkl2m6freUlOn7P93MI4AAAArDXCyCUQRjJSqtZDknwiyW+SHGaq9vC1J6d3THL7dMPJuyc5Nsmtk+wwT/fLk5yRbjD53STfS3eK94aBFAsAAABDIIxcAmEkI6Vq7ZLuVO09k9wzVecbQ66IebQnp3dPN6A8Jt1w8pimvdM83Tcn+Vm676Gcvf14Zmri6oEUDAAAAH0kjFwCYSQjp2q9J8mTkvxTqs6Lh10Oi9OMoDwy3WCyt90hyd4LfKROMpMbBpRnJ/lpkgtM9wYAAGBcCCOXQBjJyKlaD0vysSTnJGmbqj2+2pPTJcmBSW47z7bfVj56Zbqh5OztZ83+XCt7AwAAMEqEkUsgjGTk3HCq9vGpOl8bckX0QXty+qbpjqScHVDeMslhScpWProh3WDyF0l+1Wy/nLU/b2ZqYlP/KgcAAIAbEkYugTCSkVS13pXkqUnenKrzvCFXwwC1J6d3TtJON5icu908ybptXGJjkl/nhgHlOUl+m+TcZn/BzNTExj6UDwAAwBokjFwCYSQjqWrdP8nnklya5KBUnWuHXBEjoHkv5WHpBpOHN9thzXZ4kkOy7bAy6S6qc0G2hJNz9xc22wVJrvD+SgAAALZGGLkEwkhGUtVal+6otoOTPDJV56NDrogx0J6cXpfkoNw4pDy0OX5Quu+w3GEJl70uW8LJ+bYL5rQ73mkJAACwtggjl0AYyciqWq9J8rIkH03VeeSwy2F1aALLm6YbdB+cbkA5d3/TZtttO25Rp/udeul2bJebPg4AADB+hJFLIIxkZFWtOyT5XpLrkxyYqnPJkCtijWlPTu+WLcHk/rN+XmjbcwVue02SK5Jcvsz9VUmuN8UcAACg/4SRSyCMZKRVre8luUOS56XqvHnY5cDWNIvv7LONbe8Fju/eh5I2pRtKXt1sVy2w39q5uX2uSXdF8952rdXLAQCAtU4YuQTCSEZa1Xppktcm+Xqqzr2GXQ70S3tyeqd0R1bumWSvZe53HnD516cJJnPDoHLDNo5v6zPXNdv18/w837Hez9d7bycAADBIwsglEEYy0qrWwUl+naQk+Z1UnZ8PuSIYeU2wuVu6oy13m/Pz1o4t9twuWdoiQMOwMYsLLucLOa9Pd1Tpxmab/fPcdj/PbW5+3jzPNt/xbfWtTdsHAID+EEYugTCSkVe1Ppfk/kn+JlXnb4ddDpC0J6fXpxtK9rad57Tnbts6P1+fnZLsOGe/0DEWp84yA81FbllC32H1zwL7rZ1b6b17uddC+9l/9jbN+Xlue8X7GV0OAEsnjFwCYSQjr2r9QZJ3Jzk7ya1Tddb2H1rgBtqT0yXJuiwutFzMsfXNtm7Wz/1uzz23Pt3Rp3O3dfMcK8v/XQS4kW2FlnNHePdru36FrjF79Pt87euTXOc9yABsL2HkEggjGXlVa48k56c7PfRuqTqnDrkigJHRhLHzBZcLhZcLHV9s37LAlq2c61e/7b1W5jk+99hy96N+zVGvrx/XHPX6Zl+zpPtnr7ftsIifF9tv1F+zMWx1FhFabkef5RxbqD3v3shWgOEQRi6BMJKxULXem+SJSd6YqvNHwy4HAGAcNf+AMTvs3N5wc6FR3du77biC15p7zdkj4Gdvq/U1H5uyiNByBPcbvdsYGGfCyCUQRjIWqtaDknw6yUVJDk7VuX7IFQEAMMZmveZjbkA5X2g599hS+vbzmjtly8ja1WAUQtFt7ecbjWp6PyCMXAphJGOhaq1Pd1XtA5I8NFXnk0OuCAAAhq49OT33vcnjsl/fj9+PIdmc0QhKlxysGo0KK0cYuQTCSMZG1fqnJC9K8sFUnccNuRoAAGA7NSNT5xvpOer71TYadWNuOOpzlBafWunrzV58a7MglpUmjFwCYSRjo2odm+S0JNcmOSBVpzPkigAAgDWmGY067FB0e/Y79uP3Y4xtzpaAchDbxgHfr7dtnrXfPE97oZ9XvN9qD4CFkUsgjGRsVK2S5Mwkt03yrFSdtw+5IgAAgLHQjEZdn4XDylFahGqlrrduRX7zWCl1usHkwTNTExcMu5iVtpR8bTW9pwJWt6pTp2q9J8mrkjw5iTASAABgEZpRab3p2GvCnIWqeuHkoLdh3rf369+h2Wb/PLe9Pf167cW+uqBXz5pf9MnISCMjGSdV67Akv2xah6fq/GqY5QAAAMBa1oS+Swk+z5+Zmtg8nGr7xzTtJRBGMnaq1heTnJDkL1J1Xj3kagAAAIA1bin52g6DKQlYQe9p9k9p3iMJAAAAMBaEkTB+PpxkQ5Ijkxwz5FoAAAAAFk0YCeOm6nSSfKJpPWWYpQAAAAAshTASxlNvqvYTUrXWD7USAAAAgEUSRsJ4+kySi5IckOT+Q64FAAAAYFGEkTCOqs71ST7QtEzVBgAAAMaCMBLGV2+q9iNStfYcaiUAAAAAiyCMhPH1rSRnJ9k1ySOGXAsAAADANgkjYVxVnTrJfzQtU7UBAACAkSeMhPH23mZ/v1Stmw21EgAAAIBtEEbCOKs6P0/y9SQlyROGXA0AAADAVgkjYfyZqg0AAACMBWEkjL8PJbkuyR1Ste4w7GIAAAAAFiKMhHFXdS5JMt20njzMUgAAAAC2RhgJq0NvqvaTUrXWDbUSAAAAgAUII2F1+FSSS5McnOR3h1wLAAAAwLyEkbAaVJ1rk3ywaZmqDQAAAIwkYSSsHr2p2o9K1dptqJUAAAAAzEMYCavHN5L8IskeSR4+3FIAAAAAbkwYCatF1amTvKdpmaoNAAAAjBxhJKwuvanaD0jVOnColQAAAADMIYyE1aTqnJ3kW0nWJXnckKsBAAAAuAFhJKw+vanaTxpqFQAAAABzCCNh9Tk5yaYkd07VOmLYxQAAAAD0CCNhtak6FyT5XNMyOhIAAAAYGcJIWJ22rKpdtcpQKwEAAABoCCNhdfp4kquT/E6Suwy5FgAAAIAkwkhYnarOlUk+1rRM1QYAAABGgjASVq/3NvvHpWqtH2olAAAAABFGwmr2uSQXJtk/yf2HXAsAAACAMBJWrapzfZKTm9aTh1kKAAAAQCKMhNWuN1X7Ealaew61EgAAAGDNE0bC6nZqkrOS7Jbk8UOuBQAAAFjjhJGwmlWdOsnbmtazhlkKAAAAgDASVr+Tklyf5C6pWncYdjEAAADA2iWMhNWu6lyQ5ONNy+hIAAAAYGiEkbA29KZqPyVVa9ehVgIAAACsWcJIWBs+l+SXSfZO8sjhlgIAAACsVcJIWAuqzuYk72hazx5mKQAAAMDaJYyEteOdSTYnuU+q1q2GXQwAAACw9ggjYa2oOuck+UzTeuYwSwEAAADWJmEkrC1vbfbPTtXac6iVAAAAAGuOMBLWlk8m+UmSfeLdkQAAAMCACSNhLak6m5K8pmm9JFVr52GWAwAAAKwtIxlGllJeWEqZKaVsKKWcWkq5y1b6fqmUUs+zTQ+yZhgj70lybpKDkzxlyLUAAAAAa8jIhZGllMcleX2SVyQ5Nsn3kny2lLL/Ah95ZJKDZm1HJdmU5EP9rxbGUNW5Nsk/Nq0/S9VaN8xyAAAAgLVj5MLIJC9O8ta6rt9Z1/UPkzwvydVJnjFf57quL6nr+rzeluTEpr8wEhb2liSXJjki3UAfAAAAoO9GKowspeyU5Lgkn+8dq+t6c9O++yIv88wkH6jr+qqVrxBWiapzZZL/17RenqpVhlkOAAAAsDaMVBiZZL8k65KcP+f4+UkO3NaHm3dLHpXkbVvps3MpZa/elmTPZdQL4+wN6Y4iPibJA4dcCwAAALAGjFoYuVzPTPKDuq6/tZU+L0/SmbX9ehCFwcipOhcneXPTel2q1k7DLAcAAABY/UYtjLwo3cVnDphz/IAk523tg6WU3ZM8Psnbt3GPVydpzdoO2a5KYXX4uyQXJrldkj8dci0AAADAKjdSYWRd19clOS3J/XrHSik7NO1TtvHxxyTZOcl7tnGPa+u6vry3JblieVXDGKs6lyR5WdP6/1K12kOsBgAAAFjlRiqMbLw+ybNLKU8tpRyZ5N+S7J7knUlSSjmplPLqeT73zCQfq+v64sGVCqvCSUm+nGTXdN8jCQAAANAXIxdG1nV9cpKXJnllkjOSHJ3kQXVd9xa1OSzJQbM/U0q5dZJ7ZdtTtIG5qk6d5AVJNiZ5SKrWw4ZcEQAAALBKlbquh13DUDUraneStJpp27A2Va1XpbvA0zlJbpeq4xUGAAAAwDYtJV8buZGRwND8XZKZJIcmeVeqlu8HAAAAYEUJG4CuqnN1kicluS7JI5P89XALAgAAAFYbYSSwRdX5RpLn91qpWo8cZjkAAADA6iKMBG6o6rwjW1bVPilV6/bDLAcAAABYPYSRwHxekuQLSXZP8slUrZsNuR4AAABgFRBGAjdWdTYmeVySnyY5PMkXUrUOGG5RAAAAwLgTRgLzqzoXJzkxyTlJbp3kc6la+w63KAAAAGCcCSOBhVWdmST3S/LbJLdP8t+pWnsPsyQAAABgfAkjga2rOmcnuX+Si5Icm+RTqVp7DLcoAAAAYBwJI4Ftqzo/THfK9mVJ7p7uoja7DrUmAAAAYOwII4HFqTpnJHlgkiuSnJDko6laOw+zJAAAAGC8CCOBxas630ry+0muTjeYPDlVa8fhFgUAAACMC2EksDRV52tJHprk2iQPS/IfqVrrhlsUAAAAMA6EkcDSVZ0vJHlkkuuTPC7J21K1fJ8AAAAAWyU8ALZP1flUkscn2ZTkaUnemKpVhloTAAAAMNKEkcD2qzofSfIHSeokz0/yjwJJAAAAYCHCSGB5qs77kjyraf1pkjd4hyQAAAAwH2EksHxV5x3pjoysk/xhkvenau083KIAAACAUSOMBFZG1fn3JE9Id1GbxyT5VKrWXsMtCgAAABglwkhg5VSdk5P8fpIrk9w3yVdTtW433KIAAACAUSGMBFZW1fl8kvskuSDJHZJ8N1Xr5ala64dbGAAAADBswkhg5VWd7yY5Jsl0kp2SvCrJKalaRw+zLAAAAGC4Sl3Xw65hqEopeyXpJGnVdX35sOuBVaVqlSRPTvKGJHs3Rz+b5B+TfD5VZ21/AQEAAMAqsJR8TRgpjIT+q1oHpxtAPjZbRmT/IMm/J/lgqs5FwyoNAAAAWB5h5BIII2GAqtYtkvxJkmcm2b05ujHJp5O8J8nHU3WuHVJ1AAAAwHYQRi6BMBKGoGrtneTp6U7hPnbWmYuTvDvJW1N1fjyEygAAAIAlEkYugTAShqxq3TbJk5I8NcnNZp35SpL/l+RjqTobh1EaAAAAsG3CyCUQRsKIqFrrkzwoyXOSTGTLuyV/leRNSd6WqnPJkKoDAAAAFiCMXAJhJIygqnVIkucmeV6S/Zqj1yQ5KckbUnV+OKzSAAAAgBsSRi6BMBJGWNXaJckT0l305o6zznwuyTuSfDpVpzOM0gAAAIAuYeQSCCNhDFStkuTe6YaSD8uWKdzXJ/liko8n+UaSH6bqXDeUGgEAAGCNEkYugTASxkzVaqf7XslHJLnNnLPXJflBkjOS/DjJWc3+FxbBAQAAgP4QRi6BMBLGWNW6dbojJR+Y5Ngkey/Q8/okP8uWcPJ7Sb6V5OepOmv7SxAAAACWSRi5BMJIWCW6U7lvnm4oeYckt262WyXZdYFPXZJuKHlqs/92qs6F/S8WAAAAVg9h5BIII2GVq1o7JDk0W8LJ2yQ5LskxSXaa5xO/yA0DyjNSda4aTLEAAAAwfoSRSyCMhDWqau2U7gjKuya5S7PNfQdlz2+S/HSe7WepOlf0v1gAAAAYXcLIJRBGAv+narWS3CndYPKuzXbgNj51XpKzk/yk2fd+/lmqzjX9KxYAAABGgzByCYSRwFZVrZskueWs7YhZP++3jU//Ksn/Jvlhs//fJD8ymhIAAIDVRBi5BMJIYLtVrb3TDSd7261m7Vtb+eSv0g0of5pkJskvZ+0vssI3AAAA40QYuQTCSGDFdVf23i/dd1DeNsntZu23Ne376nRDyV8l+e2CmyngAAAAjAhh5BIII4GB6k77vm2z3TxJO8nhzf6gJVypk24weV62FlomHSMtAQAA6Cdh5BIII4GRUbV2SXJousHkoemGk73twFk/77KEq27IjQPLC5NcluTSWdvs9jUCTAAAABZLGLkEwkhgrHSngLdy44ByvuBy7+28y3W5YTg59+dOksubfWee9hWpOpu3894AAACMGWHkEggjgVWrau2aLcHk7OBy3yT7zNr2nvXzuhW4c53kima7Kt33YF495+e529bO9bYNzXZNkmtTdTatQK0AAAAskzByCYSRAI3uqMs9csNwcm5Y2Zqz7TWnvdMAK74+WwLKXki5YZ5t7vFr0x392Y9toynuAADAWiOMXAJhJMAKqlo754ZB5a5Jdk+y2zzbUo7vnmTnJOsH94vZblsPK2+4bZrn2PZuW7vW5mbbNGe/PcdW8jP1DTZBLgAAjCVh5BIIIwHGSNVan24ouUu6Qecu82xbO75ruqM3V3Jj5dXzbDcOL7e+LbX/9n5mvr9ILfbYUvou9/OjeK96keeW2h7Hz/a7js1z9it9rF/X7f089x80Fvp5Oce25zP+EQUAGsLIJRBGArDdulPb1+eG4eTOWTi4XNf0X2jb1vnFbrOvs2OS0hzbYdZ+MT8vt2/Z/t9cgLGw2ABz9uj1Qf48jPttOS6sBVgzhJFLIIwEgD7phrU7ZOEQsyxx26HP/bfnM3M5trhjK9nu57WH3V6Ja819tufux+Hc7O+Nuf8AstxjWzvH8m3O9r1eZFvnt/dcv6679XNVZ/OyfycBRpwwcgmEkQAAwI1UrflGgG9PyDl7m28E+3J+Xslrbe/9dtze3+I1pM74B6vzjfrd2n4pfW+4N6IWxpIwcgmEkQAAAMvQDW639qqR7T23nM8O4547LPe3kiRb3hfb7+BzkO/KHda7eHuBz0L7rZ3rd99B3HtrtvY6oW29ami55z+eqrNhG33GzlLytXFYlRQAAIBR1Z2GvDnJ9cMuZai6rydZKKwcRui6UtfdMQuP/l3qfjF6v49el8BqtX+SVRdGLoUwEgAAAJarO724N62Z+WwJbFcq3Nze/ex3Vy/m/bVLOT9Kx7KV/dbO9bvvoO692KnAi+m3ktda2/9wE9O0TdMGAAAAgGVYSr7mnRYAAAAAwEAIIwEAAACAgRBGAgAAAAADIYwEAAAAAAZCGAkAAAAADIQwEgAAAAAYCGEkAAAAADAQwkgAAAAAYCCEkQAAAADAQAgjAQAAAICBEEYCAAAAAAMhjAQAAAAABkIYCQAAAAAMhDASAAAAABgIYSQAAAAAMBDCSAAAAABgIISRAAAAAMBACCMBAAAAgIEQRgIAAAAAAyGMBAAAAAAGQhgJAAAAAAyEMBIAAAAAGAhhJAAAAAAwEMJIAAAAAGAghJEAAAAAwECsH3YBI2TPUsqwawAAAACAcbPnYjsKI7f8Zv16qFUAAAAAwHjbM8nlW+tQ6roeUC2jqXSHQx6c5Iph19JHe6Ybth6S1f3rhMTzztrjmWct8byz1njmWUs876w1q/GZ3zPJufU2wsY1PzKy+Q36zbDr6KdZ08+vqOt6q+k0jDvPO2uNZ561xPPOWuOZZy3xvLPWrNJnflG/DgvYAAAAAAADIYwEAAAAAAZCGLk2XJvkFc0eVjvPO2uNZ561xPPOWuOZZy3xvLPWrNlnfs0vYAMAAAAADIaRkQAAAADAQAgjAQAAAICBEEYCAAAAAAMhjAQAAAAABkIYuYqVUnYupfxDKeXcUso1pZRTSyknDrsuWI5SygmllHqB7W5z+t6jlPK1UsrVpZTzSilvKKXsMazaYVtKKXuUUl5RSvlMKeWS5rl+2gJ9j2z6Xdn0/Y9Syk3n6bdDKeXPSim/KKVsKKV8v5TyhL7/YmAbFvu8l1LetcB3/o/n6et5ZySVUu5cSnljKeV/SylXlVJ+VUr5YCnlVvP09f3O2FvsM+87ntWglHK7UsqHSik/b/7b86JSyldKKQ+Zp6/v+CTrh10AffWuJI9O8s9Jzk7ytCSfKqX8bl3XXxteWbAi3pDk23OO/bT3Qynl6CRfSPKjJC9OckiSlyY5IsnvDaZEWLL9kvxNkl8l+V6SE+brVEo5JMlXknSS/EWSPdJ9vm9fSrlLXdfXzer+90kmk7w13T8zD0vyvlJKXdf1B/r064DFWNTz3rg2ybPmHOvM08/zzqj68yT3TPKhJN9PcmCSP0zy3VLK3eq6PjPx/c6qsqhnvuE7nnF3eJI9k7w7yblJdkvyqCSfKKU8t67rtyS+42crdV0Puwb6oJRylySnJnlZXdeva47tkuTMJBfUdX2PYdYH26uUckKSLyZ5TF3XH95Kv08lOTrJbeq6vrw59qx0v8wfWNf1f/e9WFiiUsrOSfap6/q8Usqd0v2Lx9Prun7XnH7/mu4/MN2mrutfNcfun+RzSWb/hedmSX6R5C11Xf9hc6wk+XKSmydp13W9aRC/NphrCc/7u5I8uq7rrY5s97wzykop90jyndn/oVlKOSLJD5J8uK7rJzfHfL+zKizhmX9XfMezCpVS1iU5LckudV3fpjnmO75hmvbq9egkm5K8pXegrusNSd6e5O6llEOHVRislFLKnqWUG43wLqXsleTEJO/pBZGNk5JcmeSxAyoRlqSu62vruj5vEV0fleS/en+JaT77+SQ/yQ2f74cl2THJv87qVyf5t3RHC999JeqG7bGE5z1J9y/1zff7QjzvjKy6rr8xZ8RL6ro+O8n/Jjly1mHf76wKS3jmk/iOZ/VpwsJzkuw967Dv+IYwcvU6JslP5gQxSfKtZn/0YMuBFffOJJcn2VBK+WIzqqbn9um+huI7sz/Q/IXojHT/fMBYav6ldP/Meb4b38oNn+9jklyV7usK5vZL/FlgfOyW7nd+p3m/0pvKjd8B7HlnrDSjXA5IclHT9v3Oqjb3mZ/FdzyrQill91LKfqWU3yml/Gm6rwf7QnPOd/ws3hm5eh2U5LfzHO8dO3iAtcBKui7Jfyb5VLp/kbltuu/Z+Gop5R51XZ+e7vOfLPxn4PhBFAp9sq3n+yallJ3rur626Xt+feN3svj/AsbJb5O8Jsl30/2H9AcleUGSO5ZSTqjremPTz/POuHlSkpul++7UxPc7q9/cZz7xHc/q8o9Jntv8vDnJR9J9V2riO/4GhJGr167pvgh4rg2zzsPYqev6G0m+MevQJ0opH073xdivTvcvML3ne6E/A55/xtm2nu9en2vj/wtYBeq6fvmcQx8opfwk3Re7PzpJ7yXunnfGRinlNknelOSUdBc8SHy/s4ot8Mz7jme1+eckH043LHxsknVJdmrO+Y6fxTTt1euaJDvPc3yXWedhVajr+qdJPp7kd5sXBfee74X+DHj+GWfber5n9/H/BaxW/5TuiIP7zzrmeWcslFIOTDKd7mqqj561CIHvd1alrTzzC/Edz1iq6/rHdV1/vq7rk+q6fnC6q2V/snlFge/4WYSRq9dvs2UY8Gy9Y+cOsBYYhHPS/Ven3bNl+PpCfwY8/4yzbT3flzTTO3p9D2z+AjS3X+LPAmOqrutrklyc5CazDnveGXmllFaST6e7oMGD6rqe/Vz6fmfV2cYzPy/f8awiH05y5yS3iu/4GxBGrl5nJLnVPCuS3XXWeVhNbpHusPUrk5yZZGOS2YvapJSyU7qLN50x4NpgxdR1/ZskF2bO8924S274fJ+R7kvh565a6f8LGGullD2T7Jfun4WeM+J5Z4SVUnZJ8sl0/6P0wXVd/3D2ed/vrDbbeua38jnf8awWvenULd/xNySMXL0+nO77CZ7TO1BK2TnJ05OcWtf1OcMqDJajlHLTeY7dMclDk/x3Xdeb67ruJPl8kic3f5npeUq6Q+U/NJBioX/+M8mDSymH9g6UUu6X7l/2Zz/fH09yfbovgu/1K0mel+Q3ueH7V2HklFJ2mfM93vPXSUqSz8w65nlnZDWvkTk5yd2TPKau61MW6Or7nVVhMc+873hWi1LK/vMc2zHJH6Q7pboXxPuOb1jAZpWq6/rUUsqHkry6+YPx0yRPTdJO8sxh1gbLdHIp5Zp0v4AvSHc17eckuTrJ5Kx+f9n0+XIp5S1JDknyknQDy88ERlQp5Q/TncrUWyXvIaWUQ5qf/18Ttr8qyWOSfLGU8i/phuwvS/KDJO/sXauu61+XUv45ycuavxB9O8nD011R/kmLeGcT9NW2nvck+yQ5vZTy/iQ/bo4/MMnvp/sfqR/vXcvzzoj7x3T/4fST6a6Y+uTZJ+u6fk/zo+93VovFPPMHxnc8q8Obm1mpX0k3LDww3dXjb5PkJXVdX9n08x3fKDdeKZzVohkW/7dJnpzuX+a/n+Sv67r+7FALg2Uopfxxul/st0yyV7pD3b+Q5BXNQjaz+94ryT8kOTbJFUk+mOTldV1fMdCiYQlKKTNJDl/g9M3rup5p+t0uyeuT3CvJdem+GP4ldV2fP+d6OyT58yTPTfc9M2cneXVd1+/tR/2wFNt63pNclm4oebd0A8t16f4D63uTvK6u6+vnXM/zzkgqpXwpyX0WOl/XdZnV1/c7Y28xz3wpZe/4jmcVKKU8Pt1BX7dPsm+6/+15WroDCT4xp6/v+AgjAQAAAIAB8c5IAAAAAGAghJEAAAAAwEAIIwEAAACAgRBGAgAAAAADIYwEAAAAAAZCGAkAAAAADIQwEgAAAAAYCGEkAAAAADAQwkgAAFZUKeVdpZSZYdcxKKWUp5VS6lLKnYZdCwDAqBNGAgCsEU1gtpjthGHXCgDA6rR+2AUAADAwT5nT/oMkJ85z/EfLvM+z4x+9AQCYhzASAGCNqOv6PbPbpZS7JTlx7vG5Sim71XV99RLuc/12lggAwCrnX6wBAPg/pZQvlVLOLKUcV0r5Sinl6iSvas49rJQyXUo5t5RybSnlZ6WUvy6lrJtzjRu8M7KU0m6mf7+0lPKc5nPXllK+XUq58yLr2ruU8s+llHOaz/60lPLnpZQdZvWZfZ8/LaX8spRyTSnly6WUo+a55n1LKV8tpVxVSrmslPLxUsqR8/S7WSnl7bN+3b8opfxbKWWnOV13LqW8vpRyYXPNj5ZSbrqYXx8AwFphZCQAAHPtm+TTST6Q5D1Jzm+OPy3JlUle3+zvm+SVSfZK8rJFXPeJSfZM8uYkdZI/S/KRUsottjaaspSyW5IvJ7lZ89lfJblHklcnOSjJi+Z85A+a+7wpyS5J/iTJ/5RSbl/X9fnNNe/f/Bp/nqRKsmuSP0ry9VLKsXVdzzT9Dk7yrSR7J3lLkh83dTw6yW5Jrpt13/+X5NIkr0jSbup6Y5LHLeL3BgBgTRBGAgAw14FJnlfX9ZvnHH9iXdfXzGr/eynl35O8oJTyV3VdX7uN6x6W5Ii6ri9NklLKWUk+nuSBSf5rK597cZLfSXJMXddnN8feXEo5N8nLSin/WNf1ObP637K5z2+a+3wmyalJ/ry5VpK8NsklSe5e1/UlTb+PJTk93TDxqU2/Vze/H3et6/o7s+7xN6WUMqfOi5M8oK7rurneDkn+uJTSquu6s/XfGgCAtcE0bQAA5ro2yTvnHpwdRJZS9iyl7Jfkq+mOELzNIq57ci+IbHy12d9iG597TNP30lLKfr0tyeeTrEty7zn9P9YLIpu6v5VuGPn7Te0HJTk6ybt6QWTT7/tJPjer3w5JHp7kk3OCyF7/es6ht8w59tWmvsO38esDAFgzjIwEAGCu39R1fd3cg6WU2yX5u3SnZ+8153RrEdf91exGXdeXNoML99nG545IcockFy5wfv857bPn6fOTJI9tfu6Fg2fN0+9HSR5YStk9yR7p/jrP3EZ9Pb+a0+4Fr9v69QEArBnCSAAA5rpm7oFSyt7pvrfx8iR/k+RnSTYkOTbJP2RxM242LXB87nTnuXZId8TiaxY4/5NF3HsQtvfXBwCwZggjAQBYjBPSXdjmkXVdf6V3sJRy8wHc+2dJ9qjr+vOL7H/EPMdulWSm+fmXzf7W8/S7TZKL6rq+qpRyTbrh641W4gYAYPt4ZyQAAIvRG/X3f6P8Sik7JXnBAO79wSR3L6U8cO6JUsrepZS5/8D+8FLKzWb1uUuSu6a7enbquv5tkjOSPLUZ8dnrd1SSByT5VNNvc5KPJXlIKeVO89zbiEcAgCUyMhIAgMX4RrrvQHx3KeUNSeokT8lgpiC/NslDk/xXKeVdSU5LsnuS2yd5dJJ2kotm9f9pkq+VUv4tyc5JXpTuStezp3m/LN1w8pRSytuT7Jrkj5J0klSz+v1FugHll0spb0n3nZIHpbuozr2SXLZSv0gAgLVAGAkAwDbVdX1xKeXBSf4x3UVsLk3yniRfSPLZPt/76lLKfdINBh+T5A/SnT79kyT/X7oB4mwnJdmcbgi5f5JvJfnDZkRk75qfL6U8KMkrkrwyyfXpvhPzz+u6/sWsfr8ppdw1yd8meVK6C9r8Jt0g8+oV/8UCAKxypa7rYdcAAADLVkppJ/lFkpfVdf26IZcDAMA8vDMSAAAAABgIYSQAAAAAMBDCSAAAAABgILwzEgAAAAAYCCMjAQAAAICBEEYCAAAAAAMhjAQAAAAABkIYCQAAAAAMhDASAAAAABgIYSQAAAAAMBDCSAAAAABgIISRAAAAAMBACCMBAAAAgIH4/wFnXGskqg1hYAAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -373,7 +373,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 12, "id": "08f1cba4", "metadata": { "editable": true, @@ -388,7 +388,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAx4AAAK0CAYAAACNyusCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA+XUlEQVR4nO3de5idZXkv/u+dkBNJCCcJIB5QEKvWE/W4PWDRqq3Wc3WjVbHWam3raVtLt1VQWy3bbW2VtmqtYq11t2JbrSDdeNhofxQt1gNoqQpagYRDAiSQ88zz+2NNZoZJAjND3rXWzHw+1/Vek/W+a63nzuAyc8/3ed6nWmsBAADo0qJBFwAAAMx/Gg8AAKBzGg8AAKBzGg8AAKBzGg8AAKBzGg8AAKBzGg8AAKBzGg8AAKBzGg8AAKBzGg8AAKBzGg8AACBJUlW/U1Wtqt476dzyqjqrqjZU1S1VdU5VrZ3pe2s8AACAVNXDkvxakm9PufRHSZ6e5HlJHp/k6CSfnun7azwAAGCBq6pVSf46ya8muXHS+TVJfiXJ61trX2ytXZLk1CSPrqpHzmSMA/ZjvQNXVZVeB7Z50LUAADBudZJrWmtt0IX0U1UtT7J00HVMsr21tn0f185K8rnW2gVV9eZJ509MsiTJBbtPtNb+o6r+K8mjkvzrdAefV41Hek3HVYMuAgCAPRyT5OpBF9EvVbX8yCMWb11/3cigSrglyaop585IcvrUJ1bVC5I8NMnD9vI+RybZ0Vq7acr5a8euTdt8azw2J8mPv3HPHLTKLDKYjmfd56cHXQIA89iu7MxXc26y8GakLF1/3Uh+fMk9c9Dq/v5cumnzaO5x4o9WpdfsTf6+75F2VNXdkvxxkie11rZ1Wdd8azySJAetWtT3/8AwVx1QSwZdAgDz2YKaXLWnVasrq1ZXX8cczfh4m1trm+7g6ScmOSLJN3qrFpIki5M8rqp+I8mTkyytqoOnpB5rk6yfSV3zsvEAAACm5QtJpk5/+EiS/0jyh0l+kmRnkpOTnJMkVXVCkrsnuWgmA2k8AABggWqtbU5y6eRzVXVrkg2ttUvHHn84yXuqamOSTUnel+Si1tq0F5YnGg8AAOjMSBvNSJ+nm4200f39lq9LMppe4rEsyflJfn2mb6LxAAAAxrXWTpryeFuSV48ds6bxAACAjoymZbTPK+z7Pd50ufUTAADQOYkHAAB0ZDSj2e8rLqYx5jCSeAAAAJ3TeAAAAJ0z1QoAADoy0lpGWn8Xe/d7vOmSeAAAAJ2TeAAAQEfcTneCxAMAAOicxgMAAOicqVYAANCR0bSMmGqVROIBAAD0gcQDAAA6YnH5BIkHAADQOYkHAAB0xAaCEyQeAABA5zQeAABA50y1AgCAjoyOHf0ecxhJPAAAgM5JPAAAoCMjA9hAsN/jTZfEAwAA6JzGAwAA6JypVgAA0JGR1jv6PeYwkngAAACdk3gAAEBH3E53gsQDAADonMQDAAA6MprKSKrvYw4jiQcAANA5jQcAANA5U60AAKAjo6139HvMYSTxAAAAOifxAACAjowMYHF5v8ebLokHAADQOY0HAADQOVOtAACgI6ZaTZB4AAAAnZN4AABAR0ZbZbT1eefyPo83XRIPAACgcxIPAADoiDUeEyQeAABA5zQeAABA50y1AgCAjoxkUUb6/Lv+kb6ONn0SDwAAoHMSDwAA6EgbwO10m9vpAgAAC5XGAwAA6JypVgAA0BH7eEyQeAAAAJ2TeAAAQEdG2qKMtD7fTrf1dbhpk3gAAACdk3gAAEBHRlMZ7fPv+kcznJGHxAMAAOicxgMAAOicqVYAANARt9OdIPEAAAA6J/EAAICODOZ2uhaXAwAAC5TGAwAA6JypVgAA0JHePh79Xezd7/GmS+IBAAB0TuIBAAAdGc2ijNi5PInEAwAA6AONBwAA0DlTrQAAoCP28Zgg8QAAADon8QAAgI6MZlFGLS5PIvEAAIAFrapeVVXfrqpNY8dFVfXUSde/XFVtyvHnMx1H4gEAAB0ZaZWR1t8N/WYx3lVJfifJ95NUkpck+ceqekhr7bKx53woyVsmvWbLTAfReAAAwALWWvvslFP/s6peleSRSXY3Hltaa+vvzDimWgEAwPy0uqoOmnQsu6MXVNXiqnpBkpVJLpp06YVVdUNVXVpV76yqA2dajMQDAAA6MjKAnctHJhaXXzXl0hlJTt/ba6rqp9NrNJYnuSXJs1pr3x27/IkkP05yTZIHJvnDJCckefZM6tJ4AADA/HRMks2THm+/nedenuTBSdYkeW6Ss6vq8a2177bWPjjped+pqnVJvlBV926t/XC6xWg8AACgI6NtUUb7vIHg6MQGgptba5um85rW2o4kPxh7eElVPSzJa5L82l6efvHY1+OSTLvxsMYDAACYalGSfa0JefDY13UzeUOJBwAALGBV9c4k5yX5rySrk5yS5KQkT66qe489PjfJhvTWePxRkgtba9+eyTgaDwAA6MiAF5dP1xFJPpbkqCQ3J/l2kie31v5vVd0tyROTvDa9O139JMk5Sd4x00E0HgAAsIC11n7ldq79JMnj98c4Gg8AAOjIaGa1k/idHnMYWVwOAAB0TuIBAAAdGc2ijPb5d/39Hm+6hrMqAABgXtF4AAAAnTPVCgAAOjLSFmWkzzuX93u86RrOqgAAgHlF4gEAAB0ZTWU0/b6dbn/Hmy6JBwAA0DmNBwAA0DlTrQAAoCMWl0/QeNCJT/zx2pz9h0flHidszQe/dPltrl329QPz4XccnR9858AcuHokj3v6TTn1tHVZsXJ0QNXC8FiydDQvfuP6nPycG7NqzUiu/N6KnH3mkfnGhasHXRoMJZ8ZmDuGsx1iTrv+miX55J8ckeUHjuxx7YeXrsjvPP+4bN+6KK84/eo85ZQNOfevD8s7XnHP/hcKQ+gN7/1Jnv2K6/PFvz8kf/aWu2Z0NHn7X12R+z/8lkGXBkPJZ4ZhN5JFAzmGkcSD/e5Dbzs6P3XiloyOVG7euPg21z7yrqOyas1IzjznB1m5updwrD1mR977xrvnki+vzoknbR5EyTAUTnjwljzhmTflQ287Kp/68yOSJBd86pB88IuX5+VvXpfX/eLxA64QhovPDMwtw9kOMWd9519X5iufOzivPOPqPa7dunlRvnHh6pz87I3jTUeSPPF5N2bFypFc+NmD+1gpDJ/HPO2mjOxKzv34YePndm5flM//zaG5389syV2O3jHA6mD4+MwwF4y2GsgxjIay8aiqV1fVj6pqW1VdXFUPH3RN3LGRkeSsNx+Tp5yyIcf+1LY9rv/oeysysqty/IO23ub8kqUt97r/1vzg0hX9KhWG0nEP2JqrrliWLbfcNim8/JsHJknudf+te3sZLFg+MzC3DF3jUVXPT/KeJGckeWiSbyU5v6qOGGhh3KHPfezwXHfV0rzkt9ft9frG63oz+w5du3OPa4eu3ZmN1y7ptD4YdocesWuvn4Pd5w5bu6vfJcFQ85mBuWUY13i8PsmHWmsfSZKqemWSX0jysiTvmvzEqlqWZNmkU25hMSCbNi7Ox959ZE557focfNiei8qTZPu2Xp+7ZGnb49rSZW38OixUS5ePZueOPePxHdt755Ytd+c3mMxnhrlgdACLvUeHL1tIMmSJR1UtTXJikgt2n2utjY49ftReXnJakpsnHVf1oUz24qNnHpXVB4/kGS+7YZ/P2f0PwL7+kfAPBAvdjm2L9tmYJ9GcwxQ+MzC3DFvicXiSxUmunXL+2iT33cvz35netKzdVkfz0XdXX7E05338sLzyjKuzYVLkvWN7ZWRnZf1PlubAVSM59Ihe5L2vWHxvU7BgIdl43QE57Mi9T0VMkg3XDtv/ZcNg+cwwF4y2RRnt84Z+/R5vuub0J7K1tj3J9t2Pq4ZzBf98d8P6pRkdrfzp7x2TP/29Pa+/5BH3yzNffn1e/D/WZfEBLd//1oo8/hdvGr++c0flistW5HFPv2nPF8MC8sPLVuRBj74lB64auc1i2fs+ZEuS5IrL3IABJvOZgbll2NqhG5KMJFk75fzaJOv7Xw7Tcc8TtuatH75yj+MeJ2zNEXfdkbd++Mo85b9vyMqDRvOQx27OFz59aLbcMvE/vS986pBsvXVxHqvxYIH7yj+tyeIDkp9/0Ybxc0uWjubnnr8x37vkwFx/zdIBVgfDx2cG5pahSjxaazuq6pIkJyf5hySpqkVjj98/wNK4HWsOG8mjn3rzHuf//i/ukiS3ufbSN63L655xfN747OPy1BdtyA3rluScDxyREx+/KQ97gs0DWdgu//eVufAza3Lqaeuy5vBduebKZXnSL23M2rvtyHvecLdBlwdDx2eGuWAklZH0d1ZOv8ebrqFqPMa8J8nZVfVvSb6W5LVJVib5yCCLYv84/oFb865P/jAf/v2j8oHT75oVK0fy5BdsyMt+d++34IWF5szX3D0vuXp9Tn7OjVm9ZiRXfm953vLiY3PpxasGXRoMJZ8ZmDuqtT3vBjFoVfUbSd6Y5Mgk30zyW621i6fxuoOS3Hzjf94rB60etllkMJyefPSDB10CAPPYrrYzX84/Jsma1tqmQdfTL7t/Lj3j4idm+ar+/q5/2y278tZHXJAM2fd8GBOPtNbeH1OrAABg3hjKxgMAAOaDkfR/zcXet3IePPORAACAzmk8AACAzplqBQAAHbFz+YThrAoAAJhXJB4AANCRkbYoI31OIPo93nQNZ1UAAMC8ovEAAAA6Z6oVAAB0pKUy2ud9PFqfx5suiQcAANA5iQcAAHTE4vIJw1kVAAAwr0g8AACgI6OtMtr6u+ai3+NNl8QDAADonMYDAADonKlWAADQkZEsykiff9ff7/GmazirAgAA5hWJBwAAdMTi8gkSDwAAoHMaDwAAoHOmWgEAQEdGsyijff5df7/Hm67hrAoAAJhXJB4AANCRkVYZ6fNi736PN10SDwAAoHMSDwAA6Ijb6U6QeAAAAJ3TeAAAAJ0z1QoAADrS2qKMtv7+rr/1ebzpGs6qAACAeUXiAQAAHRlJZSR9vp1un8ebLokHAADQOY0HAADQOVOtAACgI6Ot//tqjLa+DjdtEg8AAKBzEg8AAOjI6ABup9vv8aZrOKsCAADmFY0HAADQOVOtAACgI6OpjPZ5X41+jzddEg8AAKBzEg8AAOjISKuM9Pl2uv0eb7okHgAAsIBV1auq6ttVtWnsuKiqnjrp+vKqOquqNlTVLVV1TlWtnek4Eg8AAOjIHLmd7lVJfifJ95NUkpck+ceqekhr7bIkf5TkF5I8L8nNSd6f5NNJ/ttMBtF4AADAAtZa++yUU/+zql6V5JFVdVWSX0lySmvti0lSVacm+V5VPbK19q/THcdUKwAAmJ9WV9VBk45ld/SCqlpcVS9IsjLJRUlOTLIkyQW7n9Na+48k/5XkUTMpRuIBAAAdGU1ltM+LvSfdTveqKZfOSHL63l5TVT+dXqOxPMktSZ7VWvtuVT04yY7W2k1TXnJtkiNnUpfGAwAA5qdjkmye9Hj77Tz38iQPTrImyXOTnF1Vj9+fxWg8AACgI20AGwi2ifE2t9Y2Tes1re1I8oOxh5dU1cOSvCbJ/0mytKoOnpJ6rE2yfiZ1WeMBAABMtSjJsiSXJNmZ5OTdF6rqhCR3T29q1rRJPAAAYAGrqncmOS+9BeOrk5yS5KQkT26t3VxVH07ynqramGRTkvcluWgmd7RKNB4AANCZ0TaAxeUzH++IJB9LclR6+3R8O72m4/+OXX9dktEk56SXgpyf5NdnOojGAwAAFrDW2q/cwfVtSV49dsyaxgMAADoyR3Yu74vhrAoAAJhXJB4AANCRObLGoy8kHgAAQOc0HgAAQOdMtQIAgI6MDmDn8n6PN10SDwAAoHMSDwAA6IjF5RMkHgAAQOc0HgAAQOdMtQIAgI6YajVB4gEAAHRO4gEAAB2ReEyQeAAAAJ2TeAAAQEckHhMkHgAAQOc0HgAAQOdMtQIAgI60JKPp79Sn1tfRpk/iAQAAdE7iAQAAHbG4fILEAwAA6JzGAwAA6JypVgAA0BFTrSZIPAAAgM5JPAAAoCMSjwkSDwAAoHMSDwAA6IjEY4LEAwAA6JzGAwAA6JypVgAA0JHWKq3PU5/6Pd50STwAAIDOSTwAAKAjo6mMps+Ly/s83nRJPAAAgM5pPAAAgM6ZagUAAB2xj8cEiQcAANA5iQcAAHTE7XQnSDwAAIDOSTwAAKAj1nhMkHgAAACd03gAAACdM9UKAAA6YnH5BIkHAADQOYkHAAB0pA1gcfmwJh7zsvF41n1+OgfUkkGXAXPC+dd8c9AlwJzz1Hs9ctAlwJyxqC1Ktg26CoaBqVYAAEDn5mXiAQAAw6Alaa3/Yw4jiQcAANA5iQcAAHRkNJVKn3cu7/N40yXxAAAAOifxAACAjthAcILEAwAA6JzGAwAA6JypVgAA0JHRVqk+T33q907p0yXxAAAAOifxAACAjrQ2gA0Eh3QHQYkHAADQOY0HAADQOVOtAACgI/bxmCDxAAAAOifxAACAjkg8Jkg8AACAzmk8AACAzplqBQAAHbFz+QSJBwAA0DmJBwAAdMTO5RMkHgAAsIBV1WlV9fWq2lxV11XVP1TVCVOe8+WqalOOP5/JOBIPAADoSC/x6PftdGf8kscnOSvJ19PrD/4gyT9X1f1aa7dOet6Hkrxl0uMtMxlE4wEAAAtYa+0pkx9X1UuTXJfkxCQXTrq0pbW2frbjmGoFAADz0+qqOmjSsWyar1sz9nXjlPMvrKobqurSqnpnVR04k2IkHgAA0JEB71x+1ZRLZyQ5/fZeW1WLkrw3yb+01i6ddOkTSX6c5JokD0zyh0lOSPLs6dal8QAAgPnpmCSbJz3ePo3XnJXkAUkeM/lka+2Dkx5+p6rWJflCVd27tfbD6RSj8QAAgI60saPfY47Z3FrbNN3XVdX7kzwtyeNaa1PTkqkuHvt6XBKNBwAAcPuqqpK8L8mzkpzUWrtyGi978NjXddMdR+MBAAAL21lJTknyjCSbq+rIsfM3t9a2VtW9x66fm2RDems8/ijJha21b093EI0HAAB0ZMCLy6frVWNfvzzl/KlJPppkR5InJnltkpVJfpLknCTvmMkgGg8AAFjA2h10Kq21n6S3yeCdovEAAICuDHh1+TCxgSAAANA5iQcAAHRlAGs80u/xpkniAQAAdE7jAQAAdM5UKwAA6EhrvaPfYw4jiQcAANA5iQcAAHRkjmwg2BcSDwAAoHMaDwAAoHOmWgEAQFda9X9fDVOtAACAhUriAQAAHXE73QkSDwAAoHMSDwAA6EobO/o95hCSeAAAAJ3TeAAAAJ0z1QoAADpi5/IJEg8AAKBzEg8AAOjSkC727jeJBwAA0DmNBwAA0DlTrQAAoCMWl0+QeAAAAJ2TeAAAQFfsXD5O4gEAAHRO4gEAAJ2psaPfYw4fiQcAANA5jQcAANA5U60AAKArFpePk3gAAACdk3gAAEBXJB7jptV4VNXjZvPmrbULZ/M6AABgfplu4vHlzKx3qrHnL55pQQAAwPwz3cbjCZ1WAQAA81Gr3tHvMYfQtBqP1tr/67oQAABg/rrTi8ur6qgkRyT5QWvt1jtfEgAAzA+t9Y5+jzmMZn073ap6RlX9R5KrknwjySPGzh9eVf9eVc/cPyUCAABz3awaj6p6epJPJ7khyRnpLSZPkrTWbkhydZJT90eBAAAwZ7UBHUNotonHW5Jc2Fp7TJKz9nL9oiQPmXVVAADAvDLbxuMBSf72dq5fm966DwAAgFkvLt+SZOXtXL9Xkg2zfG8AAJgf3E533GwTjy8leUlV7dG4VNWRSX41yT/fmcIAAID5Y7aJx/9M8q9Jvp7k79JbwvLkqvrZJL+W3mLzM/ZLhQAAMEdV6x39HnMYzSrxaK1dnuQx6U2nent6jcYbk/xuku8keWxr7Uf7qUYAAGCOm/UGgq21y5I8saoOSXJcek3MFa216/dXcQAAwPxwp3cub63dmN6UKwAAYLJB7Ksxn6ZaJUlV3aWq3l1V362qLWPHd8fOrd2fRQIAAHPbrBKPqrp/ki+kt1fHxektME+S+yR5fZJfrqqTW2uX7pcqAQBgLnI73XGznWp1VpLFSR7RWrvNNKuqeniSc5O8L8kT7lx5AADAfDDbqVYPT/LHU5uOJGmtfS3JHyd5xJ0pDAAA5rw2oGMIzbbxuC7Jttu5vm3sOQAAALNuPN6b5FVju5TfRlUdneRVY88BAACY3hqPqnr9Xk7fkuQHVfX3SX4wdu74JM8cezycq1oAAKBf3E533HQXl7/7dq69cC/nHjj2mj+acUUAAMC8M93G49hOqwAAgPlI4jFuWo1Ha+3HXRcCAADMX7PeuRwAAGC6ZruBYKrqgUl+M8lDk6zJnk1Ma63d+07UBgAAc5udy8fNKvGoqpOSfC3J05Jck+ReSa4Y+/M90rvj1YX7pUIAAGDOm23i8bb0Go1HJlma3maBf9Ba+2JVPSLJeUnetH9KBACAuala7+j3mMNotms8Hprkw621TUlGxs4tTpLW2sVJPpDk7Xe+PAAAYD6YbeKxK8nmsT/flGRnkiMmXb8iyf1mXxbzxZKlo3nxG9fn5OfcmFVrRnLl91bk7DOPzDcuXD3o0mCofOKP1+bsPzwq9zhhaz74pctvc+2yrx+YD7/j6PzgOwfmwNUjedzTb8qpp63LipWjA6oWhsfyA0fy3FesywkPuiUnPOiWrD54JP/7jffKBefcZdClAVPMNvH4QXq7lKe11pL8R5JnTbr+C0nW37nSmA/e8N6f5NmvuD5f/PtD8mdvuWtGR5O3/9UVuf/Dbxl0aTA0rr9mST75J0dk+YEje1z74aUr8jvPPy7bty7KK06/Ok85ZUPO/evD8o5X3LP/hcIQOuiQXXnhb12dux23NVd878BBlwN7agM6htBsE49zk7ysqk5rre1K8p4kH6mq749dv3eS0/ZHgcxdJzx4S57wzJvyobcdlU/9eS8Qu+BTh+SDX7w8L3/zurzuF48fcIUwHD70tqPzUyduyehI5eaNi29z7SPvOiqr1ozkzHN+kJWrewnH2mN25L1vvHsu+fLqnHjS5r29JSwYN16/JKc8/CG58YalOf6nb8mf/ONlgy4J2IfZJh5vT/KgjK3vaK2dneTFSS5N8q0kL2ut/eF+qZA56zFPuykju5JzP37Y+Lmd2xfl839zaO73M1tyl6N3DLA6GA7f+deV+crnDs4rz7h6j2u3bl6Ub1y4Oic/e+N405EkT3zejVmxciQXfvbgPlYKw2nnjkW58Yalgy4DmIZZNR6ttZ2ttQ1j06x2n/t4a+1ZrbXnttY+Opv3rarHVdVnq+qaqmpV9czZvA/D4bgHbM1VVyzLlltu+xvcy7/Zi8Lvdf+tgygLhsbISHLWm4/JU07ZkGN/atse13/0vRUZ2VU5/kG3/awsWdpyr/tvzQ8uXdGvUgGYx6rqtKr6elVtrqrrquofquqEKc9ZXlVnVdWGqrqlqs6pqrUzGWfYdi5fmV5i8upBF8Kdd+gRu7Lx2iV7nN997rC1u/pdEgyVz33s8Fx31dK85LfX7fX6xut6s2EPXbtzj2uHrt25188XAMOlMnFL3b4dMy/z8UnOSm+rjCclWZLkn6tq5aTn/FGSpyd53tjzj07y6ZkMMq01HlX1xZm86ZjWWjt5hi84L709QFI1nDsuMn1Ll49m5449/zvu2N47t2y5O/KwcG3auDgfe/eROeW163PwYXsuKk+S7dt6vxtasnTPVYJLl7Xx6wBwZ7TWnjL5cVW9NL19+k5McmFVrUnyK0lOaa19cew5pyb5XlU9srX2r9MZZ7qLyxdl5uvjO+8cqmpZkmWTTrlH6xDZsW3RPn9gSuKHJha0j555VFYfPJJnvOyGfT5nd3O+rwZe8w7AHVg95Zf521tr26fxujVjXzeOfT0xvRTkgt1PaK39R1X9V5JHJdl/jUdr7aTpPG8ATkvy1kEXwd5tvO6AHHbk3qeIJMmGa2d7UzWY266+YmnO+/hheeUZV2fDpOlSO7ZXRnZW1v9kaQ5cNZJDj+hNR9zXlMW9TcECYMi06h39HrPnqilXzkhy+u29tKoWJXlvkn9prV06dvrIJDtaazdNefq1Y9emZa7/5PfO9G7lu9vq7PkNZkB+eNmKPOjRt+TAVSO3WWB+34dsSZJccZmFsSxMN6xfmtHRyp/+3jH509/b8/pLHnG/PPPl1+fF/2NdFh/Q8v1vrcjjf/Gm8es7d1SuuGxFHvf0m/Z8MQBMOCYTm34nyXTSjrOSPCDJY/Z3MXO68RiLisa/gdaFDJev/NOaPO9V1+fnX7RhfB+PJUtH83PP35jvXXJgrr/G7Q9ZmO55wta89cNX7nH+o2cema23LM6r3nZ1jrrn9qw8aDQPeezmfOHTh+aU112bA1f1plZ94VOHZOuti/NYjQfA8BvEhn4T421urW2a7suq6v1Jnpbkca21yb/MX59kaVUdPCX1WJsZbBo+pxsPhtvl/74yF35mTU49bV3WHL4r11y5LE/6pY1Ze7cdec8b7jbo8mBg1hw2kkc/9eY9zv/9X9wlSW5z7aVvWpfXPeP4vPHZx+WpL9qQG9YtyTkfOCInPn5THvYEmwdCkjz9l9dn5UEjOWxtb3+oR5x8Yw4/svfnz3xsbbZs9uMO3J7q/fb+fUmeleSk1trU345dkmRnkpOTnDP2mhOS3D3JRdMdZ6g+iVW1Kslxk04dW1UPTrKxtfZfg6mKO+PM19w9L7l6fU5+zo1ZvWYkV35ved7y4mNz6cWrBl0azAnHP3Br3vXJH+bDv39UPnD6XbNi5Uie/IINednv7v0WvLAQPedX12XtMROb0j7mKTfmMU+5MUnyxX84XOMBd+ysJKckeUaSzVW1e93Gza21ra21m6vqw0neU1Ubk2xKr1G5aLp3tEqSmrQH4MBV1UlJvrSXS2e31l46jdcflOTmk/KMHFDubw/Tcf413xx0CTDnPPVejxx0CTBn7Go78sVtf5ska2Yy7Weu2/1z6T3+4PezaPnyvo49um1bfvy7/zOZ5ve8qvbVEJy6e2Pwqlqe5H8n+e/p3VX2/CS/3lqbm1OtWmtfTh9uwwsAAPS0dse33WqtbUtvk+9Zb/R9pxqPqrprksclOSLJOa21q6pqcXr3/r25tbb3XbEAAGAB2L2beL/HHEaz2sGtet6T5Mokf53eLW3vM3Z5VZIfJfnN/VEgAAAw98126+g3JnlNkncneVImTY9qrd2c5NNJnnOnqwMAgLmsDegYQrNtPH41ycdaa7+b5Jt7uf7tTCQgAADAAjfbxuNuSf6/27l+a5KDZvneAADAPDPbxeXXpdd87MuJSey7AQDAwjbYncuHymwTj08neWVV3WvSuZYkVfVzSV6a5O/uXGkAAMB8MdvG461J1qW3vuNj6TUdb6qqryY5L701Hn+wPwoEAIC5avftdPt9DKNZNR5jd656ZJIzk9w1ybYkj09ycJIzkjy2tbZlP9UIAADMcbPeQLC1tjXJO8YOAACAfbpTO5cDAAC3o1Xv6PeYQ2hWjUdV/eU0ntZaa78ym/cHAADml9kmHj+bPW/UtTjJUWNfr09vLw8AAFi43E533Kwaj9baPfd2vqqWJPm1JK9N8qRZVwUAAMwr+3WNR2ttZ5L3V9X9krw/yS/sz/cHAIC5ZBC3t51Xt9Odhm8leVxH7w0AAMwxXTUeT0piHw8AACDJ7O9q9ZZ9XDo4vaTjoUneNcuaAABgfrC4fNxs13icvo/zNyb5YZJXJvnQLN8bAACYZ2Z7V6uupmgBAMD8MYDF5cOaeMy4gaiqFVX1nqp6ehcFAQAA88+MG4/W2tb09upYu//LAQAA5qPZrvG4JMkD9mchAAAw71hcPm62azVem+QFVfXyqtqvmxACAADzz7Sbhqp6XJLvtdauT3J2ktEkH0jyJ1V1dZKtU17SWmsP2m+VAgDAXCPxGDeTtOJLSV6U5G+SbEhyQ5LLuygKAACYX2bSeNTYkdbaSZ1UAwAA80gN4Ha6fb997zTZjwMAAOjcTBuPIe2fAACAYTbTxuPjVTUyzWNXJxUDAABzzkxvhXtBkv/sohAAAGD+mmnjcXZr7ROdVAIAAPON2+mOs7gcAADonMYDAADo3EynWgEAANNkH48J0248WmvSEQAAYFYkHgAA0KUhTSD6TYoBAAB0TuIBAABdcTvdcRIPAACgcxoPAACgc6ZaAQBAR9xOd4LEAwAA6JzEAwAAumJx+TiJBwAA0DmNBwAA0DlTrQAAoCMWl0+QeAAAAJ2TeAAAQFcsLh8n8QAAADon8QAAgK5IPMZJPAAAgM5pPAAAgM6ZagUAAB1xO90JEg8AAKBzEg8AAOiKxeXjJB4AAEDnNB4AAEDnTLUCAICumGo1TuIBAAB0TuIBAAAdcTvdCRIPAACgcxoPAACgc6ZaAQBAVywuHyfxAAAAOifxAACAjlhcPkHiAQAAC1hVPa6qPltV11RVq6pnTrn+0bHzk4/Pz3QciQcAAHRlbqzxWJnkW0n+Msmn9/Gczyc5ddLj7TMdROMBAAALWGvtvCTnJUlV7etp21tr6+/MOKZaAQDA/LS6qg6adCy7E+91UlVdV1WXV9WfVdVhM30DjQcAAHSlDejouSrJzZOO02b5t/h8khcnOTnJm5I8Psl5VbV4Jm9iqhUAAMxPxyTZPOnxjNdlJElr7ZOTHn6nqr6d5IdJTkryhem+j8YDAAA6UmNHv8ccs7m1tml/v39r7YqquiHJcZlB42GqFQAAMG1VdUySw5Ksm8nrJB4AALCAVdWq9NKL3Y6tqgcn2Th2vDXJOUnWJ7l3kjOT/CDJ+TMZR+MBAABdmRv7ePxMki9Nevyesa9nJ3lVkgcmeUmSg5Nck+Sfk/xea21Ga0Y0HgAAsIC11r6c21+K8uT9MY7GAwAAOlKtd/R7zGFkcTkAANA5iQcAAHRlbqzx6AuJBwAA0DmNBwAA0DlTrQAAoEtDOvWp3yQeAABA5yQeAADQEbfTnSDxAAAAOqfxAAAAOmeqFQAAdMU+HuMkHgAAQOckHgAA0BGLyydIPAAAgM5JPAAAoCvWeIyTeAAAAJ3TeAAAAJ0z1QoAADpicfkEjQcscE8++sGDLgHmnOs/c49BlwBzxsiW7cnzB10Fw0DjAQAAXbG4fJw1HgAAQOc0HgAAQOdMtQIAgK6YajVO4gEAAHRO4gEAAB1xO90JEg8AAKBzEg8AAOiKNR7jJB4AAEDnNB4AAEDnTLUCAICOVGup1t+5T/0eb7okHgAAQOckHgAA0BWLy8dJPAAAgM5pPAAAgM6ZagUAAB2xc/kEiQcAANA5iQcAAHTF4vJxEg8AAKBzEg8AAOiINR4TJB4AAEDnNB4AAEDnTLUCAICuWFw+TuIBAAB0TuIBAAAdsbh8gsQDAADonMYDAADonKlWAADQFYvLx0k8AACAzkk8AACgQ8O62LvfJB4AAEDnJB4AANCV1npHv8ccQhIPAACgcxoPAACgc6ZaAQBAR+xcPkHiAQAAdE7iAQAAXbGB4DiJBwAA0DmNBwAA0DlTrQAAoCM12jv6PeYwkngAAACdk3gAAEBXLC4fJ/EAAAA6p/EAAAA6Z6oVAAB0xM7lEyQeAABA5yQeAADQldZ6R7/HHEISDwAAWMCq6nFV9dmquqaqWlU9c8r1qqq3VdW6qtpaVRdU1fEzHUfjAQAAHdm9xqPfxwytTPKtJK/ex/XfTvJbSV6Z5BFJbk1yflUtn8kgploBAMAC1lo7L8l5SVJVt7lWvROvTfKO1to/jp17cZJrkzwzySenO47EAwAA5qfVVXXQpGPZLN7j2CRHJrlg94nW2s1JLk7yqJm8kcYDAAC60gZ09FyV5OZJx2mz+BscOfb12innr510bVpMtQIAgPnpmCSbJz3ePqhCEo0HAAB0ZsAbCG5urW26k2+3fuzr2iTrJp1fm+SbM3kjU60AAIB9uTK95uPk3Seq6qD07m510UzeSOIBAAALWFWtSnLcpFPHVtWDk2xsrf1XVb03yZur6vvpNSJvT3JNkn+YyTgaDwAA6Mrc2Ln8Z5J8adLj94x9PTvJS5Ocmd5eHx9McnCSryZ5Smtt20wG0XgAAMAC1lr7cpK6nestyVvGjlnTeAAAQEcGvLh8qFhcDgAAdE7iAQAAXbnthn79G3MISTwAAIDOaTwAAIDOmWoFAAAdsbh8gsQDAADonMQDAAC6Mtp6R7/HHEISDwAAoHMaDwAAoHOmWgEAQFfs4zFO4gEAAHRO4gEAAB2pDOB2uv0dbtokHgAAQOckHgAA0JXWeke/xxxCEg8AAKBzGg8AAKBzploBAEBHqg1gcflwzrSSeAAAAN2TeAAAQFdsIDhO4gEAAHRO4wEAAHTOVCsAAOhItZbq874a/R5vuiQeAABA5yQeAADQldGxo99jDiGJBwAA0DmJBwAAdMQajwkSDwAAoHMaDwAAoHOmWgEAQFfsXD5O4gEAAHRO4gEAAF1prXf0e8whJPEAAAA6p/EAAAA6Z6oVAAB0pFrv6PeYw0jiAQAAdE7iAQAAXbG4fJzGg04tWTqaF79xfU5+zo1ZtWYkV35vRc4+88h848LVgy4NhpLPDOzdAd/fmuVf2JQl39mSxdftzOjqxdl5wopsedHhGbnr0ts+ebRl+edvyorzb87iq3ekLavsuufy3PLyu2Tk2OWD+QsAplrRrTe89yd59iuuzxf//pD82VvumtHR5O1/dUXu//BbBl0aDCWfGdi7A8/ZmKUXbc6OBx2YW371iGx78sFZetmWHPK6H2Xxj7ff5rmr/2R9Vn3ouuy89/Lc8oojsuX5h2f0Lgdk0U0jA6qehaxGB3MMI4kHnTnhwVvyhGfelA+97ah86s+PSJJc8KlD8sEvXp6Xv3ldXveLxw+4QhguPjOwb1uecWh2vWF5sqTGz21/7Ooc8ps/yoGf2pDNbzg6SbLsq5uy/IubcvNpR2fHoySFMEyGKvGoqtOq6utVtbmqrquqf6iqEwZdF7PzmKfdlJFdybkfP2z83M7ti/L5vzk09/uZLbnL0TsGWB0MH58Z2LddP7XiNk1HkowcvTS77r40i6+a+Gys+Icbs/M+y3tNx2hLtg3pr35hARqqxiPJ45OcleSRSZ6UZEmSf66qlQOtilk57gFbc9UVy7LllsW3OX/5Nw9Mktzr/lsHURYMLZ8ZmKHWsuimkbSDep+Z2jKSA76/LbuOW56VH7s+h/337+cuv/T9HPqrV2TZVzcNuFgWrN2Ly/t9DKGhmmrVWnvK5MdV9dIk1yU5McmFg6iJ2Tv0iF3ZeO2SPc7vPnfY2l39LgmGms8MzMyyL2/K4g27suWUw5Mki9ftTLVk2Vc2J4uTW19yl7SVi7Piszdm9f9al9EVi7PzRL/LhEEZqsZjL9aMfd24t4tVtSzJskmnTOYcIkuXj2bnjtrj/I7tvXPLlou/YTKfGZi+xVdtz6oPXJed912ebT97UJKkxqZVLdo8khv/192z64QVSZLtD1+Vw371iqz82w25SeNBv7Wxo99jDqFhm2o1rqoWJXlvkn9prV26j6edluTmScdV/amO6dixbVGWLN3zf/lLl/XObd82tP/zg4HwmYHpqRt3Zc3brk47cFE2vemuyeJec96W9j4jI2uXjDcdSZIVi7L9YStzwPe3JiND+hMZLADD/K/YWUkekOQFt/Ocd6aXiuw+julDXUzTxusOyKFrd+5xfve5DdcOe+AG/eUzA3esbh3JmtOvSt06kptPPyajh018LkYP7f159ODFe7yuHXxAatdEKgL031A2HlX1/iRPS/KE1to+U4zW2vbW2qbdR5LNfSuSO/TDy1bkmHttz4Grbnvf9Ps+ZEuS5IrLVuztZbBg+czAHdgxmoPefnUOuGZHbv69YzJy92W3uTx62AEZOWRxFm3Ycz3Uoo270pZW2oqh/NGHeaxaG8gxjIbq01c970/yrCQ/21q7ctA1MXtf+ac1WXxA8vMv2jB+bsnS0fzc8zfme5ccmOuvWXo7r4aFx2cGbsdIy0FnrsuSy7dm05uOzq777r0R3/6Yg7L4hl1Z8u+3jp+rTbuy9OJbsuOBByaL9lxHBfTHsOX2ZyU5JckzkmyuqiPHzt/cWnMfyTnm8n9fmQs/syannrYuaw7flWuuXJYn/dLGrL3bjrznDXcbdHkwdHxmYN9W/uX1Wfa1W7L94StTm0ey7Es33+b69if07kez5bmHZtm/bMpB77omW59xSNrKRVn++ZtSu1pu/eXDB1E6C90gbm87pInHsDUerxr7+uUp509N8tG+VsJ+ceZr7p6XXL0+Jz/nxqxeM5Irv7c8b3nxsbn04lWDLg2Gks8M7N0BV25Lkiz72q1Z9rVb97h+/Vjj0Q45IDe96+5Z9ZfXZ8Vnbkztatl53xXZ/PqjMnLs8r7WDNxWtSHtiGajqg5KcvNJeUYOqD3vhQ8A+8P1nzlh0CXAnDGyZXsuff67k2TN2JrcBWH3z6VPeOhpOWBxf5veXSPb8qVvvDMZsu/5UK3xAAAA5ieNBwAA0LlhW+MBAADzxiBub+t2ugAAwIIl8QAAgK60DOB2uv0dbrokHgAAQOc0HgAAQOdMtQIAgK7YuXycxAMAAOicxAMAALoymqQGMOYQkngAAACd03gAAACdM9UKAAA6YufyCRIPAACgcxIPAADoitvpjpN4AADAAlZVp1dVm3L8x/4eR+IBAABdmTuJx2VJnjjp8a79U8wEjQcAALCrtba+ywFMtQIAgPlpdVUdNOlYdjvPPb6qrqmqK6rqr6vq7vu7GI0HAAB0ZfdUq34fPVcluXnScdo+qrw4yUuTPCXJq5Icm+QrVbV6f34rTLUCAID56Zgkmyc93r63J7XWzpv08NtVdXGSHyf5pSQf3l/FaDwAAKAro0lqAGP2bG6tbZrpy1trN1XVfyY5bn+WZaoVAAAwrqpWJbl3knX78301HgAAsIBV1bur6vFVdc+qenSSv08ykuRv9uc4ploBAEBHqrVUn/fxmMV4x6TXZByW5PokX03yyNba9fuzLo0HAAAsYK21F/RjHI0HAAB0Ze7sXN45azwAAIDOSTwAAKAroy2pPicQoxIPAABggdJ4AAAAnTPVCgAAumJx+TiJBwAA0DmJBwAAdGYAiUckHgAAwAKl8QAAADpnqhUAAHTF4vJxEg8AAKBzEg8AAOjKaEvfF3vbuRwAAFioJB4AANCVNto7+j3mEJJ4AAAAndN4AAAAnTPVCgAAuuJ2uuMkHgAAQOckHgAA0BW30x0n8QAAADqn8QAAADpnqhUAAHTF4vJxEg8AAKBzEg8AAOhKywASj/4ON10SDwAAoHMSDwAA6Io1HuMkHgAAQOc0HgAAQOdMtQIAgK6MjiYZHcCYw0fiAQAAdE7iAQAAXbG4fJzEAwAA6JzGAwAA6JypVgAA0BVTrcZJPAAAgM5JPAAAoCujLUmfE4hRiQcAALBASTwAAKAjrY2mtf5u6Nfv8aZL4gEAAHRO4wEAAHTOVCsAAOhKa/1f7O12ugAAwEIl8QAAgK60AdxOV+IBAAAsVBoPAACgc6ZaAQBAV0ZHk+rzvhr28QAAABYqiQcAAHTF4vJxEg8AAKBzEg8AAOhIGx1N6/Maj2aNBwAAsFBpPAAAgM6ZagUAAF2xuHycxAMAAOicxAMAALoy2pKSeCQSDwAAoA80HgAAQOdMtQIAgK60lqTP+2qYagUAACxUEg8AAOhIG21pfV5c3iQeAADAQqXxAAAAOmeqFQAAdKWNpv+Ly/s83jRJPAAAgM5JPAAAoCMWl0+QeAAAAKmqV1fVj6pqW1VdXFUP35/vr/EAAICutNHBHDNUVc9P8p4kZyR5aJJvJTm/qo7YX98KjQcAAPD6JB9qrX2ktfbdJK9MsiXJy/bXAPNyjceu7EyGc2obAPPAyJbtgy4B5oyF/nkZxM+lu7Jz9x9XV9XkS9tba3v8B6mqpUlOTPLO3edaa6NVdUGSR+2vuuZb47E6Sb6acwddBwDz2fMHXQDMSauTbBp0EX20I8n6r+bcIwc0/i1Jrppy7owkp+/luYcnWZzk2innr01y3/1V0HxrPK5JckySzYMuhD2sTu9//P77wPT4zMDM+MwMt9Xp/Zy2YLTWtlXVsUmWDrqWSQYaP82rxqP17h129aDrYE+TYr7NrbWF9NsOmBWfGZgZn5mhtyD/m7TWtiXZNug6puGGJCNJ1k45vzbJ+v01iMXlAACwgLXWdiS5JMnJu89V1aKxxxftr3HmVeIBAADMynuSnF1V/5bka0lem2Rlko/srwE0HvTL9vQWNC3sW1vA9PnMwMz4zMCd0Fr7P1V1lyRvS3Jkkm8meUprbeqC81mrYd1SHQAAmD+s8QAAADqn8QAAADqn8QAAADqn8QAAADqn8aBTVbWsqv6wqq6pqq1VdXFVPWnQdcGwqqpVVXVGVX2+qjZWVauqlw66LhhGVfWwqnp/VV1WVbdW1X9V1d9W1X0GXRuwJ40HXftoktcn+eskr0lvV8xzq+oxgywKhtjhSd6S5KeSfGvAtcCwe1OS5yT5Qnr/xnwwyeOSfKOqHjDIwoA9uZ0unamqhye5OMkbW2vvHju3PMmlSa5rrT16kPXBMKqqZUkOaa2tr6qfSfL1JKe21j462Mpg+FTVo5P829iuy7vPHZ/kO0k+1Vp70cCKA/Yg8aBLz00v4fjg7hOttW1JPpzkUVV1t0EVBsOqtba9tbZ+0HXAXNBa+/8mNx1j576f5LL0UkNgiGg86NJDkvxna23TlPNfG/v64P6WA8B8V1WVZG2SGwZdC3BbGg+6dFSSdXs5v/vc0X2sBYCF4YVJ7prk/wy6EOC2NB50aUWS7Xs5v23SdQDYL6rqvknOSnJRkrMHXA4whcaDLm1Nsmwv55dPug4Ad1pVHZnkc0luTvLc1trIgEsCpjhg0AUwr61LL+6e6qixr9f0sRYA5qmqWpPkvCQHJ3lsa82/LzCEJB506ZtJ7lNVB005/4hJ1wFg1sZu0/7ZJPdJ8rTW2ncHXBKwDxoPuvSpJIuTvGL3ibE9Ck5NcnFr7SeDKgyAua+qFqe3iPxRSZ7XWrtowCUBt8NUKzrTWru4qv4uyTur6ogkP0jykiT3TPIrg6wNhllV/UZ6U0Z23/nt6VV1zNif39dau3kghcHw+d9JfjG9xOPQqrrNhoGttY8PpCpgr+xcTqfGIvC3J3lRkkOSfDvJ77XWzh9oYTDEqupHSe6xj8vHttZ+1L9qYHhV1ZeTPH5f11tr1b9qgDui8QAAADpnjQcAANA5jQcAANA5jQcAANA5jQcAANA5jQcAANA5jQcAANA5jQcAANA5jQcAANA5jQcAANA5jQfANFXVj6rqo5Men1RVrapOGlhRU0yt8Xae16rq9Fm8/0vHXvszs6lvH+95elW1/fV+AAwnjQcwJ0z6gXf3sa2q/rOq3l9Vawdd30xU1c/P5od+AJjLDhh0AQAz9JYkVyZZnuQxSV6V5Oer6gGttS19ruXCJCuS7Jjh634+yauTnL6/CwKAYaXxAOaa81pr/zb257+oqg1JXp/kGUn+Zm8vqKqVrbVb93chrbXRJNv29/sCwHxkqhUw131x7OuxSVJVH62qW6rq3lV1blVtTvLXY9cWVdVrq+qysala11bVB6rqkMlvWD1vrqqrqmpLVX2pqu4/deB9rfGoqkeMjX1jVd1aVd+uqtfsri+9tGP3Oos2eX3D/q5xuqrqHlX1p1V1eVVtraoNVfV3VXXPfbzkwLG6NlTVpqr62NQax973qVX1lbHvw+aq+tydqROAuUviAcx19x77umHSuQOSnJ/kq0n+R5LdU7A+kOSlST6S5E/Sa1Z+I8lDquq/tdZ2jj3vbUnenOTcseOhSf45ydI7KqaqnpTkn5KsS/LHSdYn+akkTxt7/IEkRyd5UpJf3stbdF7jPjwsyaOTfDLJVUnumd40ti9X1f32Mo3t/UluSm+62Aljz71HVZ3UWmtj34tfTnJ2ev8t3pTkwLHnfbWqHtJa+9EsawVgDtJ4AHPNmqo6PL01Hv8tvTUfW9P7YX+3ZUn+rrV22u4TVfWYJC9P8sLW2icmnf9Sks8neV6ST1TVXZL8dpLPJXn6pB+ifz/J795eYVW1OL3GYV2SB7fWbpp0rZKktXZRVf1nkie11j4+5fWd13g7Ptda+9SUej6b5KIkz0nyV1OevyPJybsboar6cZIzkzw9yWeqalV6jdNftNZeMek9z05y+VidrwgAC4apVsBcc0GS65P8JL3fzt+S5FmttaunPO/Ppjx+XpKbk/zfqjp895HkkrH3eMLY856YXmrwvt0/0I957zRqe0h6CcV7JzcdSTLlvfalHzXuVWtt6+4/V9WSqjosyQ/SSzUeupeXfHBS+pL0vt+70ls4n/QSnYOT/M2Uv8tIkosn/V0AWCAkHsBc8+ok/5neD7nXJrl8bJH3ZLvSmy402fFJ1iS5bh/ve8TY13uMff3+5Iutteur6sY7qG33tK9L7+B5+9KPGveqqlYkOS3JqUnumqQmXV6zl5dMHfuWqlqX3hStpPd3SSbW4Ey1aTZ1AjB3aTyAueZrk+5qtS/b99KMLErvB/oX7uM119/pyu68Qdb4vvSajvemN73q5iQtvVRpNun47tf8cnrrXKbaNYv3BGAO03gAC8UP05ui9C+TpxXtxY/Hvh6f5IrdJ8fWVexx16a9jJEkD0hvSti+7GvaVT9q3JfnJjm7tfaGSe+3PL3pUntzfJIvTXruqiRHpbfQPZn4XlzXWru97wUAC4Q1HsBC8bdJFif5vakXquqAqjp47OEFSXYm+c3dC8LHvHYaY3wjvc0NXzvp/XaPMfm9bh07d5vn9KnGfRnJbadXJclvjtWzN6+oqiWTHr8qvV9mnTf2+Pz0plP97pTnJRlvkgBYQCQewILQWvt/VfWBJKdV1YPTu/XszvR+c/+8JK9J8qmxdRLvTm+9wz9V1bnpLRp/apIb7mCM0ap6VZLPJvlmVX0kvTtc3TfJ/ZM8eeypl4x9/ZOqOj/JSGvtk/2o8Xb8U5Jfrqqbk3w3yaPSS1827OP5S5N8oar+Nr3b6f56ercv/szY92LT2Pfir5J8o6o+md5Usbsn+YUk/5LebYIBWCA0HsCC0Vp7ZVVdkuTXkvxBeusMfpTk4+n9ILzbm9PbkfyV6d196eIkP5fe7WvvaIzzq+oJSd6a5A3pJcs/TPKhSU/7dHprKl6Q5EXpJQ2f7FeN+/Ca9FKPF6Z3q+J/Sa/xOH8fz/+Nsee+LcmS9HaN/63Jd9lqrX2iqq5J8jtJ3pjebY6vTvKV9PYpAWABqend4REAAGD2rPEAAAA6p/EAAAA6p/EAAAA6p/EAAAA6p/EAAAA6p/EAAAA6p/EAAAA6p/EAAAA6p/EAAAA6p/EAAAA6p/EAAAA6p/EAAAA69/8Dxr2263CcjyIAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -419,17 +419,17 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 13, "id": "ca48f9d5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "0.9906846833902615" + "0.9633110554163186" ] }, - "execution_count": 42, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -461,7 +461,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 14, "id": "218d0983", "metadata": { "editable": true, @@ -501,7 +501,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 15, "id": "9169c2dc", "metadata": {}, "outputs": [], @@ -520,7 +520,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 16, "id": "233a57da", "metadata": { "editable": true, @@ -535,7 +535,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABR4AAALGCAYAAAAjlY2LAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABTTklEQVR4nO3dd7hdVZk/8O+bBEJJjHQEaSoiiiJEURxBsRdwVBwLOohlxoLOMGLDMqD+xt7HXnF0BFEYpVhxwMpYUBTFAii9l4QeStbvj3MuHi73JjcnO7k5yefzPOc5nLXX3vs9J2ffXL5Ze61qrQUAAAAAoEszprsAAAAAAGD1I3gEAAAAADoneAQAAAAAOid4BAAAAAA6J3gEAAAAADoneAQAAAAAOid4BAAAAAA6J3gEAAAAADoneAQAAAAAOid4BABWG1V1l6r6cFWdU1W3VlWrqgdW1SP7/33YdNfIqq3/PTl5XNth/fZHTlNNB/TPf8C49nOq6pzpqGmghmn9bACAVZvgEQCYVv3QonV0uHcneWWS05O8I8lbklzS0bFhKFV1eP97vu1017KsJgs9AQCmYtZ0FwAA0KG9k/y5tbbPYGNV3Wea6mH18JEkRyY5b5rO/z9J/i/JxdN0/iWZ7s8GAFiFCR4BgNXJFkl+ON1FsHpprV2R5IppPP/CJAun6/xLMt2fDQCwanOrNQCwyqmqbfu3dx7e/+8jq+qKqrqpqn5ZVXuP639y/3btSvKIsdu3x8/VN8F5Jp0jb0lz11XVffq1nV9VN1fVpVX15araYZJjrVdVr+vXfm1VXVdVf+jPR7nZBH0PqarTqur6ft9Tquo5S3ovE5zzAVV1RP89Lqqqy6vqV1X1wapaa1zfmVX10qr6SVUtrKobq+qsqvpMVW0/ru+8qnpHVf2p/+dxdVV9p6oeM0ENt8+tWVW7VdUJVXXV+NuOq+o5VXVSVS3oH/MPVfWmqpo9wTH3qKrjquqC/vu6pKr+r6oOXYbPZu2qenNVnd0/xl+r6v9NdL5+/wm/C1Oppf+9fH7/5V8HvpvnDPQ5ud+2dlX9e/+zXVRVh/e3L/F25/6fyUeq6sL+53dGVf1LVdW4fkuc63T89dC/fj7ff/n5gdpv//NbynXy6Kr6dv/PfFFV/bmq3llV8yboO/YZzKqqN1TVmf19zq+qd1XV2hPVDACs2ox4BABWZdsk+XmSvyT5YpINkzwryTeq6jGttZP6/Q5PcnKSQ5Oc23+dJOd0XVBVPSHJMUnWSnJckrOS3D3J05M8uar2aq39aqD/BklOSrJzkj8l+VySm5PcM8kL+se6tN/3rkn+N8kuSX7V7zsjyeOTfLmq7tdae9MUanxAkp8laUmOTfLXJHdJcq8kL0/ypiS39PuuneT4JI9Ncn6SLye5Jsm2SZ6W5MdJzhyo7ydJ7pvkF0k+mGTjJM9M8t2qellr7ZMTlLR7kkP6x/pcf5+b+8f8XP9zuCDJ0UkWJHlokrcleXRVPba1duvAZ39Cv75jk1yY3ndix/77essUPptKclSSv09ydnq3Cq+d5IVJ7r+0/QeOM9Va3pLkqen9+X+o//4y8Dzo6CQPTvKtJF9PctkUSlk7yYlJ7preLc9rJ9m3f64dkhw41fc0gcP7df59km8kOW1g24Il7VhVL0ny8STXJ/lqeu/lkUlel2Sfqvq71tpEx/hykj3S+wyuSfKkJK9Nsml63xMAYIQIHgGAVdkjkxzWWrs9UKqqLyf5dpLXpBfopbV2eH/boUnOaa0dtiKK6YeIRyS5IcmerbUzBrbtlN48fJ9JsuvAbh9NL3T6RJIDW2uLB/aZk2TmQN8Pphc6vq619u6BfuukF0S9oaq+1lo7bSmlPj/JOkme2lr7xgTv4YaBpsPSCx2PS/IPrbVFA31npxdYjnlXeqHjp5K8tLXW+v3eleSXST5cVd9prZ0zrp7H9fvfIZTsj+B7QXpzGD63tXbjwLbD0guSD0wvREuSf0oviH1ka+0344618aSfxh09J70g7f+S7NVau6m//6HphalTNaVaWmuH9UcH7pzkgxN8NoO2SbJT//blqbpbesH8TmN/dgPv5eVV9ZXW2lDTD7TWDu8Pmvz7JF8fu86Wpqq2SfLhJNcl2a219seBbR9L8rL0FoL65wl2v2eS+7XWrur3f2OS3yTZv6oOaa1ZLAoARohbrQGAVdm5Sf7fYENr7TvpLWSx2zTUs396I8sOHQwd+3X9Lsmnk+xSVfdNkqraNL0RmhcnefVg6Njf57r+/H2pqo2SPC/JLwdDx36/m9IbKVZJ9luGem8c39Bau3qsjqqamd7ovBvTCwYXjeu7qLV2eb/v2v36rktyyFjo2O93ZnpB09rpfUbjnTbJSMh/TXJrkhcOho59b0tyZZLnTvF9TTWsGxs194ax0LG//1X9cy6r5allvDcPue8hg392497LdIwSfF5634WPDIaOfW9Mcm2Sf5zk1vbXjYWOSdJauz7Jf6f3/y0PWkH1AgAriBGPAMCq7LTW2m0TtJ+f3u27K9vYOXeeZJ68e/efd0xyRnq3zc5I8sN+gLIkD05v9ONkc/CNzcu44xTq/Ep6od7Xq+pr6d2K+5PW2tnj+t0nybwkP2utXbSUY+6QZL3+ca6aYPv/pncL9y4TbPv5+IaqWi+9UYBXJDlo3HSEYxblju/3v9O7pf1nVfWV9Ea8/qS1dsFSah+0a5LF6d32Pd7Jy3CcLmoZ706f0xTcmuSnE7Sf3H+e6M9jRRsb8fu/4ze01q6uql8n2TO9799vxnX55QTHO7//vEFnFQIAK4XgEQBYlS2YpP3WTM+dGxv1n/9pKf3m9J/v2n++cBmO/eD+Y2nHnlRr7edVtUd6o8uekeQfk6Sq/pTkLa21I4aob2xBkIsn2T7WftcJtk10e+wG6Y3g3CS9W6qXqrV2TPUWFjo4vTkZX5IkVXVqeqP+vjeFw8xLclVr7ZYp1rkiaxn6/AOumCScHzvWnRZyWQmG/q5MMu/jrf3nmRNsAwBWYW61BgDWZIsz+T/E3nWCtoX9551ba7WExxf6/Rb0n7ecQi1jx/7AUo6911TeWGvtlNba3ukFfH+X3q23m6W3SM3YCtTD1Lf5JNvvNq7fHcpZwvF+vZT3e4ehkK21E1prj0rvfT06yQeS3C/J8WO3uE/hfWxY41b27pvsvU2og1rGH2+iz2lpNu7fMj/e2HsZ/PMYu9V/Wb7zw1ie7woAsBoRPAIAa7Krk2w2SQg10Xxy/9d/3mOKx/95emHPnlW1/hT7TvXYU9Kfp/GnrbV/T/Iv/ea/7z//Mb3w8QFVtcVSDvWn9Bal2bm/uvV4Y4HorybYNlFd1yX5fZL7VdWGU9ln3P7Xt9b+t7X2qiRvT29OwSdOYddfpfc78MMn2PbIZa1jirWMjUhcESP2ZiV52ATtj+w//3qg7er+81bjO1fVvTLx6Mhhah875yPHb+h/dx6Y5KYkf1iGYwIAI0jwCACsyX6eXnBzhwU4+qst/90E/T+fXlB3aFXdaXGbqppRVY8ce91fmOXI9EZ4vbeqZozrP6eq5vX7XpbevIEPqqo3TzSKraruWVXbLe1NVdXDqmrdCTZt1n++oX/O25J8LMm6ST4xfrGPqlq7qjbp9725X9/cjFuEparumV6oeUuSLy6tvgHvTy+k+9xEYWZVbVBVuw683rOqJhqtd4f3tRSf7z//R3+18LFjb5jeHJVTsoy1XNl/3nqqx19G7xj8sxv3Xj4/0O+PSa5J8vf9hY/G+q+b3uJAExmm9i+l9114ZT/QHPS29FZK/9L4xYwAgNWPOR4BgDXZf6YXOn68qh6d3iIWD0xvEZnjk+w92Lm1dmVVPSPJ/yT5v6r6fnqj9lp6o8h2T2+uxnUGdntFkp2SvDTJI6vqO0luTrJdkscneUr+thDIK5Jsn+St6a36++MklybZIr1FVh6c5DlJ/rqU9/XaJI+qqh/1+16X3i3AT0xv1NunBvq+JclDkuyT5M9VdXx6qw5vleRxSV6T5PB+39enNyLzFVX14PQWVNk4yTPTCyRf0VpbWm23a619rqrmp7ey9tn9z+a8JBv2P5890wvOXtrf5cNJtqyqnyQ5J73PcX6SR6W3AvqRUzjtEemtNP6UJL+rqm+kt3DPM5L8Isk9p1j+stTy/fQ+x09X1dHpfb4LWmsfmeK5luTiJLPTey/H5m/v5W5JPtZa++FYx9baLVX1oSRvTvLrqvqf9P5/4LFJLuo/xjslvRD1oP7K62NzR/7n2Irs47XWzqmqg5J8NMmvquqoJJcneUR618gf01ulHQBYzQkeAYA1VmvtjP58h29PL3i7NcmP0gtHnp5xwWN/n+9X1QOSvDq94HCP9EKni9Jbxffocf2vrqqHJTkovcDrn9O7ffX8JJ9Lb/Xrsb7XVNUj+n32S7JveiHmpUnOTPJvSaayaMnH0gsYH5LeLcWzklzQb39fa+3cgXPeXFVPSC/c2z/J89Nb9OWi9ALWHw/0vaqqdk9ySP/zeVWSG9MbOfqe1tp3p1DbHbTWDqyqb/XP/5j05hm8Kr0A8j3pjZ4b8/YkT0vvNvjHpHdr+nn99g+21q7OUrTWWlX9Q3oh6gHphb0XpxdwvjW9W4CnYsq1tNa+U1UHp7co0UHpjfI8N0kXwePN/fO/Pcmz0wuC/5LknekF6+Mdml6Q+E/pfc8uSS8kPSwD38WB2q+uqn37+x2QZGzKgC9lCXM0ttY+VlVnpXed7Jveiujnp/dn+vZJFpEBAFYzNdwc1gAAAAAAkzPHIwAAAADQOcEjAAAAANA5wSMAAAAA0DnBIwAAAADQOcEjAAAAANA5wSMAAAAA0LlZ013AylZVlWSLJNdOdy0AAAAAMKLmJrmotdYm67DGBY/phY4XTHcRAAAAADDi7p7kwsk2ronB49hIx7vHqEcAAAAAWFZz0xvYt8RsbU0MHsdc21q7ZrqLAAAAAIBR0pvJcOksLgMAAAAAdE7wCAAAAAB0TvAIAAAAAHRO8AgAAAAAdG5NXlwGAAAAYI1y6qmnzk1ytxiMxp0tTnJlkqvnz5+/uIsDVmuti+OMjKq6S5KFSeZZ1RoAAABYE5x66qkzkrxh5syZ+1fVWkmmtiwxa5TW2q2ttUsWL1783iTHThZATjVfM+IRAAAAYPX3hrXWWutlm2+++c3rr7/+DVW1Zo1EY6laa7n11ltnLVy4cLsFCxb85y233HK/JP+xPMc04hEAAABgNXbqqafeZebMmb/cYost1tp0002vnO56WPVdeumlG1188cXX33bbbQ+bP3/+nfKzqeZr7ucHAAAAWL1tXlVrrb/++jdMdyGMhjlz5lxfVXOSbL48xxE8AgAAAKzeZiQpt1czVVW3TwG6XNmh4BEAAAAA6JzgEQAAAADonOARAAAAAFYRu+222w677bbbDtNdRxcEjwAAAABA52ZNdwEAAAAATI9tX3/C/OmuIUnOeeeTT53uGuieEY8AAAAAMIHFixfnuuuuq6X3ZCKCRwAAAABG0qte9aotqmr+7373u9n77rvvtnPnzn3g3LlzH/iMZzxj22uvvfb23OuWW27Ja17zmrtttdVWO6299tq7brnllvd/xSteseWNN954h1Bxyy23vP9ee+11r6OPPvouO+20047rrrvuru9///s3Of744+dW1fzPfOYzGxx88MF323TTTR+w/vrr7/KEJzzhHldeeeXMG2+8sV74whduteGGG+683nrr7fKMZzxj2/HH/tCHPrTRQx/60HtvuOGGO6+99tq73vOe97zfu971rk1W1mc1HdxqDQAAAMBIe+Yzn3mPrbba6uY3velNF/76179e7ytf+crGm2yyyS0f//jHL0ySZz/72dsec8wxGz3hCU+4+sADD7z05z//+fof/ehHN//Tn/60zve+972zB4/1l7/8ZZ0XvvCF93je8553+fOf//zLd9xxx0Vj2973vvfdbZ111ln8r//6r5ecddZZs7/whS9sesABB7SqysKFC2e+9rWvvehnP/vZ+kcfffRG22677aL3vve9F4/t+5nPfGbTHXbY4cYnPelJC2bNmtW++c1v3vX1r3/91osXL84hhxxy+cr7tFYewSMAAAAAI22nnXa64aijjjp37PVVV10168gjj9z44x//+IWnnHLKusccc8xGz3rWs6448sgjx/pc/pKXvOTWT33qU5sdd9xxc/fZZ59rx/Y977zzZn/ta187c999971mrO3444+fmyS33XZb/u///u9Ps2fPbklyxRVXzDrhhBM23GOPPRb+4Ac/OGvs2Lvssss6RxxxxMaDweMpp5zyxzlz5rSx1294wxsu32OPPbb/2Mc+ttnqGjy61RoAAACAkXbggQfeIbj7u7/7u2sXLFgw66qrrppx7LHHzkuS1772tZcO9nnjG994SZIcd9xx8wbbt9xyy5sHQ8dBz3rWs64cCx2TZLfddru+tZYDDjjgysF+u+666/WXXHLJ2rfccsvtbYOh45VXXjnz4osvnvXwhz/82gsuuGD2lVdeOXOZ3/QIMOIRAAAAgJF2j3vc4+bB1xtssMFtSW9E4rnnnrv2jBkzcr/73W/RYJ+tt9761rlz5952/vnnrz3YvtVWW92h37h97nCeefPm3ZYk22yzzZ3aFy9enCuvvHLm5ptvfluSfPe7313/sMMO2/LXv/71+jfddNMdBgNeddVVMzfaaKPbpv6OR4PgEQAAAICRNmvWxBFXa7cPMsyMGTPahJ3GWWeddRYv63lmzZo14bFba5Ukv//972fvs88+O2y33XY3vfWtbz1/6623vmX27NmLjz/++Hmf/exnN1u8eNJTjjTBIwAAAACrrW222ebmxYsX5/TTT19n1113vWms/fzzz5917bXXztxqq61uXtL+XTj66KPn3XzzzXXcccedtf32299+vu9///t3WdHnnk7meAQAAABgtfWUpzxlYZK8973v3Wyw/e1vf/tmSbLPPvssXNE1zJzZm8JxcATmlVdeOfMrX/nKRiv63NPJiEcAAAAAVlu77777jU9/+tOvPOKIIzZeuHDhzD322OPaX/ziF+sfc8wxGz3mMY9ZMLii9Yqy9957L3zLW95y97333vteL3jBCy6/7rrrZn7xi1/ceMMNN7z18ssvX2tFn3+6GPEIAAAAwGrtyCOPPOfggw++6De/+c36b37zm7f66U9/OvfAAw+85Nhjj/3Lyjj/zjvvvOjwww8/u6rylre8ZavDDz98k/333//yl73sZZcufe/RVYNDPNcEVXWXJAuTzGutTbg0OgDAqNr29SesWb/cJTnnnU+u6a4BAFZlp5566n1mzZr17e233/669dZb76al78Ga7oYbbljnzDPPnHPrrbc+Yf78+X8cv32q+ZoRjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAACwhqiq+a961au2WBnnmrUyTgIAAADAKuiwefOnu4QkyWELT53uElYln/jEJza87LLLZv37v//7ZdNdy/Iw4hEAAAAAViFf+cpXNvzkJz+52XTXsbwEjwAAAAAwgRtuuKFuu+22Cbddc801crWl8AEBAAAAMNL++te/rvXMZz5zm0033fQBa6+99q5bbrnl/Z/73OdufdNNN1WSnHHGGWs/8YlPvMe8efMeuO666+6y88473+fII4+cN3iM448/fm5Vzf/Upz61wb/8y79ssemmmz5gzpw5u1599dUz9913323XW2+9XX7/+9/PfsQjHnGv9ddff5enP/3p2yXJlltuef9999132/E17bbbbjvstttuO4w//qc//ekNXvGKV2y58cYb77zuuuvu8qhHPepeZ5111lqD+5188snzLrroorWran5Vzd9yyy3vP7b9xhtvrH/7t3/bYuutt95p7bXX3nXzzTd/wEtf+tK733jjjTV4/htvvLFe9KIXbbXBBhvsvP766+/yqEc96l5nn332WlmJzPEIAAAAwMg655xz1nrIQx6y47XXXjtzv/32u+I+97nPjRdeeOHaxx133AbXXXfdjMsvv7z23HPPHW+66aYZL3zhCy/daKONbj3iiCM2fu5zn3uvm2+++ez9999/weDx3v3ud2+x1lprtQMPPPCSRYsWzZg9e3ZLkttuu62e+MQnbv/gBz/4usMOO+z89dZbb/Ew9b7nPe+5W1Xlla985cWXXXbZWp/97Gc3e8xjHrPD7373u9/PmTOnHXLIIRe/4Q1vuPsll1yy1n/8x3+cnyRz585d3K8hj33sY+916qmnztlvv/2u2HHHHW88/fTT1/3MZz6z6VlnnTX7xBNPPHvsPM95znO2/cY3vrHhPvvsc9Xuu+9+3cknn3yXJz3pSdsP/UEPQfAIAAAAwMh61ateteWVV1651kknnfSHPffc84ax9g9+8IMXLV68OP/0T/+01ZVXXjnr29/+9p8e//jHX5ckBx100BX3u9/97nfIIYds9dznPnfBzJkzbz/eokWL6rTTTjtjzpw5bfA8N998c+2zzz5Xf/SjH71weepduHDhrD/+8Y+/22CDDRYnyfz582940YtedI8PfvCDm7zpTW+67GlPe9o1H/7wh2++5pprZr785S+/anDfT37ykxuecsopd/nmN795+3tJkp122unG1772tdt873vfW/+xj33s9aeccsq63/jGNzZ83vOed/kXv/jF85LkkEMOufwpT3nKdn/+85/XXZ76l4VbrQEAAAAYSbfddlu+973v3XWvvfZaMBg6jpkxY0a+//3vz7v//e9//WBQN2/evMX777//5RdddNHav/rVr9YZ3OdZz3rWleNDxzEHHXTQ5ctb8z/8wz9cORY6JskBBxxw9SabbHLLd77znXlL2i9Jjj766A3ucY973PSABzzgposvvnjW2OMJT3jCtUly4oknzk2SY489dl6SvPrVr750cP+DDz740jsfdcUx4hEAAACAkXTRRRfNuu6662be9773vXGyPhdffPHau+yyy3Xj2+973/velCRnn3327Ac/+ME3jbVvt912iyY6zsyZM9s97nGPm5e35u233/6mwdczZszI1ltvveiCCy5Ye2n7nnPOOev85S9/WWeLLbbYeaLtl1122VpJcu655649Y8aM3Pe+973De7n//e9/00T7rSiCRwAAAADoW2+99SYc7bj22mu3wVuyl+a2227LsvSfisWLF2f77be/8d3vfvf5E23fbrvtljsY7ZLgEQAAAICRtMUWW9w6Z86c284444xJ5y28293udvPZZ5+9zvj2P/zhD+skyT3vec8JRzhO1bx5825duHDhnRLGiy66aO2tttrqTkHgmWeeeYdaFi9enPPOO2/2DjvscPuozaoav1uSZJtttln0hz/8Yb2nPOUp186YMfkMittss83NixcvzhlnnDF75513vv39nX766Xf6HFYkczwCAAAAMJJmzpyZxz72sQtOOumku/7whz9cb/z2xYsX59GPfvTC008/ff0TTzxx/bH2a665ZsZ//dd/bbzFFlvcvOuuuy7X7cfbbLPNotNOO23OTTfddHtaeMQRR8y75JJLJrx1+qtf/epGV1999e2Z3OGHH77B5ZdfvtbjHve4hWNt66233uJrr732TmHmvvvue/Vll1221vvf//6Nx2+77rrr6pprrpmRJPvss8/CJHnve9+72WCf973vfZuN329FMuIRAAAAgJH1vve978If/ehHd3n84x+/w3777XfFjjvueOPFF1+81rHHHrvhKaec8sfDDjvs4m984xsbPu1pT9v+RS960WUbbrjhrUccccTGF1544ezDDz/87OW9HfrFL37xFd/+9rc3eOQjH7n905/+9KvPPvvs2cccc8yGW2211YQjKefNm3frQx/60Ps897nPveLSSy9d67Of/exmW2+99aKDDjroirE+u+yyy/UnnHDCBi9+8Yvv/uAHP/iGuXPn3rbffvstfPnLX37l0UcfvcFrX/vabX7wgx/M3X333a+77bbb6o9//OM6J5xwwobHHnvsn/fcc88bHvawh9249957X/WlL31pk2uuuWbm7rvvft1JJ510l3POOWf2cr3ZZSR4BAAAAFhTHbbw1OkuYXltt912t/z0pz/94+te97ot/ud//mfDL33pSzM33XTTm/faa69r5syZs3jjjTduP/zhD/9w8MEH3/1zn/vcpjfffPOMe9/73jd8+ctfPuvZz372wqWfYcn23Xffaw499NALPv7xj2/25je/eauddtrp+mOOOeasgw8+eKuJ+r/61a+++Le//e16H/rQh+52ww03zNh9992v+dSnPnXe3Llzb1/p+jWvec3lv/nNb9Y76qijNv7sZz87c4sttrh5v/32O33mzJn5zne+c/bb3va2Tb/yla9s/N3vfneDddZZZ/FWW2216MUvfvGlO+200+2jN7/yla+cc+CBB9769a9/fcPvfe97d33oQx967Te/+c0z73Wvez1ged/zVFVrE86XudqqqrskWZhkXmvtmumuBwCgS9u+/oQ165e7JOe888kTT4IEACRJTj311PvMmjXr29tvv/1166233kpd1Zi/Of744+fus88+9/7c5z73lxe84AVXT3c9S3LDDTesc+aZZ8659dZbnzB//vw/jt8+1XzNHI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnLC4DAAAAACvY3nvvfW1rbeQX81kWRjwCAAAAAJ0TPAIAAACs3hYnSWttuutgRAx8VxYvz3EEjwAAAACrtytba7feeuutptxjSm655Za1Wmu3JlmwPMdZpYLHqtqzqo6rqouqqlXVU5fQ9xP9PgetvAoBAAAARs7VrbVLFi5cOHe6C2HV11rLggUL5i1evPi0+fPnX7Y8x1rVku71k/wmyeeSHDNZp6p6WpKHJrloJdUFAAAAMJLmz5+/+NRTT33vggUL/nP27NkbzZkz5/qqmu6yWMW01nLLLbestWDBgnkLFiy4trX2yeU95ioVPLbWvpXkW0ky2QVQVVsm+c8kj09ywkorDgAAAGB0HXvLLbfc7+KLL35OVc2Z7mJYNbXWbl28ePGPW2ufnD9//veW93irVPC4NFU1I8kXk7yntfb7qaTzVTU7yeyBJsOKAQAAgDXK/PnzFyf5j1NPPfU/k2yeVWz6PVYJi5MsWN7bqweNVPCY5HVJbk3y4WXY55Akh66YcgAAAABGx/z5869Jcs1018GaYWTS7aqan+RfkxzQlm3993ckmTfwuPsKKA8AAAAAGDAywWOSPZJsmuS8qrq1qm5Nsk2S91XVOZPt1Fpb1Fq7ZuyR5NqVUy4AAAAArLlG6VbrLyY5cVzbd/rtn1/55QAAAAAAk1mlgsf+qkr3GmjarqoemOSq1tp5Sa4c1/+WJJe01v608qoEAAAAAJZmlQoekzwoyUkDr9/ff/5CkgNWejUAAAAAwFBWqeCxtXZyklqG/tuusGIAAAAAgKGN0uIyAAAAAMCIEDwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ2bNd0FAADA8tj29Se06a5hOpzzzifXdNcAALAkRjwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ1bpYLHqtqzqo6rqouqqlXVUwe2rVVV76qq06vq+n6f/6qqLaaxZAAAAABgAqtU8Jhk/SS/SXLgBNvWS7Jrkrf1n5+eZIckx6606gAAAACAKZk13QUMaq19K8m3kqSqxm9bmOSxg21V9YokP6+qrVtr562sOgEAAACAJVulgschzEvSkiyYrENVzU4ye6Bp7gquCQAAAADWeKvardZTVlXrJHlXkiNaa9csoeshSRYOPC5YCeUBAAAAwBptJIPHqloryVFJKsnLltL9HemNjBx73H3FVgcAAAAAjNyt1gOh4zZJHrWU0Y5prS1Ksmhg/xVbIAAAAAAwWsHjQOi4fZK9WmtXTnNJAAAAAMAEVqngsarmJLnXQNN2VfXAJFcluTjJ15LsmmTvJDOravN+v6taazevzFoBAAAAgMmtUsFjkgclOWng9fv7z19IcliSp/RfnzZuv72SnLwC6wIAAAAAlsEqFTy21k5Ob8GYyZigEQAAAABGwEiuag0AAAAArNoEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA51ap4LGq9qyq46rqoqpqVfXUcdurqt5aVRdX1Y1VdWJVbT9N5QIAAAAAk1ilgsck6yf5TZIDJ9n+2iT/kuSlSR6S5Pok36mqdVZOeQAAAADAVMya7gIGtda+leRbSVJVd9hWvYaDkvy/1to3+m37J7k0yVOTHLkSSwUAAAAAlmBVG/G4JNsl2TzJiWMNrbWFSX6WZPfJdqqq2VV1l7FHkrkrvFIAAAAAWMONUvC4ef/50nHtlw5sm8ghSRYOPC7ovjQAAAAAYNAoBY/DekeSeQOPu09vOQAAAACw+lul5nhcikv6z5sluXigfbMkp022U2ttUZJFY6/Hzx0JAAAAAHRvlEY8/jW98PHRYw39ORsfkuSU6SoKAAAAALizVWrEY1XNSXKvgabtquqBSa5qrZ1XVR9M8qaqOjO9IPJtSS5K8vWVXCoAAAAAsASrVPCY5EFJThp4/f7+8xeSHJDk3UnWT/KpJHdN8uMkT2it3bTySgQAAAAAlmaVCh5baycnmXQSxtZaS/Lv/QcAAAAAsIoapTkeAQAAAIARIXgEAAAAADoneAQAAAAAOid4BAAAAAA6J3gEAAAAADoneAQAAAAAOid4BAAAAAA6N6urA1XVekmenWR2km+21s7t6tgAAAAAwGgZKnisqs8meUhrbaf+67WT/F+SnfpdFlbVo1prv+6mTAAAAABglAx7q/VeSY4ZeL1feqHjc/vPlyQ5dPlKAwAAAABG1bDB4+ZJzhl4/dQkv2ytHdFaOyPJp5M8ZPlKAwAAAABG1bDB4/VJ7pokVTUrySOTfGdg+7VJ5i1PYQAAAADA6Bp2cZlfJfmnqjopyVOSzE1y3MD2eya5dDlrAwAAAABG1LDB4xvTG+H4yySV5GuttZ8PbH9akp8sZ20AAAAAwIgaKnhsrf2yqu6T5GFJFrTWfjC2rarumuRjSU7uokAAAAAAYPQMNcdjVe2ZJK21bwyGjv22BUm+HHM8AgAAAMAaa9jFZU5K8tglbH9Uvw8AAAAAsAYaNnispWyfneS2IY8NAAAAAIy4Kc/xWFVbJ9l2oOk+Y7dcj3PXJC9Jcu5yVQYAAAAAjKxlWVzmBUkOTdL6jzf2H+NVeqMdX7Lc1QEAAAAAI2lZgsejkvwuvWDxqCQfTvKjcX1akuuTnNZau7STCgEAAACAkTPl4LG19ockf0iSqnpBkh+21v66ogoDAAAAAEbXsox4vF1r7QtdFwIAAAAArD6GCh6TpKp2TG/ex3sk2SB3Xum6tdYevRy1AQAAAAAjaqjgsar+Mcnnk9yS5E9Jrp6o23LUBQAAAACMsGFHPB6W5NdJnthau6K7cgAAAACA1cGMIffbIsnnhI4AAAAAwESGDR5/m174CAAAAABwJ8MGj69K8qKqeliXxQAAAAAAq4dh53h8XZKFSX5UVWckOS/JbeP6tNba3y9PcQAAAADAaBo2eHxAkpZe4DgnyX0n6NOGLQoAAAAAGG1DBY+ttW07rgMAAAAAWI0MO8cjAAAAAMCkpjTisaq2TpLW2nmDr5dmrD8AAAAAsGaZ6q3W5yRpVbVua+3msddT2G/mkHUBAAAAACNsqsHjC9MLGm8Z9xoAAAAA4E6mFDy21g5f0msAAAAAgEGdLC5TVetW1bpdHAsAAAAAGH1DB49VtXVVfb6qLk1yXZLrqurSqvpcVW3TXYkAAAAAwKiZ6hyPd1BV90ny4yR3TfK9JH/ob7pPkv2T7FNVD2+t/amLIgEAAACA0TJU8JjknUkWJ9mltXb64Iaq2inJ9/t9nrZ85QEAAAAAo2jYW60fkeTD40PHJGmt/S7JR5I8cjnqAgAAAABG2LDB41pJblzC9hv6fQAAAACANdCwweOvk7y4quaN31BVd0nyoiS/Wp7CAAAAAIDRNewcj4cm+XaSP1bV55P8ud++Q5LnJ9koyYHLXx4AAAAAMIqGCh5ba/9bVU9K8p4krx+3+bQk/9haO2k5awMAAAAARtSwIx7TWjsxyS5VtXmSbfrN57bWLumkMgAAAABgZA0dPI7pB43CRgAAAADgdsMuLpOq2qSq3ltVZ1TVDf3HGf22zbosEgAAAAAYLUMFj1V1vySnJ3lVkoVJvtp/LOy3/baqduqqSAAAAABgtAx7q/VHk8xM8pDW2i8GN1TVbkm+meQ/k+y1fOUBAAAAAKNo2Futd0vyofGhY5K01n6e5ENJHrI8hQEAAAAAo2vY4PGyJDctYftN/T4AAAAAwBpo2ODxg0leVlWbj99QVVskeVm/DwAAAACwBhp2jscZSa5LclZV/U+Ss/rt2yd5av/1jKp61cA+rbX2gWELBQAAAABGx7DB43sH/vu5E2x/wLg+SdKSCB4BAAAAYA0wbPC4XadVAAAAAACrlaGCx9bauV0XAgAAAACsPoZdXAYAAAAAYFKCRwAAAACgc4JHAAAAAKBzgkcAAAAAoHNTCh6r6l+q6t4ruhgAAAAAYPUw1RGPH0jyoLEXVXVbVe23YkoCAAAAAEbdVIPHq5NsNvC6VkAtAAAAAMBqYtYU+52c5LCqemCShf22/avqoUvYp7XW/nU5agMAAAAARtRUg8eXJ/lgkscl2TRJ6//345awT0sieAQAAACANdCUbrVurV3WWtuvtXa31trM9G61fl5rbcYSHjO7LraqZlbV26rqr1V1Y1WdXVVvriq3fgMAAADAKmSqIx7He0GSn3ZZyBS9LsnLkjw/ye/TW/Dm8+nd/v3haagHAAAAAJjAUMFja+0LY/9dVfdNsk3/5bmttTO6KGwSD0vyjdbaCf3X51TVc5LstgLPCQAAAAAso6muan0nVfX3VXV2ktOTHN9/nF5VZ1XVU7oqcJyfJnl0Vd27X8POSR6e5FtLqHN2Vd1l7JFk7gqqDQAAAADoG2rEY1U9KcnRSc5N8oYkf+hv2jHJPyc5pqr2bq19u5Mq/+adSe6S5I9VdVuSmUne2Fr77yXsc0iSQzuuAwAAAABYgmHneHxzkt8m2aO1dv1A+7FV9ZEkP04v7Os6eHxmkucm2S+9OR4fmOSDVXXR4O3f47wjyfsHXs9NckHHdQEAAAAAA4YNHh+Q5A3jQsckSWvt+qo6PMnbl6ewSbwnyTtba0f2X59eVdukN6pxwuCxtbYoyaKx1xbABgAAAIAVb9g5Hm9KsuEStm/Y79O19ZIsHtd2W5ZjrkoAAAAAoHvDBnb/m+Rfq2r38Ruq6iFJ/iXJictT2CSOS/LGqnpyVW1bVU9L8qok/7MCzgUAAAAADGnYW61fm+SUJD+uqp8n+VO/fYckuyW5LMnrlr+8O3llkrcl+ViSTZNclOSTSd66As4FAAAAAAxpqOCxtfbXqnpAenMrPjHJs/qbzk3yofTmYbysmxLvcN5rkxzUfwAAAAAAq6hhRzymHyz+W/8BAAAAAHA7i7IAAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnVvm4LGq1quqU6vqpSuiIAAAAABg9C1z8NhauyHJdkla9+UAAAAAAKuDYW+1/naSx3dZCAAAAACw+hg2eHxbkntX1Rer6uFVtWVVbTj+0WWhAAAAAMDomDXkfr/vP983yX5L6DdzyOMDAAAAACNs2ODxrTHHIwAAAAAwiaGCx9baYR3XAQAAAACsRoad4/EOqmpeVbmtGgAAAABIshzBY1U9qKq+XVU3JLkyySP67RtX1Teq6pHdlAgAAAAAjJqhgseqeliSHyfZPsmXBo/TWrsiybwkL+miQAAAAABg9Aw74vHtSf6Q3qrWb5hg+0lJHjJsUQAAAADAaBs2eHxwks+31hZl4tWtL0yy+dBVAQAAAAAjbdjg8Zal7LtlkuuGPDYAAAAAMOKGDR7/L8kzJtpQVesneUGSHwxbFAAAAAAw2oYNHg9N8qCqOiHJE/ttO1fVi5OcmmSTJG/roD4AAAAAYAQNFTy21n6W5ElJ7pXkv/rN70vyqSQzkzyptfbbTioEAAAAAEbOrGF3bK39b5IdqmqX9ALIGUnOTnJqa22iBWcAAAAAgDXE0MHjmNbar5P8uoNaAAAAAIDVxNDBY1XNTvJP6d1yvW2/+Zwk30zymdbaTctbHAAAAAAwmoaa47Gq7p7ktCQfTrJzksv7j537baf1+wAAAAAAa6BhV7X+aJJtkjyztbZla+0R/ceWSZ6VZOt+HwAAAABgDTTsrdaPTvKB1trXxm9orX21qnZN8srlqgwAAAAAGFnDjni8NsllS9h+Sb8PAAAAALAGGjZ4/HySA6pqvfEbqmpOkhck+ezyFAYAAAAAjK4p3WpdVU8f1/TrJE9O8seq+kKSs/rt2yfZP8lVSX7bVZEAAAAAwGiZ6hyPX0vSklT/9eB/v3GC/ndPckSSo5arOgAAAABgJE01eNxrhVYBAAAAAKxWphQ8ttZ+sKILAQAAAABWH8MuLgMAAAAAMKmp3mp9J1X18CQvTHKPJBvkb3M+jmmttZ2XozYAAAAAYEQNFTxW1auSvCfJTUn+lN4q1gAAAAAASYYf8fiaJD9Jsk9rbWGH9QAAAAAAq4Fh53hcL8l/Cx0BAAAAgIkMGzyelOT+XRYCAAAAAKw+hg0eX5nk0VX16qrasMuCAAAAAIDRN1Tw2Fo7P8knk7wzyeVVdX1VXTPu4TZsAAAAAFhDDbuq9VuTvDHJhUl+mUTICAAAAADcbthVrV+a5IQkT22tLe6wHgAAAABgNTDsHI9rJzlB6AgAAAAATGTY4PH4JHt0WQgAAAAAsPoYNnh8S5L7VtXHqmp+VW1SVRuOf3RZKAAAAAAwOoad4/FP/ecHJnnJEvrNHPL4AAAAAMAIGzZ4fGuS1mUhAAAAAMDqY6jgsbV2WMd1AAAAAACrkWHneAQAAAAAmNRQIx6r6t+n0K211t42zPEBAAAAgNE27ByPhy1hW0tS/WfBIwAAAACsgYa61bq1NmP8I70Q855JPpDkl0k27bBOAAAAAGCEdDbHY2ttcWvtr621Vyc5M8l/dnVsAAAAAGC0rKjFZX6Y5Ekr6NgAAAAAwCpuRQWPD0qyeAUdGwAAAABYxQ27qvX+k2y6a5I9kzw9yWeGrAkAAAAAGHHDrmp9+BK2XZHknUneOuSxAQAAAIARN2zwuN0EbS3J1a21a5ejHgAAAABgNTBU8NhaO7frQgAAAACA1cewIx5vV1VzkmyQpMZva62dt7zHBwAAAABGz7CLy6yT5NAkL0qy0RK6zhzm+AAAAADAaBt2xOPHkjw/ydeT/CjJ1V0VBAAAAACMvmGDx6cn+Uxr7SVdFgMAAAAArB5mDLlfS/KrLgsBAAAAAFYfwwaP30jymC4LAQAAAABWH8MGj29Lco+q+lRVza+qTapqw/GPLgsdU1VbVtWXqurKqrqxqk6vqgetiHMBAAAAAMMZdo7HM/vPu6S3svVkOl3Vuqo2SPKTJCcleWKSy5NsH4vbAAAAAMAqZdjg8a3pzfO4sr0uyfmttRcMtP11GuoAAAAAAJZgqOCxtXZYx3VM1VOSfKeqvprkEUkuTPKx1tqnJ9uhqmYnmT3QNHfFlggAAAAADDvH43S5R5KXpXer9+OTfDzJh6vq+UvY55AkCwceF6zoIgEAAABgTTdqweOMJL9qrb2htfbr1tqnknw6yUuXsM87kswbeNx9xZcJAAAAAGu2Yed4nC4XJzljXNsfkuw72Q6ttUVJFo29rqoVUxkAAAAAcLtRG/H4kyQ7jGu7d5Jzp6EWAAAAAGASoxY8fiDJQ6vqDVV1r6raL8k/J/noNNcFAAAAAAwYqeCxtfaLJE9L8pwkv0vy5iQHtdb+e1oLAwAAAADuYNTmeExr7fgkx093HQAAAADA5EZqxCMAAAAAMBoEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA52ZNdwEAAMCy2/b1J7TprmFlO+edT67prgEAmDojHgEAAACAzgkeAQAAAIDOCR4BAAAAgM4JHgEAAACAzgkeAQAAAIDOCR4BAAAAgM4JHgEAAACAzgkeAQAAAIDOCR4BAAAAgM4JHgEAAACAzgkeAQAAAIDOCR4BAAAAgM4JHgEAAACAzgkeAQAAAIDOCR4BAAAAgM4JHgEAAACAzgkeAQAAAIDOCR4BAAAAgM4JHgEAAACAzgkeAQAAAIDOCR4BAAAAgM4JHgEAAACAzgkeAQAAAIDOCR4BAAAAgM4JHgEAAACAzgkeAQAAAIDOCR4BAAAAgM4JHgEAAACAzgkeAQAAAIDOCR4BAAAAgM4JHgEAAACAzgkeAQAAAIDOCR4BAAAAgM4JHgEAAACAzo108FhVr6+qVlUfnO5aAAAAAIC/GdngsaoenOQlSX473bUAAAAAAHc0ksFjVc1J8t9J/inJ1dNcDgAAAAAwzkgGj0k+muSE1tqJS+tYVbOr6i5jjyRzV3x5AAAAALBmmzXdBSyrqnp2kl2TPHiKuxyS5NAVVxEAjJjD5rXpLoG+wxbWdJcAsCra9vUnrHF/V53zzif7OwFY7YzUiMeq2irJh5I8t7V20xR3e0eSeQOPu6+g8gAAAACAvlEb8Tg/yaZJflV1+z8GzUyyZ1W9Isns1tptgzu01hYlWTT2emA/AAAAAGAFGbXg8ftJ7j+u7fNJ/pjkXeNDRwAAAABgeoxU8NhauzbJ7wbbqur6JFe21n438V4AAAAAwMo2UnM8AgAAAACjYaRGPE6ktfbI6a4BAAAAALgjIx4BAAAAgM4JHgEAAACAzgkeAQAAAIDOCR4BAAAAgM4JHgEAAACAzgkeAQAAAIDOCR4BAAAAgM4JHgEAAACAzgkeAQAAAIDOCR4BAAAAgM4JHgEAAACAzgkeAQAAAIDOCR4BAAAAgM4JHgEAAACAzgkeAQAAAIDOCR4BAAAAgM4JHgEAAACAzgkeAQAAAIDOCR4BAAAAgM4JHgEAAACAzgkeAQAAAIDOCR4BAAAAgM4JHgEAAACAzgkeAQAAAIDOCR4BAAAAgM4JHgEAAACAzgkeAQAAAIDOCR4BAAAAgM4JHgEAAACAzgkeAQAAAIDOCR4BAAAAgM4JHgEAAACAzs2a7gIAWIMcNq9NdwkAAACsHEY8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0TPAIAAAAAnRM8AgAAAACdEzwCAAAAAJ0bqeCxqg6pql9U1bVVdVlVfb2qdpjuugAAAACAOxqp4DHJI5J8NMlDkzw2yVpJvltV609rVQAAAADAHcya7gKWRWvtCYOvq+qAJJclmZ/kh9NREwAAAABwZyMVPE5gXv/5qsk6VNXsJLMHmuau0IoAAAAAgNENHqtqRpIPJvlJa+13S+h6SJJDV0pRq4rD5rXpLoG+wxbWdJcAAMBo2/b1J/j9HoCRNGpzPA76aJKdkjx7Kf3ekd7IyLHH3VdwXQAAAACwxhvJEY9V9ZEkeyfZs7V2wZL6ttYWJVk0sO8Krg4AAAAAGKngsXqp4X8meVqSR7bW/jrNJQEAAAAAExip4DG926v3S/L3Sa6tqs377QtbazdOX1kAAAAAwKBRm+PxZenN03hykosHHs+axpoAAAAAgHFGasRja80EjQAAAAAwAkZtxCMAAAAAMAIEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA52ZNdwEAK9xh89p0lwAALL9tX3+Cv9NZbfl+rznOeeeTa7prWNnW1O/3mvhnPZ4RjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA5wSPAAAAAEDnBI8AAAAAQOcEjwAAAABA50YyeKyqA6vqnKq6qap+VlW7TXdNAAAAAMDfjFzwWFXPSvL+JG9JsmuS3yT5TlVtOq2FAQAAAAC3G7ngMcmrkny6tfb51toZSV6a5IYkL5zesgAAAACAMbOmu4BlUVVrJ5mf5B1jba21xVV1YpLdJ9lndpLZA01zx56rakWVOq0Wvn7u0juxUsyrust014BrAlh1rYi/J7Y66KiuDwkAdKjWwP9PXFN/P1nN/6yn9D/a1Vpb0YV0pqq2SHJhkoe11k4ZaH93kke01h4ywT6HJTl0pRUJAAAAAGuGu7fWLpxs40iNeBzSO9KbE3LQhkmumoZaYLrNTXJBkrsnuXaaa4Hp4BoA1wG4BsB1AK6BbsxNctGSOoxa8HhFktuSbDaufbMkl0y0Q2ttUZJF45qv6b40WPUNTC9wbWvNdcAaxzUArgNwDYDrAFwDnVnqZzdSi8u01m5OcmqSR4+1VdWM/utTJtsPAAAAAFi5Rm3EY9K7bfoLVfXLJD9PclCS9ZN8fjqLAgAAAAD+ZuSCx9baV6pqkyRvTbJ5ktOSPKG1dum0FgajYVGSt+TO0w/AmsI1AK4DcA2A6wBcAyvJSK1qDQAAAACMhpGa4xEAAAAAGA2CRwAAAACgc4JHAAAAAKBzgkcAAAAAoHOCR1hNVNVdq+pTVXV5VV1fVSdV1a5T3He3qvpYVZ1aVbdU1RJXnaqqF1XVH6rqpqo6s6pe2c27gOWzPNdBf/8dq+rbVXVdVV1VVV+sqk3G9dm2qtokj2d3/67gzqpqdlW9q6ouqqobq+pnVfXYKe67ZVUdVVULquqaqvpGVd1jkr5+3rNKWhnXwBJ+1r+++3cEy27Y66CqdqiqD1TVT/s/31tVbbuE/k+pql/1+55XVW+pqlmdvhkYwsq4BqrqnEn+LvhE529oNeWHBawGqmpGkhOS7JzkPUmuSPLyJCdX1fzW2plLOcSTkrw4yW+T/CXJvZdwrpck+USSo5O8P8keST5cVeu11t61vO8FhrW810FV3T3JD5MsTPKGJHOSvDrJ/atqt9bazeN2OSLJN8e1nbLcbwSm5vAkz0jywSRnJjkgyTeraq/W2o8n26mq5iQ5Kcm8JG9PckuSf0vyg6p6YGvtyoG+ft6zKjs8K/ga6Ptekv8a1/brDuqHLhyeIa6DJLsn+ZckZyT5Q5IHTtaxqp6Y5OtJTk7yyiT3T/KmJJsmedlyVQ/L7/Cs4Gug77Qk7xvX9udlLXaN1Vrz8PAY8UeSZyZpSZ4x0LZJkquTfHkK+2+WZN3+f3+k96Nhwn7rphfmHD+u/UtJrkuywXR/Fh5r7qOD6+BjSW5IsvVA22P6x/zngbZt+22vnu737LFmPpLsNv47mGSdJGcl+elS9n1tf98HD7TdJ8mtSd4+0Obnvccq+1gZ10C/vSX5yHS/Xw+PiR7LeR1smGRu/79f3T/OtpP0/X16ocusgbb/l2RxkvtM9+fgseY+VuI1cM7434c8lu3hVmtYPTwjyaVJjhlraK1dnuSoJH9fVbOXtHNr7dLW2o1TOM9eSTZKL6AZ9NEk6yd58rIUDR1brusgyb7p/VJx3sD+J6b3r5nPnGiHqlq/qtZe3sJhGT0jyW1JPjXW0Fq7Kclnk+xeVVstZd9ftNZ+MbDvH5N8P3f8nvt5z6psZVwDt6uqdatqnS4Khw4NfR201q5qrV27tBNU1X2T3DfJp1prtw5s+liS6tcA02WFXwODqmrtqlp/2GLXZIJHWD3skuRXrbXF49p/nmS9LOHW6SHOkyS/HNd+anr/6rlLYPoMfR1U1Zbp3TI0/rs9tv9E3+1D0xv5dVNV/aKqHjdU1bDsdkny59baNePaf95/fuBEO/WnI3hAJv+e37Oq5g6cIxP09fOeVcHKuAbGHJDk+iQ3VtUZVbXfsEVDx4a6DoY4RzLummmtXZTkgvi7gOm1Mq6BMY9K786o6/pzPv5rh8de7QkeYfVwtyQXT9A+1rZFh+e5rbV22WBj6819d2WH54FhLM91cLdxfcfvv+HAiMnFSb6b5DVJnpLe3GCbJvlWVRkFxsow7Hd9wySzp7ivn/esylbGNZAkP03yxiRPTW8uu9uS/HdVmdeOVcHK+P1/ab8f+buA6bSy/h/4t0kOS+/uqBclOS/JB6vKfNdTZHEZWMX0/zV+qrduLmq9iSfWTbJogu039Z/X7aK2/nHGL7AxeK6uzsMabhqug7FtS9t/Uf9W7MePq/eL6U1O/b70FriBFWnY7/pUv+djz37es6paGddAWmt/N9ihqj6X3qjft1fV4VOcpgZWlJXx+//Srpm7dHAOGNZK+X/g1tpTBl9X1eeTfCvJq6rqP1trF3RxntWZEY+w6tkzyY1TfOzQ3+fG9P4Ff7x1BrZ34cZMHgat0+F5YGVfB2Pbhtq/tXZVks8n2aG/OjasSMN+15fle+7nPauylXEN3El/xO9Hktw1yfylVgkr1sr4/X9p14y/C5hOK+v/ge+gP+DhA+kN5HvkijjH6saIR1j1/DHJC6bY9+KB57tNsH2s7aLlLWrgPDOratPB2+/6i2ts1OF5YGVfB2PHmGz/q1prE/2L6qDz+88bpjfvEawoFyfZcoL2pX3Xr0pvZMBUrhM/71mVrYxrYDKDP+thOg17HSzrOcaOef64bXfL3+bSg+mwMq6Byfi7YBkIHmEV01q7JMnhy7jbaUn2qKoZ4xbWeEh6k+D+uZvqclr/+UFJvjnQ/qD0RlCfFujAyr4OWmsXVtXl6X2Xx9stU/tu36P/fPmUqoXhnZZkr6q6y7gJ1R8ysP1OWmuLq+r0TPw9f0iSvwys8Dh2DD/vWRWdlhV/DUzGz3pWFadliOtgiHMkvWvm9pCxqrZIcvcMrCYM0+C0rPhrYDL+LlgGbrWG1cPXkmyW5OljDVW1cZJ/SHLc4EitqrpnVd1zyPP8b3qjBcZPqv6y9IIdc9sxnZb3Ojg6yd5VtdVAv0entxr2VwfaNhl/4v6q2C9M8tvW2kSTXEOXvpZkZpJ/HmvoL370giQ/a62d32/buqruM8G+D66qBw3su0N6qzV+daCfn/esylb4NTDJz/q5SQ5KckV6cz3CdFqe62BKWmu/T+8ulH+uqpkDm16WpPVrgOmywq+Bqtpw3Hc/VbVWktenNxf2SUPWvkap3u3pwCjr/zD8cZKdkrwnvV+IX55k6yQPbq39aaDvOUnSWtt2oG2bJP/Yf7l3ev9K9Ob+63Nba18c6PvyJB9N7wf9d5LskWT/JG9srb29+3cHU9PBdbBVkl8nWZDkQ0nmpLdy9QX9/Rf1+30+yT2TfD+9Wzi2TfKSJHOTPL61dvKKeo8wpqqOSvK09OYYOivJ89Mbnfvo1toP+31OTvKI1loN7Dc3ve/53CTvTXJLklel94v7A1trlw/09fOeVdaKvgaq6rD0VrM+Lr0VTO+W3j8wbZ3kH1tr/72i3yMszXJcB/OSvLL/8u+SPCG9BfIWJFnQWvvIQN+9kxybXsByZHq/Z70iyWdba7cHPjAdVvQ1UFUHJHlTer8L/TW9W6v3S+86eENr7R0r9A2uJgSPsJqoqg3SC1uemt4KXr9I8urW2i/H9TsnuVPg8shM/q81P2itPXLcMf4pycFJtktvfouPJPlQ8wOFabY810G//X5J3p/k4en9K+YJSQ5urV060Oc5SV6aZMckG6T3C8qPkvy/1tqvun9XcGdVtU6StyV5Xnrfw98meXNr7TsDfU7OuF+0++13T+8X9Meld/fLyUn+rbV21gTn8fOeVdKKvgaq6rHp/ePT/dOb1/T69G41fVdr7X9X2BuDZTDsdVBV26YXokzk3Al+P3pqkkPT+93n8vSmw3lra+2Wbt4JDGdFXwNVNT+97/6uSTZJ7/8PTkvy4dbaVyfZn3EEjwAAAABA58zxCAAAAAB0TvAIAAAAAHRO8AgAAAAAdE7wCAAAAAB0TvAIAAAAAHRO8AgAAAAAdE7wCAAAAAB0TvAIAAAAAHRO8AgAAAAAdE7wCAAwYqrqgKpqVbXtkPtvX1XfraqF/eM8dXmPCQAA482a7gIAAFjpvpBkuyRvTLIgyS+TPGY6CwIAYPUjeAQAGD1fTHJkkkXLumNVrZtk9yT/0Vr7yEB7d9UBAEDcag0AMHJaa7e11m5qrbUhdt+k/7ygw5IYUFXrT3cNAACrAsEjAMCImWg+xqo6p6qOr6qHV9XPq+qmqvpLVe0/0OewJOf2X76nf4xzlnCe1t9nfPs5VXX4uLa7VtUHq+r8qlpUVWdV1euqasa4fjOq6l+r6vR+jZdX1ber6kHj+j2vqk6tqhur6qqqOrKqtprCZzO3X8c5/Touq6rvVdWu4/o9pKq+WVVXV9X1VfXbqvrXcX0eVVU/6m9fUFXfqKodx/U5rP853beqvlxVVyf58fK+DwCA1YFbrQEAVh/3SvK1JJ9Nbx7HFyY5vKpOba39Pskx6Y10/ECSI5J8M8l1y3vSqlovyQ+SbJnkk0nOS/KwJO9IcrckBw10/2ySA5J8K8ln0vt9dI8kD01vrslU1RuTvC3JUf0+myR5ZZIfVtUurbUFSyjnE0mekeQjSc5IslGShyfZMcmv+sd/bJLjk1yc5ENJLulv37v/OlX1mH6Nf0lyWJJ1+zX8pKp2ba2dM+68X01yZpI3JKkO3gcAwMgTPAIArD52SLJna+1HSVJVRyU5P8kLkry6tfbbqromveDxV621L3V03lcluWeSXVprZ/bbPllVFyV5TVW9r7V2flXtlV7o+OHW2uDowvdVf5LJqtomyVuSvKm19vaxDlV1TJJfJ3l5krdnck9O8unW2sEDbe8eOM7M9MLRi5M8cDD8G6uh7z1Jrkqye2vtqv72r/dreEuS5487729aa/sNHGt53wcAwMhzqzUAwOrjjLHQMUlaa5cn+VOSe6zg8/5Dkh8lubqqNh57JDkxycwke/b77ZukpRfI3cHAfJVPT+931KPGHeuS9EYU7rWUWhYkeUhVbTHJ9l3SW9H7g+NHHI7VUFV3S/LAJIePhY797b9N8r0kT5rguJ8Y93p53wcAwMgz4hEAYPVx3gRtVyfZYAWfd/skD0hy+STbN+0/3zPJRYNh3iTHqvTCuYncspRaXpvebebnV9Wp6d1O/l+ttb8M1JAkv1vCMbbpP/9pgm1/SPL4qlq/tXb9QPtfx/Vb3vcBADDyBI8AAKuP2yZpr0nahzVz3OsZ6Y0EfPcEfZPkz8tw7BnpjYp8YiZ+P0uck7K1dlRV/SjJ05I8Lslrkryuqp7eWvvWMtSxrG4c93q53gcAwOpA8AgAwGSuTnLXwYaqWju9BWMGnZ1kTmvtxKUc7+z0RgtuuIRRj2enF5T+tbW2LIHl7VprFyf5WJKPVdWm6S0q88b0Fos5u99tp/RuBZ/I2MrfO0yw7T5Jrhg32nEiy/0+AABGnTkeAQCYzNn52/yMY/45dx7xeFSS3avq8eMPUFV3raqxf+w+Or0w7tAJ+o2NyjwmvRGCh45b7CXVs9FkxVbVzKqaN9jWWrssyUVJZvebfpXebdEHVdVdJ6qhH1yeluT5g32qaqf0RlF+c7IaBgz9PgAAVhdGPAIAMJnPJPlEVR2d3q3UOyd5fJIrxvV7T5KnJDm+qg5PcmqS9ZPcP8kzkmyb3ijBk6rqi0n+paq2T/Lt9P4hfI8kJyX5SGvt7Kp6U5J3JNm2v5L0tektCPO0JJ9K8t5J6p2b5IKq+lqS36R3O/Njkjw4ycFJ0lpbXFUvS3JcktOq6vPprXB9nyT367+/pHeL9reSnFJVn02ybpJXJlmY5LClfXDL+T4AAFYLgkcAACbz6fSCshcleUJ6K1c/Nsn3Bzu11m6oqkckeUN6K1zvn+Sa9OZ2PDS9sG7MC5L8tn/M9/S3/TLJTweO986q+nOSf8vfRkeen+S7SY5dQr03pHeL9ePyt1Wlz0ry8tbaxweO/52q2qt/7IP7/c7uv9+xPidW1RPSW4H7rektBvODJK9rrY1fSGZCy/E+AABWC9Vam+4aAAAAAIDVjDkeAQAAAIDOCR4BAAAAgM4JHgEAAACAzgkeAQAAAIDOCR4BAAAAgM4JHgEAAACAzgkeAQAAAIDOCR4BAAAAgM4JHgEAAACAzgkeAQAAAIDOCR4BAAAAgM4JHgEAAACAzv1/Jx82r5HSvJQAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -568,7 +568,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 17, "id": "8bc72789", "metadata": { "editable": true, @@ -584,8 +584,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average influence of corrupted points: -0.051812828\n", - "Average influence of other points: 0.033997897\n" + "Average influence of corrupted points: -1.0750157\n", + "Average influence of other points: 0.10827962\n" ] } ], @@ -620,7 +620,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 18, "id": "462d545e", "metadata": { "editable": true, @@ -639,7 +639,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 19, "id": "1e096222", "metadata": { "editable": true, @@ -654,7 +654,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -697,7 +697,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 20, "id": "efdb4050", "metadata": { "editable": true, @@ -713,14 +713,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "Conjugate gradient: 0%| | 0/53 [00:00" ] @@ -914,18 +914,25 @@ } ], "source": [ - "plt.plot(mean_ekfac_train_influences, color=\"red\")\n", - "plt.plot(mean_train_influences, color=\"blue\")\n", + "plt.scatter(mean_train_influences, mean_ekfac_train_influences)\n", "plt.legend([\"ekfac\", \"direct\"])\n", - "plt.xlabel(\"Feature index\")\n", - "plt.ylabel(\"Influence Score\")\n", + "plt.xlabel(\"Direct Influence Score\")\n", + "plt.ylabel(\"EK-FAC Influence Score\")\n", "plt.title(\"Influence of training points - EK-FAC vs direct method\")\n", "plt.show()" ] }, + { + "cell_type": "markdown", + "id": "de31676a", + "metadata": {}, + "source": [ + "The above plot shows a good correlation between the EK-FAC and the direct method. Indeed, this is confirmed by explicit calculation of the Pearson and Spearman correlation coefficients." + ] + }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 27, "id": "8537c4b1", "metadata": {}, "outputs": [ @@ -933,8 +940,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Pearson Correlation EK-FAC vs direct 0.19388048831254523\n", - "Spearman Correlation EK-FAC vs direct 0.3658280922431866\n" + "Pearson Correlation EK-FAC vs direct 0.959797872242442\n", + "Spearman Correlation EK-FAC vs direct 0.8938761115449531\n" ] } ], @@ -959,7 +966,7 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 28, "id": "a3256f00", "metadata": {}, "outputs": [ @@ -967,8 +974,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Pearson Correlation EK-FAC vs direct 0.10598500963131875\n", - "Spearman Correlation EK-FAC vs direct -0.03157894736842105\n" + "Pearson Correlation EK-FAC vs direct 0.9879168976873198\n", + "Spearman Correlation EK-FAC vs direct 0.9819548872180449\n" ] } ], From 784fdf61319238ac8ca2c11a83574404021722ae Mon Sep 17 00:00:00 2001 From: Dominik Jain Date: Fri, 22 Dec 2023 16:08:22 +0100 Subject: [PATCH 13/87] Fix underlined whitespace between badges in README --- README.md | 28 +++++++--------------------- 1 file changed, 7 insertions(+), 21 deletions(-) diff --git a/README.md b/README.md index 417709714..ee0cc5d3d 100644 --- a/README.md +++ b/README.md @@ -7,27 +7,13 @@

- - PyPI - - - Version - - - documentation - - - License - - - Build status - - - - - - DOI - + PyPI + Version + documentation + License + Build status + + DOI

**pyDVL** collects algorithms for **Data Valuation** and **Influence Function** computation. From 822b4787921645424ae203803b4703e6a3c11b8a Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Fri, 22 Dec 2023 16:21:39 +0100 Subject: [PATCH 14/87] add ekfac dask tests and make others more robust --- notebooks/influence_wine.ipynb | 39 ++++++++----- tests/influence/test_influence_calculator.py | 58 ++++++++++++++++++- tests/influence/torch/test_influence_model.py | 45 +++++--------- tests/influence/torch/test_util.py | 19 ++++++ 4 files changed, 113 insertions(+), 48 deletions(-) diff --git a/notebooks/influence_wine.ipynb b/notebooks/influence_wine.ipynb index 4ead5a255..c24266b94 100644 --- a/notebooks/influence_wine.ipynb +++ b/notebooks/influence_wine.ipynb @@ -291,7 +291,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Model fitting: 100%|██████████| 300/300 [00:01<00:00, 173.02it/s]\n" + "Model fitting: 100%|██████████| 300/300 [00:02<00:00, 101.35it/s]\n" ] } ], @@ -347,7 +347,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -535,7 +535,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -584,8 +584,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average influence of corrupted points: -1.0750157\n", - "Average influence of other points: 0.10827962\n" + "Average influence of corrupted points: -1.055609\n", + "Average influence of other points: 0.107684255\n" ] } ], @@ -654,7 +654,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -720,7 +720,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Conjugate gradient: 100%|██████████| 54/54 [00:04<00:00, 13.12it/s]\n" + "Conjugate gradient: 100%|██████████| 54/54 [00:06<00:00, 8.31it/s]\n" ] } ], @@ -765,7 +765,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Percentage error of cg over direct method:5.162223146726319e-05 %\n" + "Percentage error of cg over direct method:0.00019243561837356538 %\n" ] } ], @@ -821,7 +821,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Percentage error of Arnoldi over direct method:64.04273509979248 %\n" + "Percentage error of Arnoldi over direct method:87.29403018951416 %\n" ] } ], @@ -876,7 +876,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Percentage error of EK-FAC over direct method:1040.204906463623 %\n" + "Percentage error of EK-FAC over direct method:2013.3354187011719 %\n" ] } ], @@ -902,7 +902,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -915,6 +915,13 @@ ], "source": [ "plt.scatter(mean_train_influences, mean_ekfac_train_influences)\n", + "plt.scatter(\n", + " mean_train_influences[:num_corrupted_idxs],\n", + " mean_ekfac_train_influences[:num_corrupted_idxs],\n", + " facecolors=\"none\",\n", + " edgecolors=\"r\",\n", + " s=60,\n", + ")\n", "plt.legend([\"ekfac\", \"direct\"])\n", "plt.xlabel(\"Direct Influence Score\")\n", "plt.ylabel(\"EK-FAC Influence Score\")\n", @@ -927,7 +934,7 @@ "id": "de31676a", "metadata": {}, "source": [ - "The above plot shows a good correlation between the EK-FAC and the direct method. Indeed, this is confirmed by explicit calculation of the Pearson and Spearman correlation coefficients." + "The above plot shows a good correlation between the EK-FAC and the direct method. Corrupted points have been circled in red, and in both the direct and approximate case they are correcly identified as having negative influence on the model's accuracy. This is confirmed by explicit calculation of the Pearson and Spearman correlation coefficients." ] }, { @@ -940,8 +947,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Pearson Correlation EK-FAC vs direct 0.959797872242442\n", - "Spearman Correlation EK-FAC vs direct 0.8938761115449531\n" + "Pearson Correlation EK-FAC vs direct 0.9621345709705068\n", + "Spearman Correlation EK-FAC vs direct 0.9007179383832532\n" ] } ], @@ -974,8 +981,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Pearson Correlation EK-FAC vs direct 0.9879168976873198\n", - "Spearman Correlation EK-FAC vs direct 0.9819548872180449\n" + "Pearson Correlation EK-FAC vs direct 0.9898618538582042\n", + "Spearman Correlation EK-FAC vs direct 0.9127819548872179\n" ] } ], diff --git a/tests/influence/test_influence_calculator.py b/tests/influence/test_influence_calculator.py index 23797e9ad..d11731d9a 100644 --- a/tests/influence/test_influence_calculator.py +++ b/tests/influence/test_influence_calculator.py @@ -7,6 +7,7 @@ import pytest import torch from distributed import Client +from torch import nn from torch.utils.data import DataLoader, TensorDataset from pydvl.influence import DaskInfluenceCalculator, InfluenceMode @@ -20,13 +21,19 @@ ThreadSafetyViolationError, UnalignedChunksError, ) -from pydvl.influence.torch import ArnoldiInfluence, CgInfluence, DirectInfluence +from pydvl.influence.torch import ( + ArnoldiInfluence, + CgInfluence, + DirectInfluence, + EkfacInfluence, +) from pydvl.influence.torch.util import ( NestedTorchCatAggregator, TorchCatAggregator, TorchNumpyConverter, ) from tests.influence.torch.test_influence_model import model_and_data, test_case +from tests.influence.torch.test_util import are_active_layers_linear @pytest.fixture @@ -34,7 +41,7 @@ "influence_factory", [ lambda model, loss, train_dataLoader, hessian_reg: CgInfluence( - model, loss, train_dataLoader + model, loss, train_dataLoader, hessian_reg ).fit(train_dataLoader), lambda model, loss, train_dataLoader, hessian_reg: DirectInfluence( model, loss, hessian_reg @@ -338,3 +345,50 @@ def test_sequential_calculator(model_and_data, test_case): assert torch.allclose(seq_values, torch_values, atol=1e-6) assert np.allclose(seq_values_from_zarr, torch_values.numpy(), atol=1e-6) shutil.rmtree(zarr_values_path) + + +@pytest.mark.torch +def test_dask_ekfac_influence(model_and_data, test_case): + model, loss, x_train, y_train, x_test, y_test = model_and_data + chunk_size = int(test_case.train_data_len / 4) + da_x_train = da.from_array( + x_train.numpy(), chunks=(chunk_size, *[-1 for _ in x_train.shape[1:]]) + ) + da_y_train = da.from_array( + y_train.numpy(), chunks=(chunk_size, *[-1 for _ in y_train.shape[1:]]) + ) + da_x_test = da.from_array( + x_test.numpy(), chunks=(chunk_size, *[-1 for _ in x_test.shape[1:]]) + ) + da_y_test = da.from_array( + y_test.numpy(), chunks=(chunk_size, *[-1 for _ in y_test.shape[1:]]) + ) + train_dataloader = DataLoader( + TensorDataset(x_train, y_train), batch_size=test_case.batch_size + ) + + if not are_active_layers_linear(model): + with pytest.raises(NotImplementedError): + EkfacInfluence(model).fit(train_dataloader) + elif isinstance(loss, nn.CrossEntropyLoss): + ekfac_influence = EkfacInfluence( + model, hessian_regularization=test_case.hessian_reg + ).fit(train_dataloader) + + numpy_converter = TorchNumpyConverter() + dask_inf = DaskInfluenceCalculator( + ekfac_influence, numpy_converter, DisableClientSingleThreadCheck + ) + + dask_val = dask_inf.influences( + da_x_test, + da_y_test, + da_x_train, + da_y_train, + mode=test_case.mode, + ) + dask_val = dask_val.compute(scheduler="synchronous") + torch_val = ekfac_influence.influences( + x_test, y_test, x_train, y_train, mode=test_case.mode + ).numpy() + assert np.allclose(dask_val, torch_val, atol=1e-5, rtol=1e-3) diff --git a/tests/influence/torch/test_influence_model.py b/tests/influence/torch/test_influence_model.py index 5ee6915e2..f9e5942f4 100644 --- a/tests/influence/torch/test_influence_model.py +++ b/tests/influence/torch/test_influence_model.py @@ -20,7 +20,6 @@ import torch import torch.nn.functional as F from pytest_cases import fixture, parametrize, parametrize_with_cases -from scipy.stats import pearsonr, spearmanr from torch import nn from torch.utils.data import DataLoader, TensorDataset @@ -30,6 +29,10 @@ analytical_linear_influences, linear_model, ) +from tests.influence.torch.test_util import ( + are_active_layers_linear, + check_influence_correlations, +) # Mark the entire module pytestmark = pytest.mark.torch @@ -55,7 +58,7 @@ def create_conv1d_nn(): return nn.Sequential( nn.Conv1d(in_channels=5, out_channels=3, kernel_size=2), nn.Flatten(), - nn.Linear(6, 3), + nn.Linear(6, 2), ) @@ -67,7 +70,7 @@ def create_conv1d_no_grad(): return nn.Sequential( nn.Conv1d(in_channels=5, out_channels=3, kernel_size=2).requires_grad_(False), nn.Flatten(), - nn.Linear(6, 3), + nn.Linear(6, 2), ) @@ -131,7 +134,7 @@ def case_conv1d_nn_up(self) -> TestCase: return TestCase( module_factory=create_conv1d_nn, input_dim=(5, 3), - output_dim=3, + output_dim=2, loss=nn.MSELoss(), mode=InfluenceMode.Up, ) @@ -140,7 +143,7 @@ def case_conv1d_nn_pert(self) -> TestCase: return TestCase( module_factory=create_conv1d_nn, input_dim=(5, 3), - output_dim=3, + output_dim=2, loss=nn.SmoothL1Loss(), mode=InfluenceMode.Perturbation, ) @@ -167,7 +170,7 @@ def case_conv1d_no_grad_up(self) -> TestCase: return TestCase( module_factory=create_conv1d_no_grad, input_dim=(5, 3), - output_dim=3, + output_dim=2, loss=nn.CrossEntropyLoss(), mode=InfluenceMode.Up, ) @@ -553,28 +556,10 @@ def test_influences_ekfac( with pytest.raises(NotFittedException): ekfac_influence.influence_factors(x_test, y_test) - def is_active_layers_linear(): - for module in model.modules(): - if not isinstance(module, nn.Linear): - param_requires_grad = [p.requires_grad for p in module.parameters()] - if any(param_requires_grad): - with pytest.raises(NotImplementedError): - ekfac_influence.fit(train_dataloader) - return False - return True - - def check_correlations(true_infl, approx_infl, threshold=0.95): - for axis in range(0, true_infl.ndim): - mean_true_infl = np.mean(true_infl, axis=axis) - mean_approx_infl = np.mean(approx_infl, axis=axis) - assert np.all( - pearsonr(mean_true_infl, mean_approx_infl).statistic > threshold - ) - assert np.all( - spearmanr(mean_true_infl, mean_approx_infl).statistic > threshold - ) - - if is_active_layers_linear and isinstance(loss, nn.CrossEntropyLoss): + if not are_active_layers_linear: + with pytest.raises(NotImplementedError): + ekfac_influence.fit(train_dataloader) + elif isinstance(loss, nn.CrossEntropyLoss): ekfac_influence = ekfac_influence.fit(train_dataloader) ekfac_influence = ekfac_influence.update_diag(train_dataloader) ekfac_influence_values = ekfac_influence.influences( @@ -592,5 +577,5 @@ def check_correlations(true_infl, approx_infl, threshold=0.95): ).numpy() assert np.allclose(ekfac_influence_values, influence_from_factors) - check_correlations(direct_influences, ekfac_influence_values) - check_correlations(direct_sym_influences, ekfac_self_influence) + check_influence_correlations(direct_influences, ekfac_influence_values) + check_influence_correlations(direct_sym_influences, ekfac_self_influence) diff --git a/tests/influence/torch/test_util.py b/tests/influence/torch/test_util.py index 33b8c9316..6e675b18f 100644 --- a/tests/influence/torch/test_util.py +++ b/tests/influence/torch/test_util.py @@ -7,6 +7,7 @@ torch = pytest.importorskip("torch") import torch.nn from numpy.typing import NDArray +from scipy.stats import pearsonr, spearmanr from torch.nn.functional import mse_loss from torch.utils.data import DataLoader, TensorDataset @@ -278,3 +279,21 @@ def __getitem__(self, index): torch_dataset_to_dask_array( tensor_data_set, chunk_size=chunk_size, total_size=total_size + 1 ) + + +def check_influence_correlations(true_infl, approx_infl, threshold=0.95): + for axis in range(0, true_infl.ndim): + mean_true_infl = np.mean(true_infl, axis=axis) + mean_approx_infl = np.mean(approx_infl, axis=axis) + assert np.all(pearsonr(mean_true_infl, mean_approx_infl).statistic > threshold) + assert np.all(spearmanr(mean_true_infl, mean_approx_infl).statistic > threshold) + + +def are_active_layers_linear(model): + for module in model.modules(): + if len(list(module.children())) == 0 and len(list(module.parameters())) > 0: + if not isinstance(module, torch.nn.Linear): + param_requires_grad = [p.requires_grad for p in module.parameters()] + if any(param_requires_grad): + return False + return True From ce44b7784c0c955778de54af0b0cfa39b79082ee Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Thu, 28 Dec 2023 12:42:10 +0100 Subject: [PATCH 15/87] ekfac documentation --- docs/assets/pydvl.bib | 17 +++++ docs/influence/influence_function_model.md | 32 ++++++++- .../torch/influence_function_model.py | 68 +++++++++++++++++-- src/pydvl/influence/torch/util.py | 2 +- 4 files changed, 112 insertions(+), 7 deletions(-) diff --git a/docs/assets/pydvl.bib b/docs/assets/pydvl.bib index e87ad3484..a79fb6627 100644 --- a/docs/assets/pydvl.bib +++ b/docs/assets/pydvl.bib @@ -342,4 +342,21 @@ @InProceedings{kwon_data_2023 pdf = {https://proceedings.mlr.press/v202/kwon23e/kwon23e.pdf}, url = {https://proceedings.mlr.press/v202/kwon23e.html}, abstract = {Data valuation is a powerful framework for providing statistical insights into which data are beneficial or detrimental to model training. Many Shapley-based data valuation methods have shown promising results in various downstream tasks, however, they are well known to be computationally challenging as it requires training a large number of models. As a result, it has been recognized as infeasible to apply to large datasets. To address this issue, we propose Data-OOB, a new data valuation method for a bagging model that utilizes the out-of-bag estimate. The proposed method is computationally efficient and can scale to millions of data by reusing trained weak learners. Specifically, Data-OOB takes less than $2.25$ hours on a single CPU processor when there are $10^6$ samples to evaluate and the input dimension is $100$. Furthermore, Data-OOB has solid theoretical interpretations in that it identifies the same important data point as the infinitesimal jackknife influence function when two different points are compared. We conduct comprehensive experiments using 12 classification datasets, each with thousands of sample sizes. We demonstrate that the proposed method significantly outperforms existing state-of-the-art data valuation methods in identifying mislabeled data and finding a set of helpful (or harmful) data points, highlighting the potential for applying data values in real-world applications.} +} + +@article{george2018fast, + title={Fast approximate natural gradient descent in a kronecker factored eigenbasis}, + author={George, Thomas and Laurent, C{\'e}sar and Bouthillier, Xavier and Ballas, Nicolas and Vincent, Pascal}, + journal={Advances in Neural Information Processing Systems}, + volume={31}, + year={2018} +} + +@inproceedings{martens2015optimizing, + title={Optimizing neural networks with kronecker-factored approximate curvature}, + author={Martens, James and Grosse, Roger}, + booktitle={International conference on machine learning}, + pages={2408--2417}, + year={2015}, + organization={PMLR} } \ No newline at end of file diff --git a/docs/influence/influence_function_model.md b/docs/influence/influence_function_model.md index d12d963c9..1beaaf5ed 100644 --- a/docs/influence/influence_function_model.md +++ b/docs/influence/influence_function_model.md @@ -87,7 +87,7 @@ the Hessian and \(V\) contains the corresponding eigenvectors. See also ```python from pydvl.influence.torch import ArnoldiInfluence -if_model = ArnoldiInfluence +if_model = ArnoldiInfluence( model, loss, hessian_regularization=0.0, @@ -97,4 +97,32 @@ if_model = ArnoldiInfluence ``` These implementations represent the calculation logic on in memory tensors. To scale up to large collection of data, we map these influence function models over these collections. For a detailed discussion see the -documentation page [Scaling Computation](scaling_computation.md). \ No newline at end of file +documentation page [Scaling Computation](scaling_computation.md). + +### Eigenvalue Corrected K-FAC + +K-FAC, short for Kronecker-Factored Approximate Curvature, is a method that approximates the Fisher information matrix [FIM](https://en.wikipedia.org/wiki/Fisher_information) of a model. It is possible to show that for classification models with appropriate loss functions the FIM is equal to the Hessian of the model’s loss over the dataset. In this restricted but nonetheless important context K-FAC offers an efficient way to approximate the Hessian and hence the influence scores. +For more info and details refer to the original paper [@martens2015optimizing]. + +The K-FAC method is implemented in the class [EkfacInfluence](pydvl/influence/torch/influence_function_model.py). The following code snippet shows how to use the K-FAC method to calculate the influence function of a model. Note that, in contrast to the other methods for influence function calculation, K-FAC does not require the loss function as an input. This is because the current implementation is only applicable to classification models with a cross entropy loss function. + +```python +from pydvl.influence.torch import EkfacInfluence +if_model = EkfacInfluence( + model, + hessian_regularization=0.0, +) +``` +Upon initialization, the K-FAC method will parse the model and extract which layers require grad and which do not. Then it will only calculate the influence scores for the layers that require grad. The current implementation of the K-FAC method is only available for linear layers, and therefore if the model contains non-linear layers that require gradient the K-FAC method will raise a ValueError. + +A further improvement of the K-FAC method is the Eigenvalue Corrected K-FAC (EKFAC) method [@george2018fast], which allows to further re-fit the eigenvalues of the Hessian, thus providing a more accurate approximation. On top of the K-FAC method, the EKFAC method is implemented by simply calling the update_diag method from [EkfacInfluence](pydvl/influence/torch/influence_function_model.py). The following code snippet shows how to use the EKFAC method to calculate the influence function of a model. + +```python +from pydvl.influence.torch import EkfacInfluence +if_model = EkfacInfluence( + model, + hessian_regularization=0.0, +) +if_model.fit(train_loader) +if_model.update_diag(train_loader) +``` \ No newline at end of file diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index d1cbced53..73326c7f2 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -883,6 +883,20 @@ def to(self, device: torch.device): class EkfacInfluence(TorchInfluenceFunctionModel): + r""" + Solves the linear system Hx = b, where H is the Hessian of a model with the empirical + categorical cross entropy as loss function and b is the given right-hand side vector. + It employs the EK-FAC method [@george2018fast], which is based on the kronecker + factorization of the Hessian first introduced in [@martens2015optimizing]. + Contrary to the other influence function methods, this implementation can only + be used for classification tasks with a cross entropy loss function. However, it + is much faster than the other methods and can be used efficiently for very large + datasets and models. For more information, see [Eigenvalue Corrected K-FAC][ekfac]. + + Args: + model: Instance of [torch.nn.Module][torch.nn.Module]. + hessian_regularization: Regularization of the hessian. + """ ekfac_representation: EkfacRepresentation @@ -904,6 +918,11 @@ def is_fitted(self): return False def _parse_active_layers(self) -> Dict[str, torch.nn.Module]: + """ + Find all layers of the model that have parameters that require grad + and return them in a dictionary. If a layer has some parameters that require + grad and some that do not, raise an error. + """ active_layers: Dict[str, torch.nn.Module] = {} for m_name, module in self.model.named_modules(): if len(list(module.children())) == 0 and len(list(module.parameters())) > 0: @@ -913,7 +932,7 @@ def _parse_active_layers(self) -> Dict[str, torch.nn.Module]: if all(layer_requires_grad): active_layers[m_name] = module elif any(layer_requires_grad): - raise RuntimeError( + raise ValueError( f"Layer {m_name} has some parameters that require grad and some that do not." f"This is not supported. Please set all parameters of the layer to require grad." ) @@ -923,6 +942,10 @@ def _parse_active_layers(self) -> Dict[str, torch.nn.Module]: def init_layer_kfac_blocks( module: torch.nn.Module, ) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Initialize the tensors that will store the cumulative forward and + backward KFAC blocks for the layer. + """ if isinstance(module, nn.Linear): with_bias = module.bias is not None sG = module.out_features @@ -942,6 +965,13 @@ def get_layer_kfac_hooks( forward_x: Dict[str, torch.Tensor], grad_y: Dict[str, torch.Tensor], ) -> Tuple[Callable, Callable]: + """ + Create the hooks that will be used to compute the forward and backward KFAC + blocks for the layer. The hooks are registered to the layer and will be called + during the forward and backward passes. At each pass, the hooks will update the + tensors that store the cumulative forward and backward KFAC blocks for the layer. + These tensors are stored in the forward_x and grad_y dictionaries. + """ if isinstance(module, nn.Linear): with_bias = module.bias is not None @@ -968,6 +998,11 @@ def get_kfac_blocks( self, data: DataLoader, ) -> Tuple[Dict[str, torch.Tensor], Dict[str, torch.Tensor]]: + """ + Compute the KFAC blocks for each layer of the model, using the provided data. + Returns the average forward and backward KFAC blocks for each layer in + dictionaries. + """ forward_x = {} grad_y = {} hooks = [] @@ -997,6 +1032,11 @@ def get_kfac_blocks( return forward_x, grad_y def fit(self, data: DataLoader) -> EkfacInfluence: + """ + Compute the KFAC blocks for each layer of the model, using the provided data. + It then creates an EkfacRepresentation object that stores the KFAC blocks for + each layer, their eigenvalue decomposition and diagonal values. + """ forward_x, grad_y = self.get_kfac_blocks(data) layers_evecs_a = {} layers_evect_g = {} @@ -1019,6 +1059,9 @@ def fit(self, data: DataLoader) -> EkfacInfluence: @staticmethod def init_layer_diag(module: torch.nn.Module) -> torch.Tensor: + """ + Initialize the tensor that will store the updated diagonal values of the layer. + """ if isinstance(module, nn.Linear): with_bias = module.bias is not None sG = module.out_features @@ -1037,7 +1080,13 @@ def get_layer_diag_hooks( last_x_kfe: Dict[str, torch.Tensor], diags: Dict[str, torch.Tensor], ) -> Tuple[Callable, Callable]: - + """ + Create the hooks that will be used to update the diagonal values of the layer. + The hooks are registered to the layer and will be called during the forward and + backward passes. At each pass, the hooks will update the tensor that stores the + updated diagonal values of the layer. This tensor is stored in the diags + dictionary. + """ evecs_a, evecs_g = self.ekfac_representation.get_layer_evecs() if isinstance(module, nn.Linear): with_bias = module.bias is not None @@ -1068,7 +1117,11 @@ def update_diag( self, data: DataLoader, ) -> EkfacInfluence: - + """ + Compute the updated diagonal values for each layer of the model, using the + provided data. It then updates the EkfacRepresentation object that stores the + KFAC blocks for each layer, their eigenvalue decomposition and diagonal values. + """ if not self.is_fitted: raise ValueError( "EkfacInfluence must be fitted before calling update_diag on it. " @@ -1099,10 +1152,17 @@ def update_diag( for hook in hooks: hook.remove() - self.ekfac_representation.diags = diags.values() + self.ekfac_representation = EkfacRepresentation( + self.ekfac_representation.layer_names, + self.ekfac_representation.layers_module, + self.ekfac_representation.evecs_a, + self.ekfac_representation.evecs_g, + diags.values(), + ) return self + @log_duration def _solve_hvp(self, rhs: torch.Tensor) -> torch.Tensor: x = rhs.clone() start_idx = 0 diff --git a/src/pydvl/influence/torch/util.py b/src/pydvl/influence/torch/util.py index 550387fab..8c87b24d0 100644 --- a/src/pydvl/influence/torch/util.py +++ b/src/pydvl/influence/torch/util.py @@ -456,7 +456,7 @@ def __call__( ) -@dataclass +@dataclass(frozen=True) class EkfacRepresentation: r""" Container class for the EKFAC representation of the Hessian. From 7e163b168c154e65719a8f019a6ca561d7d4d21d Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Thu, 28 Dec 2023 14:25:34 +0100 Subject: [PATCH 16/87] distilbert notebook --- notebooks/influence_distilbert.ipynb | 353 +++++++++++++++++++++++++++ requirements-notebooks.txt | 1 + 2 files changed, 354 insertions(+) create mode 100644 notebooks/influence_distilbert.ipynb diff --git a/notebooks/influence_distilbert.ipynb b/notebooks/influence_distilbert.ipynb new file mode 100644 index 000000000..8773e24a4 --- /dev/null +++ b/notebooks/influence_distilbert.ipynb @@ -0,0 +1,353 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/fabio/miniconda3/envs/pydvl_env/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n", + "Found cached dataset imdb (/Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0)\n", + "100%|██████████| 3/3 [00:00<00:00, 365.94it/s]\n" + ] + } + ], + "source": [ + "from datasets import load_dataset\n", + "import torch\n", + "\n", + "imdb = load_dataset(\"imdb\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading cached shuffled indices for dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-9c48ce5d173413c7.arrow\n", + "Loading cached shuffled indices for dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-d00218895ddb9236.arrow\n" + ] + } + ], + "source": [ + "small_train_dataset = (\n", + " imdb[\"train\"].shuffle(seed=42).select([i for i in list(range(30))])\n", + ")\n", + "small_test_dataset = imdb[\"test\"].shuffle(seed=4).select([i for i in list(range(3))])" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Positive probability: 96.0169792175293%\n", + "Negative probability: 3.9830222725868225%\n" + ] + } + ], + "source": [ + "import torch.nn.functional as F\n", + "from transformers import AutoTokenizer, AutoModelForSequenceClassification\n", + "\n", + "tokenizer = AutoTokenizer.from_pretrained(\"assemblyai/distilbert-base-uncased-sst2\")\n", + "model = AutoModelForSequenceClassification.from_pretrained(\n", + " \"assemblyai/distilbert-base-uncased-sst2\"\n", + ")\n", + "\n", + "tokenized_segments = tokenizer(\n", + " [\n", + " \"AssemblyAI is the best speech-to-text API for modern developers with performance being second to none!\"\n", + " ],\n", + " return_tensors=\"pt\",\n", + " padding=True,\n", + " truncation=True,\n", + ")\n", + "tokenized_segments_input_ids, tokenized_segments_attention_mask = (\n", + " tokenized_segments.input_ids,\n", + " tokenized_segments.attention_mask,\n", + ")\n", + "model_predictions = F.softmax(\n", + " model(\n", + " input_ids=tokenized_segments_input_ids,\n", + " attention_mask=tokenized_segments_attention_mask,\n", + " )[\"logits\"],\n", + " dim=1,\n", + ")\n", + "\n", + "print(\"Positive probability: \" + str(model_predictions[0][1].item() * 100) + \"%\")\n", + "print(\"Negative probability: \" + str(model_predictions[0][0].item() * 100) + \"%\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-2171cbc40247bcf4.arrow\n", + "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-66cb6f78496beb63.arrow\n" + ] + } + ], + "source": [ + "def preprocess_function(examples):\n", + " return tokenizer(examples[\"text\"], truncation=True, padding=True)\n", + "\n", + "\n", + "tokenized_train = small_train_dataset.map(preprocess_function, batched=True)\n", + "tokenized_test = small_test_dataset.map(preprocess_function, batched=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "class ImdbDataset(torch.utils.data.Dataset):\n", + " def __init__(self, encodings, attn_mask, labels):\n", + " self.encodings = encodings\n", + " self.attn_mask = attn_mask\n", + " self.labels = labels\n", + "\n", + " def __getitem__(self, idx):\n", + " x = torch.tensor([self.encodings[idx], self.attn_mask[idx]])\n", + " y = torch.tensor(self.labels[idx])\n", + " return x, y\n", + "\n", + " def __len__(self):\n", + " return len(self.labels)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "train_dataset = ImdbDataset(\n", + " tokenized_train[\"input_ids\"],\n", + " tokenized_train[\"attention_mask\"],\n", + " tokenized_train[\"label\"],\n", + ")\n", + "test_dataset = ImdbDataset(\n", + " tokenized_test[\"input_ids\"],\n", + " tokenized_test[\"attention_mask\"],\n", + " tokenized_test[\"label\"],\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "class PatchedModel(torch.nn.Module):\n", + " def __init__(self, model):\n", + " super().__init__()\n", + " self.model = model\n", + "\n", + " def forward(self, x):\n", + " return self.model(x[:, 0], x[:, 1])[\"logits\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "for param in model.named_parameters():\n", + " param[1].requires_grad = False\n", + "\n", + "for m_name, module in model.named_modules():\n", + " if len(list(module.children())) == 0 and len(list(module.parameters())) > 0:\n", + " if isinstance(module, torch.nn.Linear):\n", + " for p_name, param in module.named_parameters():\n", + " if (\n", + " \"ffn\" in m_name\n", + " or \"pre_classifier\" in m_name\n", + " or \"classifier\" in m_name\n", + " ):\n", + " param.requires_grad = True" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "distilbert.transformer.layer.0.ffn.lin1.weight torch.Size([3072, 768])\n", + "distilbert.transformer.layer.0.ffn.lin1.bias torch.Size([3072])\n", + "distilbert.transformer.layer.0.ffn.lin2.weight torch.Size([768, 3072])\n", + "distilbert.transformer.layer.0.ffn.lin2.bias torch.Size([768])\n", + "distilbert.transformer.layer.1.ffn.lin1.weight torch.Size([3072, 768])\n", + "distilbert.transformer.layer.1.ffn.lin1.bias torch.Size([3072])\n", + "distilbert.transformer.layer.1.ffn.lin2.weight torch.Size([768, 3072])\n", + "distilbert.transformer.layer.1.ffn.lin2.bias torch.Size([768])\n", + "distilbert.transformer.layer.2.ffn.lin1.weight torch.Size([3072, 768])\n", + "distilbert.transformer.layer.2.ffn.lin1.bias torch.Size([3072])\n", + "distilbert.transformer.layer.2.ffn.lin2.weight torch.Size([768, 3072])\n", + "distilbert.transformer.layer.2.ffn.lin2.bias torch.Size([768])\n", + "distilbert.transformer.layer.3.ffn.lin1.weight torch.Size([3072, 768])\n", + "distilbert.transformer.layer.3.ffn.lin1.bias torch.Size([3072])\n", + "distilbert.transformer.layer.3.ffn.lin2.weight torch.Size([768, 3072])\n", + "distilbert.transformer.layer.3.ffn.lin2.bias torch.Size([768])\n", + "distilbert.transformer.layer.4.ffn.lin1.weight torch.Size([3072, 768])\n", + "distilbert.transformer.layer.4.ffn.lin1.bias torch.Size([3072])\n", + "distilbert.transformer.layer.4.ffn.lin2.weight torch.Size([768, 3072])\n", + "distilbert.transformer.layer.4.ffn.lin2.bias torch.Size([768])\n", + "distilbert.transformer.layer.5.ffn.lin1.weight torch.Size([3072, 768])\n", + "distilbert.transformer.layer.5.ffn.lin1.bias torch.Size([3072])\n", + "distilbert.transformer.layer.5.ffn.lin2.weight torch.Size([768, 3072])\n", + "distilbert.transformer.layer.5.ffn.lin2.bias torch.Size([768])\n", + "pre_classifier.weight torch.Size([768, 768])\n", + "pre_classifier.bias torch.Size([768])\n", + "classifier.weight torch.Size([2, 768])\n", + "classifier.bias torch.Size([2])\n" + ] + } + ], + "source": [ + "for param in model.named_parameters():\n", + " if param[1].requires_grad:\n", + " print(param[0], param[1].shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "train_dataloader = torch.utils.data.DataLoader(\n", + " train_dataset, batch_size=3, shuffle=True\n", + ")\n", + "test_dataloader = torch.utils.data.DataLoader(test_dataset, batch_size=3, shuffle=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "first_batch = next(iter(test_dataloader))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([3, 2, 364])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "first_batch[0].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Batch Test Gradients: 100%|██████████| 1/1 [00:01<00:00, 1.36s/it]\n", + "Batch Split Input Gradients: 100%|██████████| 10/10 [00:24<00:00, 2.50s/it]\n" + ] + } + ], + "source": [ + "from pydvl.influence import compute_influences\n", + "from pydvl.influence.torch import TorchTwiceDifferentiable\n", + "\n", + "patched_model = PatchedModel(model)\n", + "patched_model.eval()\n", + "\n", + "ekfac_train_influences = compute_influences(\n", + " TorchTwiceDifferentiable(patched_model, F.cross_entropy),\n", + " training_data=train_dataloader,\n", + " test_data=test_dataloader,\n", + " influence_type=\"up\",\n", + " inversion_method=\"ekfac\",\n", + " hessian_regularization=0.1,\n", + " progress=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([3, 30])" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ekfac_train_influences.shape" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pydvl_env", + "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.9.16" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/requirements-notebooks.txt b/requirements-notebooks.txt index c45e0a104..f55e01b80 100644 --- a/requirements-notebooks.txt +++ b/requirements-notebooks.txt @@ -2,3 +2,4 @@ torch==2.0.1 torchvision==0.15.2 datasets==2.14.6 pillow==9.3.0 +transformers==4.35.0 \ No newline at end of file From 316826920517cd8bcc6f626ed5403f4cab59e82b Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Thu, 28 Dec 2023 14:30:01 +0100 Subject: [PATCH 17/87] fix hook dimensions --- src/pydvl/influence/torch/influence_function_model.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index 73326c7f2..950b4cd4f 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -976,7 +976,7 @@ def get_layer_kfac_hooks( with_bias = module.bias is not None def input_hook(m, x, y): - x = x[0] + x = x[0].reshape(-1, module.in_features) if with_bias: x = torch.cat( (x, torch.ones((x.shape[0], 1), device=module.weight.device)), @@ -985,7 +985,7 @@ def input_hook(m, x, y): forward_x[m_name] += torch.mm(x.t(), x) def grad_hook(m, m_grad, m_out): - m_out = m_out[0] + m_out = m_out[0].reshape(-1, module.out_features) grad_y[m_name] += torch.mm(m_out.t(), m_out) else: @@ -1092,7 +1092,7 @@ def get_layer_diag_hooks( with_bias = module.bias is not None def input_hook(m, x, y): - x = x[0] + x = x[0].reshape(-1, module.in_features) if with_bias: x = torch.cat( (x, torch.ones((x.shape[0], 1), device=module.weight.device)), @@ -1101,7 +1101,7 @@ def input_hook(m, x, y): last_x_kfe[m_name] = torch.mm(x, evecs_a[m_name]) def grad_hook(m, m_grad, m_out): - m_out = m_out[0] + m_out = m_out[0].reshape(-1, module.out_features) gy_kfe = torch.mm(m_out, evecs_g[m_name]) diags[m_name] += torch.mm( gy_kfe.t() ** 2, last_x_kfe[m_name] ** 2 From 9317e324f36de7ad964c311bb7209a099d11ee40 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Fri, 29 Dec 2023 01:34:37 +0100 Subject: [PATCH 18/87] WIP influences by layer --- notebooks/influence_distilbert.ipynb | 253 +++++++++++++++--- .../torch/influence_function_model.py | 169 +++++++++++- 2 files changed, 371 insertions(+), 51 deletions(-) diff --git a/notebooks/influence_distilbert.ipynb b/notebooks/influence_distilbert.ipynb index 8773e24a4..03ba1a1da 100644 --- a/notebooks/influence_distilbert.ipynb +++ b/notebooks/influence_distilbert.ipynb @@ -12,13 +12,14 @@ "/Users/fabio/miniconda3/envs/pydvl_env/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", " from .autonotebook import tqdm as notebook_tqdm\n", "Found cached dataset imdb (/Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0)\n", - "100%|██████████| 3/3 [00:00<00:00, 365.94it/s]\n" + "100%|██████████| 3/3 [00:00<00:00, 410.90it/s]\n" ] } ], "source": [ "from datasets import load_dataset\n", "import torch\n", + "from pydvl.influence.torch import EkfacInfluence\n", "\n", "imdb = load_dataset(\"imdb\")" ] @@ -39,9 +40,9 @@ ], "source": [ "small_train_dataset = (\n", - " imdb[\"train\"].shuffle(seed=42).select([i for i in list(range(30))])\n", + " imdb[\"train\"].shuffle(seed=42).select([i for i in list(range(60))])\n", ")\n", - "small_test_dataset = imdb[\"test\"].shuffle(seed=4).select([i for i in list(range(3))])" + "small_test_dataset = imdb[\"test\"].shuffle(seed=4).select([i for i in list(range(15))])" ] }, { @@ -53,8 +54,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Positive probability: 96.0169792175293%\n", - "Negative probability: 3.9830222725868225%\n" + "Positive probability: 99.57591891288757%\n", + "Negative probability: 0.42408257722854614%\n" ] } ], @@ -68,9 +69,7 @@ ")\n", "\n", "tokenized_segments = tokenizer(\n", - " [\n", - " \"AssemblyAI is the best speech-to-text API for modern developers with performance being second to none!\"\n", - " ],\n", + " [\"Pydvl is the best data valuation library, and it is fully open-source!\"],\n", " return_tensors=\"pt\",\n", " padding=True,\n", " truncation=True,\n", @@ -100,8 +99,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-2171cbc40247bcf4.arrow\n", - "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-66cb6f78496beb63.arrow\n" + "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-844f976fdb8a2b78.arrow\n", + "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-7a61d4de4e064d18.arrow\n" ] } ], @@ -237,12 +236,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 40, "metadata": {}, "outputs": [], "source": [ "train_dataloader = torch.utils.data.DataLoader(\n", - " train_dataset, batch_size=3, shuffle=True\n", + " train_dataset, batch_size=5, shuffle=True\n", ")\n", "test_dataloader = torch.utils.data.DataLoader(test_dataset, batch_size=3, shuffle=True)" ] @@ -251,75 +250,182 @@ "cell_type": "code", "execution_count": 11, "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "patched_model = PatchedModel(model)\n", + "patched_model.eval()\n", + "\n", + "ekfac_influence_model = EkfacInfluence(\n", + " patched_model,\n", + " hessian_regularization=0.1,\n", + ")\n", + "ekfac_influence_model = ekfac_influence_model.fit(train_dataloader)\n", + "ekfac_influence_model.update_diag(train_dataloader)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "first_test_batch = next(iter(test_dataloader))\n", + "first_train_batch = next(iter(train_dataloader))" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, "outputs": [], "source": [ - "first_batch = next(iter(test_dataloader))" + "first_train_batch[1][0] = 1 - first_train_batch[1][0]" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/fabio/miniconda3/envs/pydvl_env/lib/python3.9/site-packages/transformers/models/distilbert/modeling_distilbert.py:222: UserWarning: There is a performance drop because we have not yet implemented the batching rule for aten::masked_fill.Tensor. Please file us an issue on GitHub so that we can prioritize its implementation. (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/functorch/BatchedFallback.cpp:84.)\n", + " scores = scores.masked_fill(\n" + ] + } + ], + "source": [ + "ekfac_train_influences = ekfac_influence_model.influences(\n", + " *first_test_batch, *first_train_batch, mode=\"up\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 44, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "torch.Size([3, 2, 364])" + "tensor([-5.8491e+01, 1.5467e+00, -8.5055e-03, 9.9609e-01, -5.1906e+00])" ] }, - "execution_count": 12, + "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "first_batch[0].shape" + "torch.mean(ekfac_train_influences, axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "first_train_batch[0][0] = first_test_batch[0][0]\n", + "first_train_batch[1][0] = first_test_batch[1][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "ekfac_train_influences = ekfac_influence_model.influences(\n", + " *first_test_batch, *first_train_batch, mode=\"up\"\n", + ")" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 18, "metadata": {}, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "Batch Test Gradients: 100%|██████████| 1/1 [00:01<00:00, 1.36s/it]\n", - "Batch Split Input Gradients: 100%|██████████| 10/10 [00:24<00:00, 2.50s/it]\n" - ] + "data": { + "text/plain": [ + "tensor(1)" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "from pydvl.influence import compute_influences\n", - "from pydvl.influence.torch import TorchTwiceDifferentiable\n", - "\n", - "patched_model = PatchedModel(model)\n", - "patched_model.eval()\n", - "\n", - "ekfac_train_influences = compute_influences(\n", - " TorchTwiceDifferentiable(patched_model, F.cross_entropy),\n", - " training_data=train_dataloader,\n", - " test_data=test_dataloader,\n", - " influence_type=\"up\",\n", - " inversion_method=\"ekfac\",\n", - " hessian_regularization=0.1,\n", - " progress=True,\n", - ")" + "first_train_batch[1][0]" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "torch.Size([3, 30])" + "tensor(3356.6882)" ] }, - "execution_count": 15, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ekfac_train_influences[0][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(796.5195)" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "torch.mean(ekfac_train_influences[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([3, 5])" + ] + }, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -327,6 +433,69 @@ "source": [ "ekfac_train_influences.shape" ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "ekfac_train_influences = ekfac_influence_model.influences_by_layer(\n", + " *first_test_batch, *first_train_batch, mode=\"up\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "influences = torch.zeros(size=(3, 5))\n", + "for layer_id, value in ekfac_train_influences.items():\n", + " influences += value" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([ 598.4623, 27.0340, 4.7846, 1015.5076, -10.5945],\n", + " grad_fn=)" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "torch.mean(influences, axis=0) * (598.4626 / 48.8362)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "12.254487449883488" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(598.4626 / 48.8362)" + ] } ], "metadata": { diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index 950b4cd4f..871173e9d 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -91,7 +91,7 @@ def _loss_grad(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: return flatten_dimensions(grads.values(), shape=shape) @log_duration - def _flat_loss_mixed_grad(self, x: torch.Tensor, y: torch.Tensor): + def _flat_loss_mixed_grad(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: mixed_grads = create_per_sample_mixed_derivative_function( self.model, self.loss )(self.model_params, x, y) @@ -191,7 +191,7 @@ def _non_symmetric_values( x: torch.Tensor, y: torch.Tensor, mode: InfluenceMode = InfluenceMode.Up, - ): + ) -> torch.Tensor: if mode == InfluenceMode.Up: if x_test.shape[0] <= x.shape[0]: factor = self.influence_factors(x_test, y_test) @@ -896,6 +896,7 @@ class EkfacInfluence(TorchInfluenceFunctionModel): Args: model: Instance of [torch.nn.Module][torch.nn.Module]. hessian_regularization: Regularization of the hessian. + progress: If True, display progress bars. """ ekfac_representation: EkfacRepresentation @@ -904,11 +905,13 @@ def __init__( self, model: nn.Module, hessian_regularization: float = 0.0, + progress: bool = False, ): super().__init__(model, torch.nn.functional.cross_entropy) self.hessian_regularization = hessian_regularization self.active_layers = self._parse_active_layers() + self.progress = progress @property def is_fitted(self): @@ -1016,7 +1019,7 @@ def get_kfac_blocks( hooks.append(module.register_forward_hook(layer_input_hook)) hooks.append(module.register_full_backward_hook(layer_grad_hook)) - for x, _ in data: + for x, _ in tqdm(data, disable=not self.progress, desc="K-FAC blocks"): data_len += x.shape[0] pred_y = self.model(x) loss = empirical_cross_entropy_loss_fn(pred_y) @@ -1140,7 +1143,7 @@ def update_diag( hooks.append(module.register_forward_hook(input_hook)) hooks.append(module.register_full_backward_hook(grad_hook)) - for x, _ in data: + for x, _ in tqdm(data, disable=not self.progress, desc="Update Diagonal"): data_len += x.shape[0] pred_y = self.model(x) loss = empirical_cross_entropy_loss_fn(pred_y) @@ -1162,11 +1165,10 @@ def update_diag( return self - @log_duration - def _solve_hvp(self, rhs: torch.Tensor) -> torch.Tensor: - x = rhs.clone() + def _solve_hvp_by_layer(self, rhs: torch.Tensor) -> Dict[str, torch.Tensor]: + hvp_layers = {} start_idx = 0 - for _, (_, evecs_a, evecs_g, diag) in self.ekfac_representation: + for layer_id, (_, evecs_a, evecs_g, diag) in self.ekfac_representation: end_idx = start_idx + diag.shape[0] rhs_layer = rhs[:, start_idx : end_idx - evecs_g.shape[0]].reshape( rhs.shape[0], evecs_g.shape[0], -1 @@ -1187,13 +1189,162 @@ def _solve_hvp(self, rhs: torch.Tensor) -> torch.Tensor: torch.einsum("ij,bjk->bik", evecs_g, inv_kfe), evecs_a.t(), ) - x[:, start_idx:end_idx] = torch.cat( + hvp_layers[layer_id] = torch.cat( [inv[:, :, :-1].reshape(rhs.shape[0], -1), inv[:, :, -1]], dim=1 ) start_idx = end_idx + return hvp_layers + + @log_duration + def _solve_hvp(self, rhs: torch.Tensor) -> torch.Tensor: + x = rhs.clone() + start_idx = 0 + layer_hvp = self._solve_hvp_by_layer(rhs) + for hvp in layer_hvp.values(): + end_idx = start_idx + hvp.shape[1] + x[:, start_idx:end_idx] = hvp + start_idx = end_idx x.detach_() return x + def influences_by_layer( + self, + x_test: torch.Tensor, + y_test: torch.Tensor, + x: Optional[torch.Tensor] = None, + y: Optional[torch.Tensor] = None, + mode: InfluenceMode = InfluenceMode.Up, + ) -> Dict[str, torch.Tensor]: + if not self.is_fitted: + raise ValueError( + "Instance must be fitted before calling influence methods on it" + ) + + if x is None: + + if y is not None: + raise ValueError( + "Providing labels y, without providing model input x " + "is not supported" + ) + + return self._symmetric_values_by_layer( + x_test.to(self.model_device), + y_test.to(self.model_device), + mode, + ) + + if y is None: + raise ValueError( + "Providing model input x without providing labels y is not supported" + ) + + return self._non_symmetric_values_by_layer( + x_test.to(self.model_device), + y_test.to(self.model_device), + x.to(self.model_device), + y.to(self.model_device), + mode, + ) + + def influence_factors_by_layer( + self, + x: torch.Tensor, + y: torch.Tensor, + ) -> Dict[str, torch.Tensor]: + if not self.is_fitted: + raise ValueError( + "Instance must be fitted before calling influence methods on it" + ) + + return self._solve_hvp_by_layer( + self._loss_grad(x.to(self.model_device), y.to(self.model_device)) + ) + + def influences_from_factors_by_layer( + self, + z_test_factors: Dict[str, torch.Tensor], + x: torch.Tensor, + y: torch.Tensor, + mode: InfluenceMode = InfluenceMode.Up, + ) -> Dict[str, torch.Tensor]: + if mode == InfluenceMode.Up: + total_grad = self._loss_grad( + x.to(self.model_device), y.to(self.model_device) + ) + start_idx = 0 + influences = {} + for layer_id, layer_z_test in z_test_factors.items(): + end_idx = start_idx + layer_z_test.shape[1] + influences[layer_id] = ( + layer_z_test @ total_grad[:, start_idx:end_idx].T + ) * (layer_z_test.shape[1] / total_grad.shape[1]) + start_idx = end_idx + return influences + elif mode == InfluenceMode.Perturbation: + total_mixed_grad = self._flat_loss_mixed_grad( + x.to(self.model_device), y.to(self.model_device) + ) + start_idx = 0 + influences = {} + for layer_id, layer_z_test in z_test_factors.items(): + end_idx = start_idx + layer_z_test.shape[1] + influences[layer_id] = torch.einsum( + "ia,j...a->ij...", + layer_z_test, + total_mixed_grad[:, start_idx:end_idx], + ) * (layer_z_test.shape[1] / total_mixed_grad.shape[1]) + start_idx = end_idx + return influences + else: + raise UnsupportedInfluenceModeException(mode) + + def _non_symmetric_values_by_layer( + self, + x_test: torch.Tensor, + y_test: torch.Tensor, + x: torch.Tensor, + y: torch.Tensor, + mode: InfluenceMode = InfluenceMode.Up, + ) -> Dict[str, torch.Tensor]: + if mode == InfluenceMode.Up: + if x_test.shape[0] <= x.shape[0]: + fac = self.influence_factors_by_layer(x_test, y_test) + values = self.influences_from_factors_by_layer(fac, x, y, mode=mode) + else: + fac = self.influence_factors_by_layer(x, y) + values = self.influences_from_factors_by_layer( + fac, x_test, y_test, mode=mode + ).T + elif mode == InfluenceMode.Perturbation: + fac = self.influence_factors_by_layer(x_test, y_test) + values = self.influences_from_factors_by_layer(fac, x, y, mode=mode) + else: + raise UnsupportedInfluenceModeException(mode) + return values + + def _symmetric_values_by_layer( + self, x: torch.Tensor, y: torch.Tensor, mode: InfluenceMode + ) -> Dict[str, torch.Tensor]: + + grad = self._loss_grad(x, y) + fac = self._solve_hvp_by_layer(grad) + + if mode == InfluenceMode.Up: + values = {} + start_idx = 0 + for layer_id, layer_fac in fac.items(): + end_idx = start_idx + layer_fac.shape[1] + values[layer_id] = (layer_fac @ grad[:, start_idx:end_idx].T) * ( + layer_fac.shape[1] / grad.shape[1] + ) + start_idx = end_idx + elif mode == InfluenceMode.Perturbation: + values = self.influences_from_factors_by_layer(fac, x, y, mode=mode) + else: + raise UnsupportedInfluenceModeException(mode) + return values + def to(self, device: torch.device): return EkfacInfluence( self.model.to(device), self.ekfac_representation.to(device) From 67f1e24e74ca4ff3e64411ddaea7d7ee04737432 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Fri, 29 Dec 2023 13:54:09 +0100 Subject: [PATCH 19/87] explore hessian reg and set it after init --- notebooks/influence_distilbert.ipynb | 348 ++++++++++++++---- .../torch/influence_function_model.py | 105 +++++- 2 files changed, 358 insertions(+), 95 deletions(-) diff --git a/notebooks/influence_distilbert.ipynb b/notebooks/influence_distilbert.ipynb index 03ba1a1da..f688e24b5 100644 --- a/notebooks/influence_distilbert.ipynb +++ b/notebooks/influence_distilbert.ipynb @@ -12,7 +12,7 @@ "/Users/fabio/miniconda3/envs/pydvl_env/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", " from .autonotebook import tqdm as notebook_tqdm\n", "Found cached dataset imdb (/Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0)\n", - "100%|██████████| 3/3 [00:00<00:00, 410.90it/s]\n" + "100%|██████████| 3/3 [00:00<00:00, 378.50it/s]\n" ] } ], @@ -40,9 +40,9 @@ ], "source": [ "small_train_dataset = (\n", - " imdb[\"train\"].shuffle(seed=42).select([i for i in list(range(60))])\n", + " imdb[\"train\"].shuffle(seed=42).select([i for i in list(range(10))])\n", ")\n", - "small_test_dataset = imdb[\"test\"].shuffle(seed=4).select([i for i in list(range(15))])" + "small_test_dataset = imdb[\"test\"].shuffle(seed=4).select([i for i in list(range(5))])" ] }, { @@ -99,8 +99,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-844f976fdb8a2b78.arrow\n", - "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-7a61d4de4e064d18.arrow\n" + "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-e2c3a4e5d7ae70bc.arrow\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-f11a8e18a76ea3e7.arrow\n" ] } ], @@ -236,7 +242,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -252,14 +258,11 @@ "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" + "name": "stderr", + "output_type": "stream", + "text": [ + "K-FAC blocks: 100%|██████████| 2/2 [00:10<00:00, 5.09s/it]\n" + ] } ], "source": [ @@ -268,15 +271,15 @@ "\n", "ekfac_influence_model = EkfacInfluence(\n", " patched_model,\n", - " hessian_regularization=0.1,\n", + " progress=True,\n", ")\n", "ekfac_influence_model = ekfac_influence_model.fit(train_dataloader)\n", - "ekfac_influence_model.update_diag(train_dataloader)" + "# ekfac_influence_model.update_diag(train_dataloader)" ] }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ @@ -286,7 +289,216 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 91, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/fabio/miniconda3/envs/pydvl_env/lib/python3.9/site-packages/transformers/models/distilbert/modeling_distilbert.py:222: UserWarning: There is a performance drop because we have not yet implemented the batching rule for aten::masked_fill.Tensor. Please file us an issue on GitHub so that we can prioritize its implementation. (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/functorch/BatchedFallback.cpp:84.)\n", + " scores = scores.masked_fill(\n" + ] + } + ], + "source": [ + "influences_by_reg_value = ekfac_influence_model.explore_hessian_regularization(\n", + " *first_train_batch, regularization_values=[1e-9, 1e-7, 1e-5, 100]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "\n", + "cols = [\"reg_value\", \"layer_id\", \"mean_infl\"]\n", + "infl_df = pd.DataFrame(influences_by_reg_value, columns=cols)\n", + "for reg_value in influences_by_reg_value:\n", + " for layer_id, layer_influences in influences_by_reg_value[reg_value].items():\n", + " mean_infl = torch.mean(layer_influences, dim=0).detach().numpy()\n", + " infl_df = pd.concat(\n", + " [infl_df, pd.DataFrame([[reg_value, layer_id, mean_infl]], columns=cols)]\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Layer model.classifier\n", + "Reg value 1e-07\n", + "Pearson 0.9999999999982297\n", + "Spearman 0.9999999999999999\n", + "Reg value 1e-05\n", + "Pearson 0.9999999999198821\n", + "Spearman 0.9999999999999999\n", + "Reg value 100.0\n", + "Pearson 0.9890089520584947\n", + "Spearman 0.8999999999999998\n", + "Layer model.distilbert.transformer.layer.0.ffn.lin1\n", + "Reg value 1e-07\n", + "Pearson 0.9999619048425001\n", + "Spearman 0.9999999999999999\n", + "Reg value 1e-05\n", + "Pearson 0.9987266503875496\n", + "Spearman 0.9999999999999999\n", + "Reg value 100.0\n", + "Pearson 0.9774404060098946\n", + "Spearman 0.8999999999999998\n", + "Layer model.distilbert.transformer.layer.0.ffn.lin2\n", + "Reg value 1e-07\n", + "Pearson 0.9999336542986618\n", + "Spearman 0.9999999999999999\n", + "Reg value 1e-05\n", + "Pearson 0.9990544073004429\n", + "Spearman 0.9999999999999999\n", + "Reg value 100.0\n", + "Pearson 0.9976124885796617\n", + "Spearman 0.8999999999999998\n", + "Layer model.distilbert.transformer.layer.1.ffn.lin1\n", + "Reg value 1e-07\n", + "Pearson 0.9999533857529216\n", + "Spearman 0.9999999999999999\n", + "Reg value 1e-05\n", + "Pearson 0.9989482437845721\n", + "Spearman 0.9999999999999999\n", + "Reg value 100.0\n", + "Pearson 0.9964914007888204\n", + "Spearman 0.8999999999999998\n", + "Layer model.distilbert.transformer.layer.1.ffn.lin2\n", + "Reg value 1e-07\n", + "Pearson 0.9999916136560949\n", + "Spearman 0.9999999999999999\n", + "Reg value 1e-05\n", + "Pearson 0.9996741637855644\n", + "Spearman 0.9999999999999999\n", + "Reg value 100.0\n", + "Pearson 0.9989650038819474\n", + "Spearman 0.8999999999999998\n", + "Layer model.distilbert.transformer.layer.2.ffn.lin1\n", + "Reg value 1e-07\n", + "Pearson 0.9999850429340159\n", + "Spearman 0.8999999999999998\n", + "Reg value 1e-05\n", + "Pearson 0.9990860089585984\n", + "Spearman 0.9999999999999999\n", + "Reg value 100.0\n", + "Pearson 0.9973567654881873\n", + "Spearman 0.8999999999999998\n", + "Layer model.distilbert.transformer.layer.2.ffn.lin2\n", + "Reg value 1e-07\n", + "Pearson 0.9999891945547907\n", + "Spearman 0.9999999999999999\n", + "Reg value 1e-05\n", + "Pearson 0.999929272221139\n", + "Spearman 0.9999999999999999\n", + "Reg value 100.0\n", + "Pearson 0.999878601294667\n", + "Spearman 0.8999999999999998\n", + "Layer model.distilbert.transformer.layer.3.ffn.lin1\n", + "Reg value 1e-07\n", + "Pearson 0.9999743929131351\n", + "Spearman 0.9999999999999999\n", + "Reg value 1e-05\n", + "Pearson 0.9999964961833777\n", + "Spearman 0.9999999999999999\n", + "Reg value 100.0\n", + "Pearson 0.997409030920537\n", + "Spearman 0.8999999999999998\n", + "Layer model.distilbert.transformer.layer.3.ffn.lin2\n", + "Reg value 1e-07\n", + "Pearson 0.9999547452419874\n", + "Spearman 0.9999999999999999\n", + "Reg value 1e-05\n", + "Pearson 0.9988697971574463\n", + "Spearman 0.9999999999999999\n", + "Reg value 100.0\n", + "Pearson 0.989390370961956\n", + "Spearman 0.8999999999999998\n", + "Layer model.distilbert.transformer.layer.4.ffn.lin1\n", + "Reg value 1e-07\n", + "Pearson 0.9996088710756871\n", + "Spearman 0.8999999999999998\n", + "Reg value 1e-05\n", + "Pearson 0.9989685809131104\n", + "Spearman 0.9999999999999999\n", + "Reg value 100.0\n", + "Pearson 0.957268685281599\n", + "Spearman 0.8999999999999998\n", + "Layer model.distilbert.transformer.layer.4.ffn.lin2\n", + "Reg value 1e-07\n", + "Pearson 0.9993781838562021\n", + "Spearman 0.8999999999999998\n", + "Reg value 1e-05\n", + "Pearson 0.9999471200780226\n", + "Spearman 0.9999999999999999\n", + "Reg value 100.0\n", + "Pearson 0.9274370208460007\n", + "Spearman 0.8999999999999998\n", + "Layer model.distilbert.transformer.layer.5.ffn.lin1\n", + "Reg value 1e-07\n", + "Pearson 0.9999999510148485\n", + "Spearman 0.9999999999999999\n", + "Reg value 1e-05\n", + "Pearson 0.9999647286519302\n", + "Spearman 0.9999999999999999\n", + "Reg value 100.0\n", + "Pearson 0.9423928206889953\n", + "Spearman 0.7999999999999999\n", + "Layer model.distilbert.transformer.layer.5.ffn.lin2\n", + "Reg value 1e-07\n", + "Pearson 0.9999445978598823\n", + "Spearman 0.9999999999999999\n", + "Reg value 1e-05\n", + "Pearson 0.9884469308546968\n", + "Spearman 0.9999999999999999\n", + "Reg value 100.0\n", + "Pearson 0.9681394800845086\n", + "Spearman 0.7999999999999999\n", + "Layer model.pre_classifier\n", + "Reg value 1e-07\n", + "Pearson 0.9999999976033913\n", + "Spearman 0.9999999999999999\n", + "Reg value 1e-05\n", + "Pearson 0.9999813416700254\n", + "Spearman 0.9999999999999999\n", + "Reg value 100.0\n", + "Pearson 0.8385744133096472\n", + "Spearman 0.7999999999999999\n" + ] + } + ], + "source": [ + "from scipy.stats import pearsonr, spearmanr\n", + "\n", + "for layer_id, group_df in infl_df.groupby(\"layer_id\"):\n", + " print(\"Layer\", layer_id)\n", + " for idx, mean_infl in enumerate(group_df[\"mean_infl\"]):\n", + " if idx == 0:\n", + " continue\n", + " print(\"Reg value\", group_df[\"reg_value\"].iloc[idx])\n", + " print(\n", + " \"Pearson\",\n", + " pearsonr(mean_infl, group_df[\"mean_infl\"].iloc[idx - 1]).statistic,\n", + " )\n", + " print(\n", + " \"Spearman\",\n", + " spearmanr(mean_infl, group_df[\"mean_infl\"].iloc[idx - 1]).statistic,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -295,7 +507,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -315,77 +527,58 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor([-5.8491e+01, 1.5467e+00, -8.5055e-03, 9.9609e-01, -5.1906e+00])" + "tensor([[ 3.2714e+01, 2.1226e+02, -3.1409e+00, -8.7363e+01, 3.4665e+02],\n", + " [-2.8046e+02, 2.0380e+02, -6.3348e-01, -3.5344e+01, 1.5909e+02],\n", + " [-8.7853e-01, -4.7143e+00, 2.3439e-01, 1.0359e+00, -5.3958e+00]])" ] }, - "execution_count": 44, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "torch.mean(ekfac_train_influences, axis=0)" + "ekfac_train_influences" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, - "outputs": [], - "source": [ - "first_train_batch[0][0] = first_test_batch[0][0]\n", - "first_train_batch[1][0] = first_test_batch[1][0]" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "ekfac_train_influences = ekfac_influence_model.influences(\n", - " *first_test_batch, *first_train_batch, mode=\"up\"\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor(1)" + "tensor([-82.8759, 137.1154, -1.1800, -40.5570, 166.7804])" ] }, - "execution_count": 18, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "first_train_batch[1][0]" + "torch.mean(ekfac_train_influences, axis=0)" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor(3356.6882)" + "tensor(32.7142)" ] }, - "execution_count": 19, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -396,16 +589,16 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor(796.5195)" + "tensor(100.2229)" ] }, - "execution_count": 20, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -416,7 +609,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -425,7 +618,7 @@ "torch.Size([3, 5])" ] }, - "execution_count": 21, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -436,7 +629,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -447,7 +640,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -458,43 +651,46 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 26, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor([ 598.4623, 27.0340, 4.7846, 1015.5076, -10.5945],\n", - " grad_fn=)" - ] - }, - "execution_count": 38, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "torch.mean(influences, axis=0) * (598.4626 / 48.8362)" + "idx = (0, 2)\n", + "infl_across_layers = []\n", + "for layer_id, value in ekfac_train_influences.items():\n", + " infl_across_layers.append(value[idx].item())" ] }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "12.254487449883488" + "[]" ] }, - "execution_count": 39, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "(598.4626 / 48.8362)" + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(infl_across_layers)" ] } ], diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index 871173e9d..98cd5fa65 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -8,11 +8,11 @@ import logging from abc import ABC, abstractmethod -from typing import Callable, Dict, Optional, Tuple +from typing import Callable, Dict, List, Optional, Tuple import torch from torch import nn as nn -from torch.utils.data import DataLoader, TensorDataset +from torch.utils.data import DataLoader from tqdm.auto import tqdm from pydvl.utils.progress import log_duration @@ -904,12 +904,12 @@ class EkfacInfluence(TorchInfluenceFunctionModel): def __init__( self, model: nn.Module, - hessian_regularization: float = 0.0, + hessian_regularization: Optional[float] = None, progress: bool = False, ): super().__init__(model, torch.nn.functional.cross_entropy) - self.hessian_regularization = hessian_regularization + self._hessian_regularization = hessian_regularization self.active_layers = self._parse_active_layers() self.progress = progress @@ -920,6 +920,22 @@ def is_fitted(self): except AttributeError: return False + @property + def hessian_regularization(self): + return self._hessian_regularization + + @hessian_regularization.setter + def hessian_regularization(self, value): + if self._hessian_regularization is None: + self._hessian_regularization = value + else: + raise ValueError( + "Hessian regularization can only be set once." + "To change the regularization value but retain the fitted representation, " + "create a new EkfacInfluence instance and pass ekfac_representation after " + "initialization." + ) + def _parse_active_layers(self) -> Dict[str, torch.nn.Module]: """ Find all layers of the model that have parameters that require grad @@ -1165,10 +1181,15 @@ def update_diag( return self - def _solve_hvp_by_layer(self, rhs: torch.Tensor) -> Dict[str, torch.Tensor]: + @staticmethod + def _solve_hvp_by_layer( + rhs: torch.Tensor, + ekfac_representation: EkfacRepresentation, + hessian_regularization: float, + ) -> Dict[str, torch.Tensor]: hvp_layers = {} start_idx = 0 - for layer_id, (_, evecs_a, evecs_g, diag) in self.ekfac_representation: + for layer_id, (_, evecs_a, evecs_g, diag) in ekfac_representation: end_idx = start_idx + diag.shape[0] rhs_layer = rhs[:, start_idx : end_idx - evecs_g.shape[0]].reshape( rhs.shape[0], evecs_g.shape[0], -1 @@ -1180,9 +1201,7 @@ def _solve_hvp_by_layer(self, rhs: torch.Tensor) -> Dict[str, torch.Tensor]: torch.einsum("ij,bjk->bik", evecs_g.t(), rhs_layer), evecs_a, ) - inv_diag = 1 / ( - diag.reshape(*v_kfe.shape[1:]) + self.hessian_regularization - ) + inv_diag = 1 / (diag.reshape(*v_kfe.shape[1:]) + hessian_regularization) inv_kfe = torch.einsum("bij,ij->bij", v_kfe, inv_diag) inv = torch.einsum( "bij,jk->bik", @@ -1199,7 +1218,9 @@ def _solve_hvp_by_layer(self, rhs: torch.Tensor) -> Dict[str, torch.Tensor]: def _solve_hvp(self, rhs: torch.Tensor) -> torch.Tensor: x = rhs.clone() start_idx = 0 - layer_hvp = self._solve_hvp_by_layer(rhs) + layer_hvp = self._solve_hvp_by_layer( + rhs, self.ekfac_representation, self.hessian_regularization + ) for hvp in layer_hvp.values(): end_idx = start_idx + hvp.shape[1] x[:, start_idx:end_idx] = hvp @@ -1207,6 +1228,21 @@ def _solve_hvp(self, rhs: torch.Tensor) -> torch.Tensor: x.detach_() return x + def _influences( + self, + x_test: torch.Tensor, + y_test: torch.Tensor, + x: Optional[torch.Tensor] = None, + y: Optional[torch.Tensor] = None, + mode: InfluenceMode = InfluenceMode.Up, + ) -> torch.Tensor: + if self.hessian_regularization is None: + raise ValueError( + "Hessian regularization must be set for calculating influences." + ) + + return super()._influences(x_test, y_test, x, y, mode=mode) + def influences_by_layer( self, x_test: torch.Tensor, @@ -1220,6 +1256,11 @@ def influences_by_layer( "Instance must be fitted before calling influence methods on it" ) + if self.hessian_regularization is None: + raise ValueError( + "Hessian regularization must be set for calculating influences." + ) + if x is None: if y is not None: @@ -1257,8 +1298,15 @@ def influence_factors_by_layer( "Instance must be fitted before calling influence methods on it" ) + if self.hessian_regularization is None: + raise ValueError( + "Hessian regularization must be set for calculating influence factors." + ) + return self._solve_hvp_by_layer( - self._loss_grad(x.to(self.model_device), y.to(self.model_device)) + self._loss_grad(x.to(self.model_device), y.to(self.model_device)), + self.ekfac_representation, + self.hessian_regularization, ) def influences_from_factors_by_layer( @@ -1276,9 +1324,7 @@ def influences_from_factors_by_layer( influences = {} for layer_id, layer_z_test in z_test_factors.items(): end_idx = start_idx + layer_z_test.shape[1] - influences[layer_id] = ( - layer_z_test @ total_grad[:, start_idx:end_idx].T - ) * (layer_z_test.shape[1] / total_grad.shape[1]) + influences[layer_id] = layer_z_test @ total_grad[:, start_idx:end_idx].T start_idx = end_idx return influences elif mode == InfluenceMode.Perturbation: @@ -1293,7 +1339,7 @@ def influences_from_factors_by_layer( "ia,j...a->ij...", layer_z_test, total_mixed_grad[:, start_idx:end_idx], - ) * (layer_z_test.shape[1] / total_mixed_grad.shape[1]) + ) start_idx = end_idx return influences else: @@ -1328,16 +1374,16 @@ def _symmetric_values_by_layer( ) -> Dict[str, torch.Tensor]: grad = self._loss_grad(x, y) - fac = self._solve_hvp_by_layer(grad) + fac = self._solve_hvp_by_layer( + grad, self.ekfac_representation, self.hessian_regularization + ) if mode == InfluenceMode.Up: values = {} start_idx = 0 for layer_id, layer_fac in fac.items(): end_idx = start_idx + layer_fac.shape[1] - values[layer_id] = (layer_fac @ grad[:, start_idx:end_idx].T) * ( - layer_fac.shape[1] / grad.shape[1] - ) + values[layer_id] = layer_fac @ grad[:, start_idx:end_idx].T start_idx = end_idx elif mode == InfluenceMode.Perturbation: values = self.influences_from_factors_by_layer(fac, x, y, mode=mode) @@ -1345,6 +1391,27 @@ def _symmetric_values_by_layer( raise UnsupportedInfluenceModeException(mode) return values + def explore_hessian_regularization( + self, + x: torch.Tensor, + y: torch.Tensor, + regularization_values: List[float], + ) -> Dict[float, Dict[str, torch.Tensor]]: + grad = self._loss_grad(x, y) + influences_by_reg_value = {} + for reg_value in regularization_values: + reg_factors = self._solve_hvp_by_layer( + grad, self.ekfac_representation, reg_value + ) + values = {} + start_idx = 0 + for layer_id, layer_fac in reg_factors.items(): + end_idx = start_idx + layer_fac.shape[1] + values[layer_id] = layer_fac @ grad[:, start_idx:end_idx].T + start_idx = end_idx + influences_by_reg_value[reg_value] = values + return influences_by_reg_value + def to(self, device: torch.device): return EkfacInfluence( self.model.to(device), self.ekfac_representation.to(device) From a6db2cedfd045b4b8d18b96bdef48b6cc6d24e7b Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Fri, 29 Dec 2023 17:31:53 +0100 Subject: [PATCH 20/87] WIP adding features to notebook --- notebooks/influence_distilbert.ipynb | 717 +++++++++--------- .../torch/influence_function_model.py | 8 +- 2 files changed, 357 insertions(+), 368 deletions(-) diff --git a/notebooks/influence_distilbert.ipynb b/notebooks/influence_distilbert.ipynb index f688e24b5..3947fe762 100644 --- a/notebooks/influence_distilbert.ipynb +++ b/notebooks/influence_distilbert.ipynb @@ -1,27 +1,40 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Influence functions for Large Language Models" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Imports" + ] + }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 72, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/fabio/miniconda3/envs/pydvl_env/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n", - "Found cached dataset imdb (/Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0)\n", - "100%|██████████| 3/3 [00:00<00:00, 378.50it/s]\n" - ] - } - ], + "outputs": [], "source": [ "from datasets import load_dataset\n", "import torch\n", + "from typing import Sequence\n", "from pydvl.influence.torch import EkfacInfluence\n", - "\n", - "imdb = load_dataset(\"imdb\")" + "import torch.nn.functional as F\n", + "from transformers import AutoTokenizer, AutoModelForSequenceClassification\n", + "from copy import deepcopy\n", + "from IPython.display import HTML, display" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Sentiment Analysis" ] }, { @@ -33,12 +46,16 @@ "name": "stderr", "output_type": "stream", "text": [ + "Found cached dataset imdb (/Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0)\n", + "100%|██████████| 3/3 [00:00<00:00, 428.63it/s]\n", "Loading cached shuffled indices for dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-9c48ce5d173413c7.arrow\n", "Loading cached shuffled indices for dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-d00218895ddb9236.arrow\n" ] } ], "source": [ + "imdb = load_dataset(\"imdb\")\n", + "\n", "small_train_dataset = (\n", " imdb[\"train\"].shuffle(seed=42).select([i for i in list(range(10))])\n", ")\n", @@ -49,6 +66,18 @@ "cell_type": "code", "execution_count": 3, "metadata": {}, + "outputs": [], + "source": [ + "tokenizer = AutoTokenizer.from_pretrained(\"assemblyai/distilbert-base-uncased-sst2\")\n", + "model = AutoModelForSequenceClassification.from_pretrained(\n", + " \"assemblyai/distilbert-base-uncased-sst2\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -60,14 +89,6 @@ } ], "source": [ - "import torch.nn.functional as F\n", - "from transformers import AutoTokenizer, AutoModelForSequenceClassification\n", - "\n", - "tokenizer = AutoTokenizer.from_pretrained(\"assemblyai/distilbert-base-uncased-sst2\")\n", - "model = AutoModelForSequenceClassification.from_pretrained(\n", - " \"assemblyai/distilbert-base-uncased-sst2\"\n", - ")\n", - "\n", "tokenized_segments = tokenizer(\n", " [\"Pydvl is the best data valuation library, and it is fully open-source!\"],\n", " return_tensors=\"pt\",\n", @@ -91,91 +112,66 @@ ] }, { - "cell_type": "code", - "execution_count": 4, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-e2c3a4e5d7ae70bc.arrow\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-f11a8e18a76ea3e7.arrow\n" - ] - } - ], "source": [ - "def preprocess_function(examples):\n", - " return tokenizer(examples[\"text\"], truncation=True, padding=True)\n", - "\n", - "\n", - "tokenized_train = small_train_dataset.map(preprocess_function, batched=True)\n", - "tokenized_test = small_test_dataset.map(preprocess_function, batched=True)" + "## Model and Data Preparation" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 76, "metadata": {}, "outputs": [], "source": [ "class ImdbDataset(torch.utils.data.Dataset):\n", - " def __init__(self, encodings, attn_mask, labels):\n", - " self.encodings = encodings\n", - " self.attn_mask = attn_mask\n", - " self.labels = labels\n", + " def __init__(self, dataset):\n", + " self.tokenized_ds = dataset.map(self.preprocess_function, batched=True)\n", + " self.encodings = self.tokenized_ds[\"input_ids\"]\n", + " self.attn_mask = self.tokenized_ds[\"attention_mask\"]\n", + " self.labels = self.tokenized_ds[\"label\"]\n", + "\n", + " def preprocess_function(self, examples):\n", + " return tokenizer(examples[\"text\"], truncation=True, padding=True)\n", "\n", " def __getitem__(self, idx):\n", " x = torch.tensor([self.encodings[idx], self.attn_mask[idx]])\n", " y = torch.tensor(self.labels[idx])\n", - " return x, y\n", + " text = self.tokenized_ds[idx][\"text\"]\n", + " return x, y, text\n", "\n", " def __len__(self):\n", - " return len(self.labels)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "train_dataset = ImdbDataset(\n", - " tokenized_train[\"input_ids\"],\n", - " tokenized_train[\"attention_mask\"],\n", - " tokenized_train[\"label\"],\n", - ")\n", - "test_dataset = ImdbDataset(\n", - " tokenized_test[\"input_ids\"],\n", - " tokenized_test[\"attention_mask\"],\n", - " tokenized_test[\"label\"],\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "class PatchedModel(torch.nn.Module):\n", + " return len(self.labels)\n", + "\n", + "\n", + "class ModelLogitsWrapper(torch.nn.Module):\n", " def __init__(self, model):\n", " super().__init__()\n", " self.model = model\n", "\n", " def forward(self, x):\n", - " return self.model(x[:, 0], x[:, 1])[\"logits\"]" + " return self.model(x[:, 0], x[:, 1])[\"logits\"]\n", + "\n", + "\n", + "def print_sentiment_preds(model: ModelLogitsWrapper, model_input: torch.Tensor):\n", + " model_predictions = F.softmax(model(model_input.unsqueeze(0)), dim=1)\n", + " print(\"Positive probability: \" + str(model_predictions[0][1].item() * 100) + \"%\")\n", + " print(\"Negative probability: \" + str(model_predictions[0][0].item() * 100) + \"%\")\n", + "\n", + "\n", + "def strip_param_names(param_names: Sequence[str]):\n", + " stripped_param_names = []\n", + " for name in param_names:\n", + " name = name.replace(\"model.\", \"\")\n", + " if name.startswith(\"distilbert.transformer.\"):\n", + " name = name.replace(\"distilbert.transformer.\", \"\")\n", + " stripped_param_names.append(name)\n", + " return stripped_param_names" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 69, "metadata": {}, "outputs": [], "source": [ @@ -196,318 +192,117 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 61, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "distilbert.transformer.layer.0.ffn.lin1.weight torch.Size([3072, 768])\n", - "distilbert.transformer.layer.0.ffn.lin1.bias torch.Size([3072])\n", - "distilbert.transformer.layer.0.ffn.lin2.weight torch.Size([768, 3072])\n", - "distilbert.transformer.layer.0.ffn.lin2.bias torch.Size([768])\n", - "distilbert.transformer.layer.1.ffn.lin1.weight torch.Size([3072, 768])\n", - "distilbert.transformer.layer.1.ffn.lin1.bias torch.Size([3072])\n", - "distilbert.transformer.layer.1.ffn.lin2.weight torch.Size([768, 3072])\n", - "distilbert.transformer.layer.1.ffn.lin2.bias torch.Size([768])\n", - "distilbert.transformer.layer.2.ffn.lin1.weight torch.Size([3072, 768])\n", - "distilbert.transformer.layer.2.ffn.lin1.bias torch.Size([3072])\n", - "distilbert.transformer.layer.2.ffn.lin2.weight torch.Size([768, 3072])\n", - "distilbert.transformer.layer.2.ffn.lin2.bias torch.Size([768])\n", - "distilbert.transformer.layer.3.ffn.lin1.weight torch.Size([3072, 768])\n", - "distilbert.transformer.layer.3.ffn.lin1.bias torch.Size([3072])\n", - "distilbert.transformer.layer.3.ffn.lin2.weight torch.Size([768, 3072])\n", - "distilbert.transformer.layer.3.ffn.lin2.bias torch.Size([768])\n", - "distilbert.transformer.layer.4.ffn.lin1.weight torch.Size([3072, 768])\n", - "distilbert.transformer.layer.4.ffn.lin1.bias torch.Size([3072])\n", - "distilbert.transformer.layer.4.ffn.lin2.weight torch.Size([768, 3072])\n", - "distilbert.transformer.layer.4.ffn.lin2.bias torch.Size([768])\n", - "distilbert.transformer.layer.5.ffn.lin1.weight torch.Size([3072, 768])\n", - "distilbert.transformer.layer.5.ffn.lin1.bias torch.Size([3072])\n", - "distilbert.transformer.layer.5.ffn.lin2.weight torch.Size([768, 3072])\n", - "distilbert.transformer.layer.5.ffn.lin2.bias torch.Size([768])\n", - "pre_classifier.weight torch.Size([768, 768])\n", - "pre_classifier.bias torch.Size([768])\n", - "classifier.weight torch.Size([2, 768])\n", - "classifier.bias torch.Size([2])\n" + "Total parameters: 66.96 millions\n", + "Parameters requiring gradients: 28.93 millions\n", + "Ratio: 43.20%\n" ] } ], "source": [ - "for param in model.named_parameters():\n", - " if param[1].requires_grad:\n", - " print(param[0], param[1].shape)" + "total_params = sum(p.numel() for p in model.parameters()) / 1e6\n", + "params_requiring_grad = (\n", + " sum(p.numel() for p in model.parameters() if p.requires_grad) / 1e6\n", + ")\n", + "\n", + "print(\"Total parameters: {:.2f} millions\".format(total_params))\n", + "print(\"Parameters requiring gradients: {:.2f} millions\".format(params_requiring_grad))\n", + "print(\"Ratio: {:.2f}%\".format((params_requiring_grad / total_params) * 100))" ] }, { - "cell_type": "code", - "execution_count": 10, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "train_dataloader = torch.utils.data.DataLoader(\n", - " train_dataset, batch_size=5, shuffle=True\n", - ")\n", - "test_dataloader = torch.utils.data.DataLoader(test_dataset, batch_size=3, shuffle=True)" + "## Influence function computation" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 62, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "K-FAC blocks: 100%|██████████| 2/2 [00:10<00:00, 5.09s/it]\n" + "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-2be1c3a446bd7743.arrow\n", + "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-b0ad78d634cd6710.arrow\n" ] } ], "source": [ - "patched_model = PatchedModel(model)\n", - "patched_model.eval()\n", + "train_dataset = ImdbDataset(small_train_dataset)\n", + "test_dataset = ImdbDataset(small_test_dataset)\n", "\n", - "ekfac_influence_model = EkfacInfluence(\n", - " patched_model,\n", - " progress=True,\n", + "train_dataloader = torch.utils.data.DataLoader(\n", + " train_dataset, batch_size=5, shuffle=True\n", ")\n", - "ekfac_influence_model = ekfac_influence_model.fit(train_dataloader)\n", - "# ekfac_influence_model.update_diag(train_dataloader)" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [], - "source": [ - "first_test_batch = next(iter(test_dataloader))\n", - "first_train_batch = next(iter(train_dataloader))" + "test_dataloader = torch.utils.data.DataLoader(test_dataset, batch_size=3, shuffle=True)" ] }, { "cell_type": "code", - "execution_count": 91, + "execution_count": 63, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/Users/fabio/miniconda3/envs/pydvl_env/lib/python3.9/site-packages/transformers/models/distilbert/modeling_distilbert.py:222: UserWarning: There is a performance drop because we have not yet implemented the batching rule for aten::masked_fill.Tensor. Please file us an issue on GitHub so that we can prioritize its implementation. (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/functorch/BatchedFallback.cpp:84.)\n", - " scores = scores.masked_fill(\n" + "K-FAC blocks: 100%|██████████| 2/2 [00:14<00:00, 7.43s/it]\n" ] } ], "source": [ - "influences_by_reg_value = ekfac_influence_model.explore_hessian_regularization(\n", - " *first_train_batch, regularization_values=[1e-9, 1e-7, 1e-5, 100]\n", - ")" + "model_logits = ModelLogitsWrapper(model)\n", + "model_logits.eval()\n", + "\n", + "ekfac_influence_model = EkfacInfluence(\n", + " model_logits,\n", + " progress=True,\n", + ")\n", + "ekfac_influence_model = ekfac_influence_model.fit(train_dataloader)" ] }, { "cell_type": "code", - "execution_count": 92, + "execution_count": 65, "metadata": {}, "outputs": [], "source": [ - "import pandas as pd\n", - "\n", - "cols = [\"reg_value\", \"layer_id\", \"mean_infl\"]\n", - "infl_df = pd.DataFrame(influences_by_reg_value, columns=cols)\n", - "for reg_value in influences_by_reg_value:\n", - " for layer_id, layer_influences in influences_by_reg_value[reg_value].items():\n", - " mean_infl = torch.mean(layer_influences, dim=0).detach().numpy()\n", - " infl_df = pd.concat(\n", - " [infl_df, pd.DataFrame([[reg_value, layer_id, mean_infl]], columns=cols)]\n", - " )" + "ekfac_influence_model.hessian_regularization = 1e-5" ] }, { "cell_type": "code", - "execution_count": 93, + "execution_count": 11, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Layer model.classifier\n", - "Reg value 1e-07\n", - "Pearson 0.9999999999982297\n", - "Spearman 0.9999999999999999\n", - "Reg value 1e-05\n", - "Pearson 0.9999999999198821\n", - "Spearman 0.9999999999999999\n", - "Reg value 100.0\n", - "Pearson 0.9890089520584947\n", - "Spearman 0.8999999999999998\n", - "Layer model.distilbert.transformer.layer.0.ffn.lin1\n", - "Reg value 1e-07\n", - "Pearson 0.9999619048425001\n", - "Spearman 0.9999999999999999\n", - "Reg value 1e-05\n", - "Pearson 0.9987266503875496\n", - "Spearman 0.9999999999999999\n", - "Reg value 100.0\n", - "Pearson 0.9774404060098946\n", - "Spearman 0.8999999999999998\n", - "Layer model.distilbert.transformer.layer.0.ffn.lin2\n", - "Reg value 1e-07\n", - "Pearson 0.9999336542986618\n", - "Spearman 0.9999999999999999\n", - "Reg value 1e-05\n", - "Pearson 0.9990544073004429\n", - "Spearman 0.9999999999999999\n", - "Reg value 100.0\n", - "Pearson 0.9976124885796617\n", - "Spearman 0.8999999999999998\n", - "Layer model.distilbert.transformer.layer.1.ffn.lin1\n", - "Reg value 1e-07\n", - "Pearson 0.9999533857529216\n", - "Spearman 0.9999999999999999\n", - "Reg value 1e-05\n", - "Pearson 0.9989482437845721\n", - "Spearman 0.9999999999999999\n", - "Reg value 100.0\n", - "Pearson 0.9964914007888204\n", - "Spearman 0.8999999999999998\n", - "Layer model.distilbert.transformer.layer.1.ffn.lin2\n", - "Reg value 1e-07\n", - "Pearson 0.9999916136560949\n", - "Spearman 0.9999999999999999\n", - "Reg value 1e-05\n", - "Pearson 0.9996741637855644\n", - "Spearman 0.9999999999999999\n", - "Reg value 100.0\n", - "Pearson 0.9989650038819474\n", - "Spearman 0.8999999999999998\n", - "Layer model.distilbert.transformer.layer.2.ffn.lin1\n", - "Reg value 1e-07\n", - "Pearson 0.9999850429340159\n", - "Spearman 0.8999999999999998\n", - "Reg value 1e-05\n", - "Pearson 0.9990860089585984\n", - "Spearman 0.9999999999999999\n", - "Reg value 100.0\n", - "Pearson 0.9973567654881873\n", - "Spearman 0.8999999999999998\n", - "Layer model.distilbert.transformer.layer.2.ffn.lin2\n", - "Reg value 1e-07\n", - "Pearson 0.9999891945547907\n", - "Spearman 0.9999999999999999\n", - "Reg value 1e-05\n", - "Pearson 0.999929272221139\n", - "Spearman 0.9999999999999999\n", - "Reg value 100.0\n", - "Pearson 0.999878601294667\n", - "Spearman 0.8999999999999998\n", - "Layer model.distilbert.transformer.layer.3.ffn.lin1\n", - "Reg value 1e-07\n", - "Pearson 0.9999743929131351\n", - "Spearman 0.9999999999999999\n", - "Reg value 1e-05\n", - "Pearson 0.9999964961833777\n", - "Spearman 0.9999999999999999\n", - "Reg value 100.0\n", - "Pearson 0.997409030920537\n", - "Spearman 0.8999999999999998\n", - "Layer model.distilbert.transformer.layer.3.ffn.lin2\n", - "Reg value 1e-07\n", - "Pearson 0.9999547452419874\n", - "Spearman 0.9999999999999999\n", - "Reg value 1e-05\n", - "Pearson 0.9988697971574463\n", - "Spearman 0.9999999999999999\n", - "Reg value 100.0\n", - "Pearson 0.989390370961956\n", - "Spearman 0.8999999999999998\n", - "Layer model.distilbert.transformer.layer.4.ffn.lin1\n", - "Reg value 1e-07\n", - "Pearson 0.9996088710756871\n", - "Spearman 0.8999999999999998\n", - "Reg value 1e-05\n", - "Pearson 0.9989685809131104\n", - "Spearman 0.9999999999999999\n", - "Reg value 100.0\n", - "Pearson 0.957268685281599\n", - "Spearman 0.8999999999999998\n", - "Layer model.distilbert.transformer.layer.4.ffn.lin2\n", - "Reg value 1e-07\n", - "Pearson 0.9993781838562021\n", - "Spearman 0.8999999999999998\n", - "Reg value 1e-05\n", - "Pearson 0.9999471200780226\n", - "Spearman 0.9999999999999999\n", - "Reg value 100.0\n", - "Pearson 0.9274370208460007\n", - "Spearman 0.8999999999999998\n", - "Layer model.distilbert.transformer.layer.5.ffn.lin1\n", - "Reg value 1e-07\n", - "Pearson 0.9999999510148485\n", - "Spearman 0.9999999999999999\n", - "Reg value 1e-05\n", - "Pearson 0.9999647286519302\n", - "Spearman 0.9999999999999999\n", - "Reg value 100.0\n", - "Pearson 0.9423928206889953\n", - "Spearman 0.7999999999999999\n", - "Layer model.distilbert.transformer.layer.5.ffn.lin2\n", - "Reg value 1e-07\n", - "Pearson 0.9999445978598823\n", - "Spearman 0.9999999999999999\n", - "Reg value 1e-05\n", - "Pearson 0.9884469308546968\n", - "Spearman 0.9999999999999999\n", - "Reg value 100.0\n", - "Pearson 0.9681394800845086\n", - "Spearman 0.7999999999999999\n", - "Layer model.pre_classifier\n", - "Reg value 1e-07\n", - "Pearson 0.9999999976033913\n", - "Spearman 0.9999999999999999\n", - "Reg value 1e-05\n", - "Pearson 0.9999813416700254\n", - "Spearman 0.9999999999999999\n", - "Reg value 100.0\n", - "Pearson 0.8385744133096472\n", - "Spearman 0.7999999999999999\n" - ] - } - ], + "outputs": [], "source": [ - "from scipy.stats import pearsonr, spearmanr\n", - "\n", - "for layer_id, group_df in infl_df.groupby(\"layer_id\"):\n", - " print(\"Layer\", layer_id)\n", - " for idx, mean_infl in enumerate(group_df[\"mean_infl\"]):\n", - " if idx == 0:\n", - " continue\n", - " print(\"Reg value\", group_df[\"reg_value\"].iloc[idx])\n", - " print(\n", - " \"Pearson\",\n", - " pearsonr(mean_infl, group_df[\"mean_infl\"].iloc[idx - 1]).statistic,\n", - " )\n", - " print(\n", - " \"Spearman\",\n", - " spearmanr(mean_infl, group_df[\"mean_infl\"].iloc[idx - 1]).statistic,\n", - " )" + "test_input, test_labels, test_text = next(iter(test_dataloader))\n", + "train_input, train_labels, train_text = next(iter(train_dataloader))" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ - "first_train_batch[1][0] = 1 - first_train_batch[1][0]" + "modified_train_labels = deepcopy(train_labels)\n", + "modified_train_labels[0] = 1 - train_labels[0]" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -521,126 +316,172 @@ ], "source": [ "ekfac_train_influences = ekfac_influence_model.influences(\n", - " *first_test_batch, *first_train_batch, mode=\"up\"\n", + " test_input,\n", + " test_labels,\n", + " train_input,\n", + " modified_train_labels,\n", ")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Analysis of influence values" + ] + }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor([[ 3.2714e+01, 2.1226e+02, -3.1409e+00, -8.7363e+01, 3.4665e+02],\n", - " [-2.8046e+02, 2.0380e+02, -6.3348e-01, -3.5344e+01, 1.5909e+02],\n", - " [-8.7853e-01, -4.7143e+00, 2.3439e-01, 1.0359e+00, -5.3958e+00]])" + "tensor([-4367.9858, 1003.2576, 751.8049, -403.0711, 79.2274])" ] }, - "execution_count": 15, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "ekfac_train_influences" + "torch.mean(ekfac_train_influences, axis=0)" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor([-82.8759, 137.1154, -1.1800, -40.5570, 166.7804])" + "tensor([[-2.5754e+03, 3.5468e+02, 1.4799e+02, -1.9528e+02, 3.2583e+01],\n", + " [-1.1582e+00, -4.7990e+01, -2.4654e+01, 1.5628e+01, -8.8081e-01],\n", + " [-1.0527e+04, 2.7031e+03, 2.1321e+03, -1.0296e+03, 2.0598e+02]])" ] }, - "execution_count": 16, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "torch.mean(ekfac_train_influences, axis=0)" + "ekfac_train_influences" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { + "text/html": [ + "Yeh, I know -- you're quivering with excitement. Well, *The Secret Lives of Dentists* will not upset your expectations: it's solidly made but essentially unimaginative, truthful but dull. It concerns the story of a married couple who happen to be dentists and who share the same practice (already a recipe for trouble: if it wasn't for our separate work-lives, we'd all ditch our spouses out of sheer irritation). Campbell Scott, whose mustache and demeanor don't recall Everyman so much as Ned Flanders from *The Simpsons*, is the mild-mannered, uber-Dad husband, and Hope Davis is the bored-stiff housewife who channels her frustrations into amateur opera. One night, as Dad & the daughters attend one of Davis' performances, he discovers that his wife is channeling her frustrations into more than just singing: he witnesses his wife kissing and flirting with the director of opera. (One nice touch: we never see the opera-director's face.) Dreading the prospect of instituting the proceedings for separation, divorce, and custody hearings -- profitable only to the lawyers -- Scott chooses to pretend ignorance of his wife's indiscretions." + ], "text/plain": [ - "tensor(32.7142)" + "" ] }, - "execution_count": 17, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "The film has virtues, mostly having to do with verisimilitude. However, it's dragged down from greatness by its insistence on trendy distractions, which culminate in a long scene where a horrible five-day stomach flu makes the rounds in the household. We must endure pointless fantasy sequences, initiated by the imaginary ringleader Leary. Whose existence, by the way, is finally reminiscent of the Brad Pitt character in *Fight Club*. And this finally drives home the film's other big flaw: lack of originality. In this review, I realize it's been far too easy to reference many other films. Granted, this film is an improvement on most of them, but still. *The Secret Lives of Dentists* is worth seeing, but don't get too excited about it. (Not that you were all that excited, anyway. I guess.)" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "ekfac_train_influences[0][0]" + "train_sentence_idx = 3\n", + "display(HTML(train_text[train_sentence_idx].split(\"
\")[0]))\n", + "display(HTML(train_text[train_sentence_idx].split(\"
\")[-1]))" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { + "text/html": [ + "\"Murder Over New York\" is fun, but not as good as most of the other Fox Chans. This film would have been better named, \"Charlie Chan in New York\", the film's working title. This is Toler's chance to play Chan in the Big Apple. There is a lot to like here, though, including guest star Shemp Howard of the Three Stooges." + ], "text/plain": [ - "tensor(100.2229)" + "" ] }, - "execution_count": 18, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "torch.mean(ekfac_train_influences[0])" + "test_sentence_idx = 2\n", + "display(HTML(test_text[test_sentence_idx].split(\"
\")[0]))" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 18, "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "torch.Size([3, 5])" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "Positive probability: 14.639034867286682%\n", + "Negative probability: 85.36096215248108%\n" + ] } ], "source": [ - "ekfac_train_influences.shape" + "print_sentiment_preds(model_logits, train_input[train_sentence_idx])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Influence functions by layer" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 66, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/fabio/miniconda3/envs/pydvl_env/lib/python3.9/site-packages/transformers/models/distilbert/modeling_distilbert.py:222: UserWarning: There is a performance drop because we have not yet implemented the batching rule for aten::masked_fill.Tensor. Please file us an issue on GitHub so that we can prioritize its implementation. (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/functorch/BatchedFallback.cpp:84.)\n", + " scores = scores.masked_fill(\n" + ] + } + ], "source": [ "ekfac_train_influences = ekfac_influence_model.influences_by_layer(\n", - " *first_test_batch, *first_train_batch, mode=\"up\"\n", + " test_input,\n", + " test_labels,\n", + " train_input,\n", + " modified_train_labels,\n", ")" ] }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 79, "metadata": {}, "outputs": [], "source": [ @@ -651,7 +492,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -663,22 +504,22 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 27, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -692,6 +533,150 @@ "\n", "plt.plot(infl_across_layers)" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Appendix" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Choosing the Hessian regularization value" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "from scipy.stats import pearsonr, spearmanr" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "K-FAC blocks: 100%|██████████| 2/2 [00:11<00:00, 5.78s/it]\n" + ] + } + ], + "source": [ + "model_logits = ModelLogitsWrapper(model)\n", + "model_logits.eval()\n", + "\n", + "ekfac_influence_model = EkfacInfluence(\n", + " model_logits,\n", + " progress=True,\n", + ")\n", + "ekfac_influence_model = ekfac_influence_model.fit(train_dataloader)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "first_train_batch = next(iter(train_dataloader))" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/fabio/miniconda3/envs/pydvl_env/lib/python3.9/site-packages/transformers/models/distilbert/modeling_distilbert.py:222: UserWarning: There is a performance drop because we have not yet implemented the batching rule for aten::masked_fill.Tensor. Please file us an issue on GitHub so that we can prioritize its implementation. (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/functorch/BatchedFallback.cpp:84.)\n", + " scores = scores.masked_fill(\n" + ] + } + ], + "source": [ + "influences_by_reg_value = ekfac_influence_model.explore_hessian_regularization(\n", + " first_train_batch[0],\n", + " first_train_batch[1],\n", + " regularization_values=[1e-9, 1e-7, 1e-5, 100],\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "cols = [\"reg_value\", \"layer_id\", \"mean_infl\"]\n", + "infl_df = pd.DataFrame(influences_by_reg_value, columns=cols)\n", + "for reg_value in influences_by_reg_value:\n", + " for layer_id, layer_influences in influences_by_reg_value[reg_value].items():\n", + " mean_infl = torch.mean(layer_influences, dim=0).detach().numpy()\n", + " infl_df = pd.concat(\n", + " [infl_df, pd.DataFrame([[reg_value, layer_id, mean_infl]], columns=cols)]\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "result_corr = {}\n", + "for layer_id, group_df in infl_df.groupby(\"layer_id\"):\n", + " result_corr[layer_id + \"_pearson\"] = {}\n", + " result_corr[layer_id + \"_spearman\"] = {}\n", + " for idx, mean_infl in enumerate(group_df[\"mean_infl\"]):\n", + " if idx == 0:\n", + " continue\n", + " reg_value_diff = f\"Reg: {group_df['reg_value'].iloc[idx-1]} -> {group_df['reg_value'].iloc[idx]}\"\n", + " pearson = pearsonr(mean_infl, group_df[\"mean_infl\"].iloc[idx - 1]).statistic\n", + " spearman = spearmanr(mean_infl, group_df[\"mean_infl\"].iloc[idx - 1]).statistic\n", + " result_corr[layer_id + \"_pearson\"].update({f\"{reg_value_diff}\": pearson})\n", + " result_corr[layer_id + \"_spearman\"].update({f\"{reg_value_diff}\": spearman})\n", + "result_df = pd.DataFrame(result_corr).T" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 6))\n", + "plt.imshow(result_df, cmap=\"coolwarm_r\", aspect=\"auto\")\n", + "plt.xticks(range(result_df.shape[1]), result_df.columns, rotation=45)\n", + "plt.yticks(range(result_df.shape[0]), strip_param_names(result_df.index))\n", + "plt.colorbar(label=\"Correlation Value\") # Add label to the colorbar\n", + "plt.title(\"Correlation Heatmap\")\n", + "plt.xlabel(\"Regularization Values\")\n", + "plt.ylabel(\"Layer ID\")\n", + "plt.show()" + ] } ], "metadata": { diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index 98cd5fa65..93b0813df 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -1035,7 +1035,9 @@ def get_kfac_blocks( hooks.append(module.register_forward_hook(layer_input_hook)) hooks.append(module.register_full_backward_hook(layer_grad_hook)) - for x, _ in tqdm(data, disable=not self.progress, desc="K-FAC blocks"): + for x, *_ in tqdm( + data, disable=not self.progress, desc="K-FAC blocks - batche progress" + ): data_len += x.shape[0] pred_y = self.model(x) loss = empirical_cross_entropy_loss_fn(pred_y) @@ -1159,7 +1161,9 @@ def update_diag( hooks.append(module.register_forward_hook(input_hook)) hooks.append(module.register_full_backward_hook(grad_hook)) - for x, _ in tqdm(data, disable=not self.progress, desc="Update Diagonal"): + for x, _ in tqdm( + data, disable=not self.progress, desc="Update Diagonal - batch progress" + ): data_len += x.shape[0] pred_y = self.model(x) loss = empirical_cross_entropy_loss_fn(pred_y) From bfcbad0cfdd64c20295442c40e1a652171a470ca Mon Sep 17 00:00:00 2001 From: Kristof Schroeder Date: Tue, 2 Jan 2024 11:48:43 +0100 Subject: [PATCH 21/87] Fix bug, due to calling tolist on an object numpy array containing an array chunk --- src/pydvl/influence/influence_calculator.py | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/pydvl/influence/influence_calculator.py b/src/pydvl/influence/influence_calculator.py index 7164edf1d..dd2b4383f 100644 --- a/src/pydvl/influence/influence_calculator.py +++ b/src/pydvl/influence/influence_calculator.py @@ -288,8 +288,8 @@ def func(x_numpy: NDArray, y_numpy: NDArray, model: InfluenceFunctionModel): chunk_shape = (chunk_size, self.n_parameters) chunk_array = da.from_delayed( delayed(func)( - x_chunk.squeeze().tolist(), - y_chunk.squeeze().tolist(), + x_chunk.squeeze()[()], + y_chunk.squeeze()[()], self.influence_function_model, ), dtype=x.dtype, @@ -400,10 +400,10 @@ def func( block_array = da.from_delayed( delayed(func)( - x_test_chunk.squeeze().tolist(), - y_test_chunk.squeeze().tolist(), - x_chunk.squeeze().tolist(), - y_chunk.squeeze().tolist(), + x_test_chunk.squeeze()[()], + y_test_chunk.squeeze()[()], + x_chunk.squeeze()[()], + y_chunk.squeeze()[()], self.influence_function_model, ), shape=block_shape, @@ -506,9 +506,9 @@ def func( block_array = da.from_delayed( delayed(func)( - z_test_chunk.squeeze().tolist(), - x_chunk.squeeze().tolist(), - y_chunk.squeeze().tolist(), + z_test_chunk.squeeze()[()], + x_chunk.squeeze()[()], + y_chunk.squeeze()[()], self.influence_function_model, ), shape=block_shape, From ff3ae7b957f7e09849014d3b6571769fc16d7876 Mon Sep 17 00:00:00 2001 From: Kristof Schroeder Date: Tue, 2 Jan 2024 12:06:29 +0100 Subject: [PATCH 22/87] Update CHANGELOG --- CHANGELOG.md | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index b3e09e30d..efd1a1b6d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,12 @@ # Changelog +## Unreleased + +### Fixed + +- Bug in using `DaskInfluenceCalcualator` with `TorchnumpyConverter` + for single dimensional arrays [PR #485](https://github.com/aai-institute/pyDVL/pull/485) + ## 0.8.0 - 🆕 New interfaces, scaling computation, bug fixes and improvements 🎁 ### Added From b3607dce7102e7442fbbd64edfbb7f7894384ba3 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Tue, 2 Jan 2024 22:15:41 +0100 Subject: [PATCH 23/87] WIP change notebook name and improvements --- ...ynb => influence_sentiment_analysis.ipynb} | 740 +++++++++++++++--- .../torch/influence_function_model.py | 2 +- 2 files changed, 623 insertions(+), 119 deletions(-) rename notebooks/{influence_distilbert.ipynb => influence_sentiment_analysis.ipynb} (51%) diff --git a/notebooks/influence_distilbert.ipynb b/notebooks/influence_sentiment_analysis.ipynb similarity index 51% rename from notebooks/influence_distilbert.ipynb rename to notebooks/influence_sentiment_analysis.ipynb index 3947fe762..953fcd0bd 100644 --- a/notebooks/influence_distilbert.ipynb +++ b/notebooks/influence_sentiment_analysis.ipynb @@ -11,23 +11,71 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Imports" + "This notebooks showcases the use of influence functions for large language models. In particular, we will focus on sentiment analysis using the [IMDB dataset](https://ai.stanford.edu/~amaas/data/sentiment/) and a [BERT](https://arxiv.org/abs/1810.04805) model fine-tuned on it.\n", + "\n", + "Not all the methods for influence function calculation can scale to large models and datasets. In this notebook we will use the [Kronecker-Factored Approximate Curvature](https://arxiv.org/abs/1503.05671) method, which is the only one that can scale to current state-of-the-art language models.\n", + "\n", + "The notebook is structured as follows:\n", + "- [Setup](#Setup) imports the required libraries and download the dataset and the model.\n", + "- [Sentiment analysis](#Sentiment-analysis) loads the model and the dataset and we analyse a few examples of sentiment analysis on some sentences. This serves to understand the model and the problem we are dealing with.\n", + "- [Model and data preparation](#Model-and-data-preparation) prepares the model and the dataset for the influence function calculation. In particular, here we assign all the linear layers to require gradients and wrap the model to return only the logits (and not the loss or attention masks).\n", + "- [Influence function computation](#Influence-function-computation): shows how to calculate the influence function for a few test and train examples.\n", + "- [Analysis of influence values](#Analysis-of-influence-values): here we analyse the influence values to understand how the model works and how it is affected by corruption in the training data. Here we also corrupt some of the training examples to see how the influence function changes.\n", + "- [Influence functions by layer](#Influence-functions-by-layer): since ekfac is based on a block diagonal approximation of the Fisher information matrix, we can compute the influence function separately for each layer of the neural network. In this section we show how to do that and how to analyse the results.\n", + "\n", + "Finally, in the [Appendix](#Appendix) we show how to select the Hessian regularization parameter to obtain the best possible influence function approximation." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's start by importing the required libraries. If not already installed, you can install them with `pip install -r requirements-notebooks.txt`." ] }, { "cell_type": "code", - "execution_count": 72, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/fabio/miniconda3/envs/pydvl_env/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + } + ], "source": [ "from datasets import load_dataset\n", "import torch\n", + "from sklearn.metrics import f1_score\n", "from typing import Sequence\n", "from pydvl.influence.torch import EkfacInfluence\n", "import torch.nn.functional as F\n", "from transformers import AutoTokenizer, AutoModelForSequenceClassification\n", "from copy import deepcopy\n", - "from IPython.display import HTML, display" + "from IPython.display import HTML, display\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "seed = 42\n", + "torch.manual_seed(seed)\n", + "torch.cuda.manual_seed(seed)" ] }, { @@ -37,9 +85,16 @@ "## Sentiment Analysis" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Sentiment analysis is the task of classifying a sentence as having a positive or negative sentiment. For example, the sentence \"I love this movie\" has a positive sentiment, while \"I hate this movie\" has a negative sentiment. In this notebook we will use the IMDB dataset, which contains 50,000 movie reviews, each labelled as positive or negative. The dataset is split into 25,000 reviews for training and 25,000 reviews for testing. The dataset is balanced, meaning that there are the same number of positive and negative reviews in the training and test set." + ] + }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -47,24 +102,85 @@ "output_type": "stream", "text": [ "Found cached dataset imdb (/Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0)\n", - "100%|██████████| 3/3 [00:00<00:00, 428.63it/s]\n", - "Loading cached shuffled indices for dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-9c48ce5d173413c7.arrow\n", - "Loading cached shuffled indices for dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-d00218895ddb9236.arrow\n" + "100%|██████████| 3/3 [00:00<00:00, 528.25it/s]\n" + ] + } + ], + "source": [ + "imdb = load_dataset(\"imdb\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's print an example of review and its label" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Here is a sample review with label 0: \n", + "\n" ] + }, + { + "data": { + "text/html": [ + "Without wishing to be a killjoy, Brad Sykes is responsible for at least two of the most dull and clichéd films i've ever seen - this being one of them, and Camp Blood being another. " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "I bought this for £1, but remember, you can't put a price on 71 minutes of your life. You'd do well to avoid this turkey, even at a bargain basement price." + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "imdb = load_dataset(\"imdb\")\n", + "sample_review = imdb[\"train\"].select([24])\n", "\n", - "small_train_dataset = (\n", - " imdb[\"train\"].shuffle(seed=42).select([i for i in list(range(10))])\n", - ")\n", - "small_test_dataset = imdb[\"test\"].shuffle(seed=4).select([i for i in list(range(5))])" + "print(f\"Here is a sample review with label {sample_review['label'][0]}: \\n\")\n", + "\n", + "display(HTML(sample_review[\"text\"][0].split(\"
\")[0]))\n", + "display(HTML(sample_review[\"text\"][0].split(\"
\")[-1]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The review seems quite negative, so label 0 seems to be associated to negative sentiment." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The model we will use is a BERT model fine-tuned on the IMDB dataset. BERT is a large language model that has been pre-trained on a large corpus of text. The model was fine-tuned on the IMDB dataset using by AssemblyAI and is available on the HuggingFace model hub. We will also load its tokenizer, which is used to convert sentences into tokens that can be fed to the model." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -74,41 +190,170 @@ ")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Even if the model is trained on movie reviews, it can be used to classify any sentence as positive or negative. Let's try it on a simple example created by us." + ] + }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "example_phrase = (\n", + " \"Pydvl is the best data valuation library, and it is fully open-source!\"\n", + ")\n", + "\n", + "tokenized_example = tokenizer(\n", + " [example_phrase],\n", + " return_tensors=\"pt\",\n", + " padding=True,\n", + " truncation=True,\n", + ")\n", + "\n", + "tokenized_example_input_ids, tokenized_example_attention_mask = (\n", + " tokenized_example.input_ids,\n", + " tokenized_example.attention_mask,\n", + ")\n", + "\n", + "model_output = model(\n", + " input_ids=tokenized_example_input_ids,\n", + " attention_mask=tokenized_example_attention_mask,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The model output is a `SequenceClassificationOutput` object, which contains the logits and other information." + ] + }, + { + "cell_type": "code", + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Positive probability: 99.57591891288757%\n", - "Negative probability: 0.42408257722854614%\n" + "Model Output:\n", + " SequenceClassifierOutput(loss=None, logits=tensor([[-2.6237, 2.8350]], grad_fn=), hidden_states=None, attentions=None)\n" ] } ], "source": [ - "tokenized_segments = tokenizer(\n", - " [\"Pydvl is the best data valuation library, and it is fully open-source!\"],\n", - " return_tensors=\"pt\",\n", - " padding=True,\n", - " truncation=True,\n", - ")\n", - "tokenized_segments_input_ids, tokenized_segments_attention_mask = (\n", - " tokenized_segments.input_ids,\n", - " tokenized_segments.attention_mask,\n", - ")\n", + "print(\"Model Output:\\n\", model_output)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For calculating probabilities, and for the influence function calculation, we only need the logits. We then use the softmax function to convert the logits into probabilities." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ "model_predictions = F.softmax(\n", " model(\n", - " input_ids=tokenized_segments_input_ids,\n", - " attention_mask=tokenized_segments_attention_mask,\n", + " input_ids=tokenized_example_input_ids,\n", + " attention_mask=tokenized_example_attention_mask,\n", " )[\"logits\"],\n", " dim=1,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "model_predictions thus contains the probabilities for each class. In this case, the model is quite confident that the sentence has a positive sentiment, which is correct." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Positive probability: 99.6%\n", + "Negative probability: 0.4%\n" + ] + } + ], + "source": [ + "print(\n", + " \"Positive probability: \" + str(round(model_predictions[0][1].item(), 3) * 100) + \"%\"\n", ")\n", + "print(\n", + " \"Negative probability: \" + str(round(model_predictions[0][0].item(), 3) * 100) + \"%\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's examine the model's f1 score on a small subset of the test set." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading cached shuffled indices for dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-c1eaa46e94dfbfd3.arrow\n", + "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-c5cc0d728c27151c.arrow\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "F1 Score: 0.955\n" + ] + } + ], + "source": [ + "sample_test_set = imdb[\"test\"].shuffle(seed=seed).select(range(50))\n", + "sample_test_set = sample_test_set.map(\n", + " lambda example: tokenizer(example[\"text\"], truncation=True, padding=\"max_length\"),\n", + " batched=True,\n", + ")\n", + "sample_test_set.set_format(\"torch\", columns=[\"input_ids\", \"attention_mask\", \"label\"])\n", + "model.eval()\n", + "with torch.no_grad():\n", + " logits = model(\n", + " input_ids=sample_test_set[\"input_ids\"],\n", + " attention_mask=sample_test_set[\"attention_mask\"],\n", + " )[0]\n", + " predictions = torch.argmax(logits, dim=1)\n", "\n", - "print(\"Positive probability: \" + str(model_predictions[0][1].item() * 100) + \"%\")\n", - "print(\"Negative probability: \" + str(model_predictions[0][0].item() * 100) + \"%\")" + "f1_score_value = f1_score(sample_test_set[\"label\"], predictions)\n", + "print(f\"F1 Score: {round(f1_score_value, 3)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "F1 score is quite good, but not perfect. Anyway, it is good enough for our purposes." ] }, { @@ -118,13 +363,27 @@ "## Model and Data Preparation" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this section we will define several helper function and classes that will be used in the rest of the notebook. " + ] + }, { "cell_type": "code", - "execution_count": 76, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "class ImdbDataset(torch.utils.data.Dataset):\n", + " \"\"\"\n", + " A PyTorch Dataset that takes in an HuggingFace Dataset object and tokenizes it.\n", + " The objects returned by __getitem__ are PyTorch tensors, with x being a tuple of\n", + " (input_ids, attention_mask), ready to be fed into a model, and y being the label.\n", + " It also returns the original text, for printing and debugging purposes.\n", + " \"\"\"\n", + "\n", " def __init__(self, dataset):\n", " self.tokenized_ds = dataset.map(self.preprocess_function, batched=True)\n", " self.encodings = self.tokenized_ds[\"input_ids\"]\n", @@ -145,6 +404,11 @@ "\n", "\n", "class ModelLogitsWrapper(torch.nn.Module):\n", + " \"\"\"\n", + " A wrapper around a PyTorch model that returns only the logits and not the loss or\n", + " the attention mask.\n", + " \"\"\"\n", + "\n", " def __init__(self, model):\n", " super().__init__()\n", " self.model = model\n", @@ -153,13 +417,34 @@ " return self.model(x[:, 0], x[:, 1])[\"logits\"]\n", "\n", "\n", - "def print_sentiment_preds(model: ModelLogitsWrapper, model_input: torch.Tensor):\n", + "def print_sentiment_preds(\n", + " model: ModelLogitsWrapper, model_input: torch.Tensor, true_label: int\n", + "):\n", + " \"\"\"\n", + " Prints the sentiment predictions in a human-readable format given a model and an\n", + " input. It also prints the true label.\n", + " \"\"\"\n", " model_predictions = F.softmax(model(model_input.unsqueeze(0)), dim=1)\n", - " print(\"Positive probability: \" + str(model_predictions[0][1].item() * 100) + \"%\")\n", - " print(\"Negative probability: \" + str(model_predictions[0][0].item() * 100) + \"%\")\n", + " print(\n", + " \"Positive probability: \"\n", + " + str(round(model_predictions[0][1].item(), 3) * 100)\n", + " + \"%\"\n", + " )\n", + " print(\n", + " \"Negative probability: \"\n", + " + str(round(model_predictions[0][0].item(), 3) * 100)\n", + " + \"%\"\n", + " )\n", + "\n", + " true_label = \"Positive\" if true_label == 1 else \"Negative\"\n", + " print(f\"True label: {true_label} \\n\")\n", "\n", "\n", "def strip_param_names(param_names: Sequence[str]):\n", + " \"\"\"\n", + " Helper function that strips the parameter names of the model and the transformer,\n", + " so that they can be printed and compared more easily.\n", + " \"\"\"\n", " stripped_param_names = []\n", " for name in param_names:\n", " name = name.replace(\"model.\", \"\")\n", @@ -169,9 +454,16 @@ " return stripped_param_names" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Importantly, we will need to assign all the linear layers to require gradients, so that we can compute the influence function with respect to them. Keep in mind that the current implementation of Ekfac only supports linear layers, so if any other type of layer in the model requires gradients, the influence function calculation will return a `NotImplementedError`." + ] + }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -190,9 +482,16 @@ " param.requires_grad = True" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nevertheless, linear layers constitute a large fraction of the parameters of the model, so our analysis still holds a lot of information about the full model." + ] + }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -201,7 +500,7 @@ "text": [ "Total parameters: 66.96 millions\n", "Parameters requiring gradients: 28.93 millions\n", - "Ratio: 43.20%\n" + "Ratio of Linear over other layer types: 43.20%\n" ] } ], @@ -213,7 +512,11 @@ "\n", "print(\"Total parameters: {:.2f} millions\".format(total_params))\n", "print(\"Parameters requiring gradients: {:.2f} millions\".format(params_requiring_grad))\n", - "print(\"Ratio: {:.2f}%\".format((params_requiring_grad / total_params) * 100))" + "print(\n", + " \"Ratio of Linear over other layer types: {:.2f}%\".format(\n", + " (params_requiring_grad / total_params) * 100\n", + " )\n", + ")" ] }, { @@ -223,66 +526,110 @@ "## Influence function computation" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We are now ready to compute the influence function for a few test and train examples. Let's start by selecting a subset of the full training and testing dataset and wrapping them in a `DataLoader` object, so that we can easily batch the examples." + ] + }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-2be1c3a446bd7743.arrow\n", - "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-b0ad78d634cd6710.arrow\n" + "Loading cached shuffled indices for dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-9c48ce5d173413c7.arrow\n", + "Loading cached shuffled indices for dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-c1eaa46e94dfbfd3.arrow\n", + "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-b86b62990cd870b5.arrow\n", + "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-74aeeb1b0543e07c.arrow\n" ] } ], "source": [ + "NUM_TRAIN_EXAMPLES = 100\n", + "NUM_TEST_EXAMPLES = 100\n", + "\n", + "small_train_dataset = (\n", + " imdb[\"train\"]\n", + " .shuffle(seed=seed)\n", + " .select([i for i in list(range(NUM_TRAIN_EXAMPLES))])\n", + ")\n", + "small_test_dataset = (\n", + " imdb[\"test\"].shuffle(seed=seed).select([i for i in list(range(NUM_TEST_EXAMPLES))])\n", + ")\n", + "\n", "train_dataset = ImdbDataset(small_train_dataset)\n", "test_dataset = ImdbDataset(small_test_dataset)\n", "\n", "train_dataloader = torch.utils.data.DataLoader(\n", - " train_dataset, batch_size=5, shuffle=True\n", + " train_dataset, batch_size=7, shuffle=True\n", ")\n", - "test_dataloader = torch.utils.data.DataLoader(test_dataset, batch_size=3, shuffle=True)" + "test_dataloader = torch.utils.data.DataLoader(test_dataset, batch_size=5, shuffle=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For influence computation, we will need to take the model in evaluation mode, so that no dropout or batch normalization is applied. Then, we can fit the Ekfac representation." ] }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "K-FAC blocks: 100%|██████████| 2/2 [00:14<00:00, 7.43s/it]\n" + "K-FAC blocks - batch progress: 100%|██████████| 15/15 [01:45<00:00, 7.04s/it]\n" ] } ], "source": [ - "model_logits = ModelLogitsWrapper(model)\n", - "model_logits.eval()\n", + "wrapped_model = ModelLogitsWrapper(model)\n", + "wrapped_model.eval()\n", "\n", "ekfac_influence_model = EkfacInfluence(\n", - " model_logits,\n", + " wrapped_model,\n", " progress=True,\n", ")\n", "ekfac_influence_model = ekfac_influence_model.fit(train_dataloader)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And the approximate Hessian is thus computed. Considering that the model has almost 30 million parameters requiring gradients, this was very fast! Of course, we should keep in mind that this Hessian is computed using only a very small fraction (~0.4%) of the training data, and for a better approximation we should use a larger subset.\n", + "\n", + "Before continuing, we need to set the Hessian regularization parameter to an appropriate value. A way to decide which value is better can be found in the [Appendix](#Appendix). Here, we will just set it to 1e-5." + ] + }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "ekfac_influence_model.hessian_regularization = 1e-5" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will calculate the influence of the first batch of training data over the first batch of test data. This because influence functions are very expensive to compute, and to keep the computation time reasonable we will only compute the influence of a few examples." + ] + }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -291,18 +638,15 @@ ] }, { - "cell_type": "code", - "execution_count": 12, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "modified_train_labels = deepcopy(train_labels)\n", - "modified_train_labels[0] = 1 - train_labels[0]" + "And let's finally compute the influence function values" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -319,7 +663,7 @@ " test_input,\n", " test_labels,\n", " train_input,\n", - " modified_train_labels,\n", + " train_labels,\n", ")" ] }, @@ -330,57 +674,126 @@ "## Analysis of influence values" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Negative influence training examples" + ] + }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor([-4367.9858, 1003.2576, 751.8049, -403.0711, 79.2274])" + "array([ 130, 70, 93, -3688, 66, 9, 32])" ] }, - "execution_count": 14, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "torch.mean(ekfac_train_influences, axis=0)" + "torch.mean(ekfac_train_influences, axis=0).numpy().astype(int)" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Positive probability: 18.099999999999998%\n", + "Negative probability: 81.89999999999999%\n", + "True label: Positive \n", + "\n", + "Sentence:\n" + ] + }, + { + "data": { + "text/html": [ + "In the process of trying to establish the audiences' empathy with Jake Roedel (Tobey Maguire) the filmmakers slander the North and the Jayhawkers. Missouri never withdrew from the Union and the Union Army was not an invading force. The Southerners fought for State's Rights: the right to own slaves, elect crooked legislatures and judges, and employ a political spoils system. There's nothing noble in that. The Missourians could have easily traveled east and joined the Confederate Army.

It seems to me that the story has nothing to do with ambiguity. When Jake leaves the Bushwhackers, it's not because he saw error in his way, he certainly doesn't give himself over to the virtue of the cause of abolition." + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "train_sentence_idx = 3\n", + "\n", + "print_sentiment_preds(\n", + " wrapped_model,\n", + " train_input[train_sentence_idx],\n", + " train_labels[train_sentence_idx].item(),\n", + ")\n", + "\n", + "print(\"Sentence:\")\n", + "display(HTML(train_text[train_sentence_idx]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Highest influence on test examples" + ] + }, + { + "cell_type": "code", + "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "tensor([[-2.5754e+03, 3.5468e+02, 1.4799e+02, -1.9528e+02, 3.2583e+01],\n", - " [-1.1582e+00, -4.7990e+01, -2.4654e+01, 1.5628e+01, -8.8081e-01],\n", - " [-1.0527e+04, 2.7031e+03, 2.1321e+03, -1.0296e+03, 2.0598e+02]])" + "array([[ 35, 23, 15, -322, 11, 0, 9],\n", + " [ -147, -11, -30, 918, -46, 111, 2],\n", + " [ -4, 2, -3, 81, 0, 8, 0],\n", + " [ 0, 0, 0, 4, 0, 0, 0],\n", + " [ 770, 336, 487, -19124, 367, -71, 151]])" ] }, - "execution_count": 15, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "ekfac_train_influences" + "ekfac_train_influences.numpy().astype(int)" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 67, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Positive probability: 39.6%\n", + "Negative probability: 60.4%\n", + "True label: Negative \n", + "\n", + "Sentence:\n" + ] + }, { "data": { "text/html": [ - "Yeh, I know -- you're quivering with excitement. Well, *The Secret Lives of Dentists* will not upset your expectations: it's solidly made but essentially unimaginative, truthful but dull. It concerns the story of a married couple who happen to be dentists and who share the same practice (already a recipe for trouble: if it wasn't for our separate work-lives, we'd all ditch our spouses out of sheer irritation). Campbell Scott, whose mustache and demeanor don't recall Everyman so much as Ned Flanders from *The Simpsons*, is the mild-mannered, uber-Dad husband, and Hope Davis is the bored-stiff housewife who channels her frustrations into amateur opera. One night, as Dad & the daughters attend one of Davis' performances, he discovers that his wife is channeling her frustrations into more than just singing: he witnesses his wife kissing and flirting with the director of opera. (One nice touch: we never see the opera-director's face.) Dreading the prospect of instituting the proceedings for separation, divorce, and custody hearings -- profitable only to the lawyers -- Scott chooses to pretend ignorance of his wife's indiscretions." + "\"An astronaut (Michael Emmet) dies while returning from a mission and his body is recovered by the military. The base where the dead astronaut is taken to becomes the scene of a bizarre invasion plan from outer space. Alien embryos inside the dead astronaut resurrect the corpse and begin a terrifying assault on the military staff in the hopes of conquering the world,\" according to the DVD sleeve's synopsis.

A Roger Corman \"American International\" production. The man who fell to Earth impregnated, Mr. Emmet (as John Corcoran), does all right. Angela Greene is his pretty conflicted fiancée. And, Ed Nelson (as Dave Randall) is featured as prominently. With a bigger budget, better opening, and a re-write for crisper characterizations, this could have been something approaching classic 1950s science fiction.

*** Night of the Blood Beast (1958) Bernard L. Kowalski, Roger Corman ~ Michael Emmet, Angela Greene, Ed Nelson" ], "text/plain": [ "" @@ -388,11 +801,39 @@ }, "metadata": {}, "output_type": "display_data" + } + ], + "source": [ + "test_sentence_idx = 4\n", + "\n", + "print_sentiment_preds(\n", + " wrapped_model, test_input[test_sentence_idx], test_labels[test_sentence_idx].item()\n", + ")\n", + "\n", + "print(\"Sentence:\")\n", + "display(HTML(test_text[test_sentence_idx]))" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Positive probability: 18.099999999999998%\n", + "Negative probability: 81.89999999999999%\n", + "True label: Positive \n", + "\n", + "Sentence:\n" + ] }, { "data": { "text/html": [ - "The film has virtues, mostly having to do with verisimilitude. However, it's dragged down from greatness by its insistence on trendy distractions, which culminate in a long scene where a horrible five-day stomach flu makes the rounds in the household. We must endure pointless fantasy sequences, initiated by the imaginary ringleader Leary. Whose existence, by the way, is finally reminiscent of the Brad Pitt character in *Fight Club*. And this finally drives home the film's other big flaw: lack of originality. In this review, I realize it's been far too easy to reference many other films. Granted, this film is an improvement on most of them, but still. *The Secret Lives of Dentists* is worth seeing, but don't get too excited about it. (Not that you were all that excited, anyway. I guess.)" + "In the process of trying to establish the audiences' empathy with Jake Roedel (Tobey Maguire) the filmmakers slander the North and the Jayhawkers. Missouri never withdrew from the Union and the Union Army was not an invading force. The Southerners fought for State's Rights: the right to own slaves, elect crooked legislatures and judges, and employ a political spoils system. There's nothing noble in that. The Missourians could have easily traveled east and joined the Confederate Army.

It seems to me that the story has nothing to do with ambiguity. When Jake leaves the Bushwhackers, it's not because he saw error in his way, he certainly doesn't give himself over to the virtue of the cause of abolition." ], "text/plain": [ "" @@ -404,49 +845,88 @@ ], "source": [ "train_sentence_idx = 3\n", - "display(HTML(train_text[train_sentence_idx].split(\"
\")[0]))\n", - "display(HTML(train_text[train_sentence_idx].split(\"
\")[-1]))" + "\n", + "print_sentiment_preds(\n", + " wrapped_model,\n", + " train_input[train_sentence_idx],\n", + " train_labels[train_sentence_idx].item(),\n", + ")\n", + "\n", + "print(\"Sentence:\")\n", + "display(HTML(train_text[train_sentence_idx]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Influence of corrupted training examples" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What happens if we corrupt the training data? Let's try to corrupt the same training example we used before, and see how the influence function changes." ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "modified_train_labels = deepcopy(train_labels)\n", + "modified_train_labels = 1 - train_labels\n", + "\n", + "corrupted_ekfac_train_influences = ekfac_influence_model.influences(\n", + " test_input,\n", + " test_labels,\n", + " train_input,\n", + " modified_train_labels,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 27, "metadata": {}, "outputs": [ { "data": { - "text/html": [ - "\"Murder Over New York\" is fun, but not as good as most of the other Fox Chans. This film would have been better named, \"Charlie Chan in New York\", the film's working title. This is Toler's chance to play Chan in the Big Apple. There is a lot to like here, though, including guest star Shemp Howard of the Three Stooges." - ], "text/plain": [ - "" + "tensor([ 130.7261, 70.4297, 93.8776, -3688.6289, 66.4447, 9.6771,\n", + " 32.7693])" ] }, + "execution_count": 27, "metadata": {}, - "output_type": "display_data" + "output_type": "execute_result" } ], "source": [ - "test_sentence_idx = 2\n", - "display(HTML(test_text[test_sentence_idx].split(\"
\")[0]))" + "torch.mean(ekfac_train_influences, axis=0)" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 28, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Positive probability: 14.639034867286682%\n", - "Negative probability: 85.36096215248108%\n" - ] + "data": { + "text/plain": [ + "tensor([-2576.7700, -2709.6460, -3631.7090, 815.2777, -2247.4573, -872.0656,\n", + " -1619.0323])" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "print_sentiment_preds(model_logits, train_input[train_sentence_idx])" + "torch.mean(corrupted_ekfac_train_influences, axis=0)" ] }, { @@ -458,7 +938,7 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 34, "metadata": {}, "outputs": [ { @@ -471,55 +951,62 @@ } ], "source": [ - "ekfac_train_influences = ekfac_influence_model.influences_by_layer(\n", + "influences_by_layer = ekfac_influence_model.influences_by_layer(\n", " test_input,\n", " test_labels,\n", " train_input,\n", - " modified_train_labels,\n", + " train_labels,\n", ")" ] }, { "cell_type": "code", - "execution_count": 79, + "execution_count": 35, "metadata": {}, "outputs": [], "source": [ - "influences = torch.zeros(size=(3, 5))\n", - "for layer_id, value in ekfac_train_influences.items():\n", + "influences = torch.zeros_like(ekfac_train_influences)\n", + "for layer_id, value in influences_by_layer.items():\n", " influences += value" ] }, { "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "idx = (0, 2)\n", - "infl_across_layers = []\n", - "for layer_id, value in ekfac_train_influences.items():\n", - " infl_across_layers.append(value[idx].item())" - ] - }, - { - "cell_type": "code", - "execution_count": 22, + "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "tensor([[ 3.5063e+01, 2.3881e+01, 1.5637e+01, -3.2224e+02, 1.1226e+01,\n", + " -1.4874e-01, 9.6876e+00],\n", + " [-1.4736e+02, -1.1331e+01, -3.0170e+01, 9.1802e+02, -4.6235e+01,\n", + " 1.1149e+02, 2.7890e+00],\n", + " [-4.4213e+00, 2.7296e+00, -3.2295e+00, 8.1575e+01, -3.3690e-01,\n", + " 8.3784e+00, -3.1832e-01],\n", + " [-9.1143e-02, -9.6700e-02, -1.4497e-01, 4.0539e+00, -9.4822e-02,\n", + " 4.7056e-01, -3.4283e-02],\n", + " [ 7.7044e+02, 3.3697e+02, 4.8730e+02, -1.9125e+04, 3.6766e+02,\n", + " -7.1804e+01, 1.5172e+02]], grad_fn=)" ] }, - "execution_count": 22, + "execution_count": 37, "metadata": {}, "output_type": "execute_result" - }, + } + ], + "source": [ + "influences" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -529,9 +1016,26 @@ } ], "source": [ - "import matplotlib.pyplot as plt\n", + "test_idx = 0\n", "\n", - "plt.plot(infl_across_layers)" + "train_idx_to_plot = list(range(len(ekfac_train_influences[0])))\n", + "train_idx_to_plot.pop(3)\n", + "for train_idx in train_idx_to_plot:\n", + " infl_across_layers = []\n", + " idx = (test_idx, train_idx)\n", + " for layer_id, value in influences_by_layer.items():\n", + " infl_across_layers.append(value[idx].item())\n", + " plt.plot(infl_across_layers, label=f\"Train example {train_idx}\")\n", + "plt.legend()\n", + "plt.xticks(\n", + " range(len(influences_by_layer.keys())),\n", + " strip_param_names(influences_by_layer.keys()),\n", + " rotation=70,\n", + ")\n", + "plt.xlabel(\"Layer id\")\n", + "plt.ylabel(\"Influence\")\n", + "plt.title(f\"Influence of test example {test_idx} on test examples\")\n", + "plt.show()" ] }, { @@ -572,11 +1076,11 @@ } ], "source": [ - "model_logits = ModelLogitsWrapper(model)\n", - "model_logits.eval()\n", + "wrapped_model = ModelLogitsWrapper(model)\n", + "wrapped_model.eval()\n", "\n", "ekfac_influence_model = EkfacInfluence(\n", - " model_logits,\n", + " wrapped_model,\n", " progress=True,\n", ")\n", "ekfac_influence_model = ekfac_influence_model.fit(train_dataloader)" @@ -671,7 +1175,7 @@ "plt.imshow(result_df, cmap=\"coolwarm_r\", aspect=\"auto\")\n", "plt.xticks(range(result_df.shape[1]), result_df.columns, rotation=45)\n", "plt.yticks(range(result_df.shape[0]), strip_param_names(result_df.index))\n", - "plt.colorbar(label=\"Correlation Value\") # Add label to the colorbar\n", + "plt.colorbar(label=\"Correlation Value\")\n", "plt.title(\"Correlation Heatmap\")\n", "plt.xlabel(\"Regularization Values\")\n", "plt.ylabel(\"Layer ID\")\n", diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index 93b0813df..7f0e52c3a 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -1036,7 +1036,7 @@ def get_kfac_blocks( hooks.append(module.register_full_backward_hook(layer_grad_hook)) for x, *_ in tqdm( - data, disable=not self.progress, desc="K-FAC blocks - batche progress" + data, disable=not self.progress, desc="K-FAC blocks - batch progress" ): data_len += x.shape[0] pred_y = self.model(x) From 340693aaea92b6660300e7c740ade2c6190ab1bf Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Wed, 3 Jan 2024 10:16:08 +0100 Subject: [PATCH 24/87] addressing PR comments --- docs/influence/influence_function_model.md | 2 +- .../base_influence_function_model.py | 5 +++ .../torch/influence_function_model.py | 31 ++++++++++--------- src/pydvl/influence/torch/util.py | 22 +++++++++++-- 4 files changed, 42 insertions(+), 18 deletions(-) diff --git a/docs/influence/influence_function_model.md b/docs/influence/influence_function_model.md index 1beaaf5ed..169bca12c 100644 --- a/docs/influence/influence_function_model.md +++ b/docs/influence/influence_function_model.md @@ -113,7 +113,7 @@ if_model = EkfacInfluence( hessian_regularization=0.0, ) ``` -Upon initialization, the K-FAC method will parse the model and extract which layers require grad and which do not. Then it will only calculate the influence scores for the layers that require grad. The current implementation of the K-FAC method is only available for linear layers, and therefore if the model contains non-linear layers that require gradient the K-FAC method will raise a ValueError. +Upon initialization, the K-FAC method will parse the model and extract which layers require grad and which do not. Then it will only calculate the influence scores for the layers that require grad. The current implementation of the K-FAC method is only available for linear layers, and therefore if the model contains non-linear layers that require gradient the K-FAC method will raise a NotImplementedLayerRepresentationException. A further improvement of the K-FAC method is the Eigenvalue Corrected K-FAC (EKFAC) method [@george2018fast], which allows to further re-fit the eigenvalues of the Hessian, thus providing a more accurate approximation. On top of the K-FAC method, the EKFAC method is implemented by simply calling the update_diag method from [EkfacInfluence](pydvl/influence/torch/influence_function_model.py). The following code snippet shows how to use the EKFAC method to calculate the influence function of a model. diff --git a/src/pydvl/influence/base_influence_function_model.py b/src/pydvl/influence/base_influence_function_model.py index 18b2ce8ed..1274941c6 100644 --- a/src/pydvl/influence/base_influence_function_model.py +++ b/src/pydvl/influence/base_influence_function_model.py @@ -36,6 +36,11 @@ def __init__(self): ) +class NotImplementedLayerRepresentationException(ValueError): + def __init__(self): + super().__init__(f"Layer representation not implemented for this module.") + + """Type variable for tensors, i.e. sequences of numbers""" TensorType = TypeVar("TensorType", bound=Collection) DataLoaderType = TypeVar("DataLoaderType", bound=Iterable) diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index 73326c7f2..5898cf1f8 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -20,6 +20,7 @@ from ..base_influence_function_model import ( InfluenceFunctionModel, InfluenceMode, + NotImplementedLayerRepresentationException, UnsupportedInfluenceModeException, ) from .functional import ( @@ -884,7 +885,7 @@ def to(self, device: torch.device): class EkfacInfluence(TorchInfluenceFunctionModel): r""" - Solves the linear system Hx = b, where H is the Hessian of a model with the empirical + Approximately solves the linear system Hx = b, where H is the Hessian of a model with the empirical categorical cross entropy as loss function and b is the given right-hand side vector. It employs the EK-FAC method [@george2018fast], which is based on the kronecker factorization of the Hessian first introduced in [@martens2015optimizing]. @@ -939,7 +940,7 @@ def _parse_active_layers(self) -> Dict[str, torch.nn.Module]: return active_layers @staticmethod - def init_layer_kfac_blocks( + def _init_layer_kfac_blocks( module: torch.nn.Module, ) -> Tuple[torch.Tensor, torch.Tensor]: """ @@ -953,13 +954,13 @@ def init_layer_kfac_blocks( forward_x_layer = torch.zeros((sA, sA), device=module.weight.device) grad_y_layer = torch.zeros((sG, sG), device=module.weight.device) else: - raise NotImplementedError( + raise NotImplementedLayerRepresentationException( f"Only Linear layers are supported, but found module {module} requiring grad." ) return forward_x_layer, grad_y_layer @staticmethod - def get_layer_kfac_hooks( + def _get_layer_kfac_hooks( m_name: str, module: torch.nn.Module, forward_x: Dict[str, torch.Tensor], @@ -989,12 +990,12 @@ def grad_hook(m, m_grad, m_out): grad_y[m_name] += torch.mm(m_out.t(), m_out) else: - raise NotImplementedError( + raise NotImplementedLayerRepresentationException( f"Only Linear layers are supported, but found module {module} requiring grad." ) return input_hook, grad_hook - def get_kfac_blocks( + def _get_kfac_blocks( self, data: DataLoader, ) -> Tuple[Dict[str, torch.Tensor], Dict[str, torch.Tensor]]: @@ -1009,8 +1010,8 @@ def get_kfac_blocks( data_len = 0 for m_name, module in self.active_layers.items(): - forward_x[m_name], grad_y[m_name] = self.init_layer_kfac_blocks(module) - layer_input_hook, layer_grad_hook = self.get_layer_kfac_hooks( + forward_x[m_name], grad_y[m_name] = self._init_layer_kfac_blocks(module) + layer_input_hook, layer_grad_hook = self._get_layer_kfac_hooks( m_name, module, forward_x, grad_y ) hooks.append(module.register_forward_hook(layer_input_hook)) @@ -1037,7 +1038,7 @@ def fit(self, data: DataLoader) -> EkfacInfluence: It then creates an EkfacRepresentation object that stores the KFAC blocks for each layer, their eigenvalue decomposition and diagonal values. """ - forward_x, grad_y = self.get_kfac_blocks(data) + forward_x, grad_y = self._get_kfac_blocks(data) layers_evecs_a = {} layers_evect_g = {} layers_diags = {} @@ -1058,7 +1059,7 @@ def fit(self, data: DataLoader) -> EkfacInfluence: return self @staticmethod - def init_layer_diag(module: torch.nn.Module) -> torch.Tensor: + def _init_layer_diag(module: torch.nn.Module) -> torch.Tensor: """ Initialize the tensor that will store the updated diagonal values of the layer. """ @@ -1068,12 +1069,12 @@ def init_layer_diag(module: torch.nn.Module) -> torch.Tensor: sA = module.in_features + int(with_bias) layer_diag = torch.zeros((sA * sG), device=module.weight.device) else: - raise NotImplementedError( + raise NotImplementedLayerRepresentationException( f"Only Linear layers are supported, but found module {module} requiring grad." ) return layer_diag - def get_layer_diag_hooks( + def _get_layer_diag_hooks( self, m_name: str, module: torch.nn.Module, @@ -1108,7 +1109,7 @@ def grad_hook(m, m_grad, m_out): ).view(-1) else: - raise NotImplementedError( + raise NotImplementedLayerRepresentationException( f"Only Linear layers are supported, but found module {module} requiring grad." ) return input_hook, grad_hook @@ -1133,8 +1134,8 @@ def update_diag( data_len = 0 for m_name, module in self.active_layers.items(): - diags[m_name] = self.init_layer_diag(module) - input_hook, grad_hook = self.get_layer_diag_hooks( + diags[m_name] = self._init_layer_diag(module) + input_hook, grad_hook = self._get_layer_diag_hooks( m_name, module, last_x_kfe, diags ) hooks.append(module.register_forward_hook(input_hook)) diff --git a/src/pydvl/influence/torch/util.py b/src/pydvl/influence/torch/util.py index 8c87b24d0..394cf535a 100644 --- a/src/pydvl/influence/torch/util.py +++ b/src/pydvl/influence/torch/util.py @@ -484,12 +484,19 @@ def __iter__(self): ) ) - def get_layer_evecs(self): + def get_layer_evecs( + self, + ) -> Tuple[Dict[str, torch.Tensor], Dict[str, torch.Tensor]]: + """ + It returns two dictionaries, one for the a eigenvectors and one for the g + eigenvectors, with the layer names as keys. The eigenvectors are in the same + order as the layers in the model. + """ evecs_a_dict = {layer_name: evec_a for layer_name, (_, evec_a, _, _) in self} evecs_g_dict = {layer_name: evec_g for layer_name, (_, _, evec_g, _) in self} return evecs_a_dict, evecs_g_dict - def to(self, device: torch.device): + def to(self, device: torch.device) -> "EkfacRepresentation": return EkfacRepresentation( self.layer_names, [layer.to(device) for layer in self.layers_module], @@ -502,6 +509,17 @@ def to(self, device: torch.device): def empirical_cross_entropy_loss_fn( model_output: torch.Tensor, *args, **kwargs ) -> torch.Tensor: + """ + Computes the empirical cross entropy loss of the model output. This is the + cross entropy loss of the model output without the labels. The function takes + all the usual arguments and keyword arguments of the cross entropy loss + function, so that it is compatible with the PyTorch cross entropy loss + function. However, it ignores everything except the first argument, which is + the model output. + + Args: + model_output: The output of the model. + """ probs_ = torch.softmax(model_output, dim=1) log_probs_ = torch.log(probs_) log_probs_ = torch.where( From ef2116f7e2aeaa4007172ee4a241ae2db56dd56f Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Wed, 3 Jan 2024 13:47:53 +0100 Subject: [PATCH 25/87] polishing wine notebook --- notebooks/influence_wine.ipynb | 105 +++++++++++++-------------------- 1 file changed, 41 insertions(+), 64 deletions(-) diff --git a/notebooks/influence_wine.ipynb b/notebooks/influence_wine.ipynb index c24266b94..4894f4ce2 100644 --- a/notebooks/influence_wine.ipynb +++ b/notebooks/influence_wine.ipynb @@ -1,7 +1,6 @@ { "cells": [ { - "attachments": {}, "cell_type": "markdown", "id": "a75acfec", "metadata": {}, @@ -26,7 +25,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "68ec440b", "metadata": {}, @@ -35,7 +33,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "9eb29a26", "metadata": {}, @@ -48,7 +45,6 @@ "execution_count": 1, "id": "cef17bfc", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -66,11 +62,12 @@ "execution_count": 2, "id": "be813151", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, - "tags": [] + "tags": [ + "hide-output" + ] }, "outputs": [ { @@ -113,7 +110,6 @@ "execution_count": 3, "id": "02254f9c", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -136,7 +132,6 @@ "execution_count": 4, "id": "a656363e", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -156,7 +151,6 @@ "execution_count": 5, "id": "df5159e6", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -171,7 +165,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "be7ddf7c", "metadata": {}, @@ -184,7 +177,6 @@ "execution_count": 6, "id": "0d3e96ca", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -202,7 +194,6 @@ "execution_count": 7, "id": "cac906e3-aed6-4d11-b563-1b9a91132d29", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -218,7 +209,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "b96a15cc", "metadata": {}, @@ -240,7 +230,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "5de58672", "metadata": {}, @@ -263,7 +252,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "a018e72c", "metadata": {}, @@ -278,7 +266,6 @@ "execution_count": 10, "id": "00dc59af", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -291,7 +278,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Model fitting: 100%|██████████| 300/300 [00:02<00:00, 101.35it/s]\n" + "Model fitting: 100%|██████████| 300/300 [00:01<00:00, 209.95it/s]\n" ] } ], @@ -323,7 +310,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "1a3ba188", "metadata": {}, @@ -336,7 +322,6 @@ "execution_count": 11, "id": "f4b57b77", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -347,7 +332,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABSMAAAKvCAYAAACRY9qRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABf70lEQVR4nO3deZhld10n/ve3u9Od9FbZd0glJBCUPewKZFjVwriwiYOC/mQRlxmXYIGOc2FGKIVBRokLowNEwQERESwFBdmGnQxhEUICpCD7nko6SafT3ef3xz03fft27bfuUnVfr+c5z/ecc88991Od0zfd7/4upaqqAAAAAAD02oZBFwAAAAAAjAZhJAAAAADQF8JIAAAAAKAvhJEAAAAAQF8IIwEAAACAvhBGAgAAAAB9IYwEAAAAAPpCGAkAAAAA9MWmQRcwaKWUkuTkJLcPuhYAAAAAWKN2JLm6qqpqoYtGPoxMM4i8ctBFAAAAAMAad2qSqxa6QBh5oEfkqdE7EgAAAACWa0eanf0WzdaEkQfcXlXVbYMuAgAAAADWkuYsiEtjARsAAAAAoC+EkQAAAABAXwgjAQAAAIC+EEYCAAAAAH1hARsAAAAAhtZFF120I8lJ0aluEPYnueacc85ZdJXspSpVVa3WvdakUsrOJLNJxqymDQAAADAcLrroog1JXrVx48afLaUclmTpSzazWqqqqu7Zt2/fhUlee8455+yf66Ll5Gt6RgIAAAAwjF512GGH/eKJJ564Z9u2bXeWUka7R90AVFVV7rjjjq3XXnvtL95zzz1J8t+7vaeekXpGAgAAAAyViy66aOfGjRu/ePLJJx92/PHH3zToekbd9ddff8zVV199z759+86Za8j2cvI1Y+0BAAAAGDYnllIO27Zt252DLoSk7pl6WJpzd3ZFGAkAAADAsNmQpBiaPRzq/w4lq5AlCiMBAAAAgL4QRgIAAAAAfSGMBAAAAIB15FnPetb4Kaec8uBB1zGXTYMuAAAAAABGQSnlnKVc94EPfODSZz7zmYesWr0eCCMBAAAAoA8uuOCCy9uP3/GOdxzz6U9/emfn+Yc+9KF3dfM573znO7+7f//+bm7RM8JIAAAAAOiDl7/85Te3H3/2s5/d/ulPf/qQ851uv/32DTt27Fhyurhly5ahXYXcnJEAAAAAMCQe/ehHP+Css876/k9+8pNbH/nIRz7giCOOePh/+k//6ZQk+eu//usjzz333DOPP/74h2zevPkR97nPfR50/vnnn7R3796D7tE5Z+Q3v/nNzaWUc373d3/3hDe84Q3H3uc+93nQ5s2bH/GgBz3ogR//+Me39vPn0zMSAAAAAIbIrbfeuvHHfuzHzjrvvPNu/qmf+qmbTjzxxL1J8va3v/2Ybdu27X/Zy1523fbt2/d/7GMf2/GGN7zh5Ntuu23jn//5n1+52H3f8573HH3HHXdsfOELX3hDKSVvfvObT3ze85535ne/+92v9qs3pTASAAAAgDVhf1Xlzrv3Ds1I361bNu3fUMqq3/fGG2887A/+4A++e/7559/Yfv7v//7vv7N9+/Z7Q8NXvOIVN/z0T//0fS+88MLj3vSmN111xBFHLBgoXnPNNZsvvfTSrx133HH7kuTss8/e/YIXvODM9773vTuf//znz676DzIHYSQAAAAAa8Kdd+/d8KDGvzx80HW0fK3x9C9tP/ywVV8pZvPmzdWv/Mqv3NR5vj2IvOWWWzbs3r17wxOe8IRdf/M3f3PcxRdffPjjHve4BRe+eeYzn3lLK4hMkqc//em7kuTb3/72ltWsfyHCSAAAAAAYIscff/yeww8//JBejl/84hcPf+UrX3nKZz/72R27du3a2P7arbfeurHz+k73ve9997Qft4LJW265ZdH3rhZhJAAAAABrwtYtm/Z/rfH0Lw26jpatWzateq/IJJkriLzxxhs3Pu1pT3vAtm3b9r/iFa+4+swzz7z7iCOO2P/FL35x6+/93u+dum/fvkXHi2/cuHHOYdxVVa3+WPN5CCMBAAAAWBM2lJJeDIteC/75n/95x6233rrpne985zd/+Id/eFfrfD+HWK8GYeQ6Nz45fWqSRya5aWZq4pODrgcAAACA5Wv1aty//0AWu3v37vIXf/EXxw+sqBUQRq5/z0nyxiTvTiKMBAAAAFiDnvzkJ+/auXPnvpe85CWnv/jFL76+lFK9613vOqaqFlxAe+gMzVLo9Mx36vaMgVYBAAAAwIqdeOKJ+97znvdcdtxxx93z+7//+ydfcMEFJz7pSU+67bWvfe2Vg65tOcpaS09XWyllZ5LZJGNVVd026HpW2/jk9IOTfCXJzTNTE8cMuh4AAACAxVx00UVnb9q06YNnnXXWrq1bt+4edD2j7s477zz8sssu2753794fOueccy7pfH05+Zqekevf5XV79Pjk9JGDLAQAAACA0SaMXOdmpiZ2Jbm+Pjx9kLUAAAAAMNqEkaPh23Vr3kgAAAAABkYYORosYgMAAADAwAkjR4MwEgAAAICBE0aOBmEkAAAAAAMnjBwNwkgAAAAABk4YORpaYeT4+OT0xoFWAgAAAMDIEkaOhquT7EmyKcmpA64FAAAAgBEljBwBM1MT+5NcXh/eb5C1AAAAADC6hJGjw7yRAAAAAAyUMHJ0CCMBAAAA1plvfvObm0sp5/zRH/3RMYOuZSmEkaNDGAkAAAAwYE9+8pPPPOKIIx5+yy23zJvLnXfeeacfdthhj7j22mvX3ULEwsjRIYwEAAAAGLDnP//5N+3evXvDO97xjqPmev3222/f8OEPf/jIJzzhCbedeOKJ+/pdX68JI0eHMBIAAABgwJ7//Offum3btv3vete7jp7r9Xe+851H3nXXXRue//zn39Tv2vpBGDk6WqtpHzM+OT020EoAAAAARtT27durZzzjGbd85jOf2XHVVVdt6nz9Xe9619Hbtm3b/9SnPnXXS17yklPvf//7f9/WrVsfvn379oc/8YlPPOszn/nMEYOoe7UII0fEzNTE7UluqA9PH2QtAAAAAKPsBS94wc379u0rb3/72w8aqn3ddddt/OQnP7nz6U9/+i1XXHHFYR/84AePfNrTnjb7mte85opf/MVfvPab3/zmEU9/+tMfMDMzc9igau/WIekr69p3khyX5lDtiwdbCgAAAMAyVfuTPXcMT+e6zdv2pyy/nB/90R+97bjjjrvnb//2b4951ate1eo8lgsvvPCovXv3lhe84AU3P+pRj7rr8ssv/9rGjQfWsPmFX/iFmx7ykIc86IILLjj29a9//TWr80P0lzBytHwnyWNi3kgAAABgLdpzx4a87tSHD7qMe73yyi9ly479y33bpk2bct555938l3/5lyd885vf3PyABzxgT5K8+93vPuaYY47Ze9555922adOB2G7v3r258cYbN+7cuXP/+Pj47osvvnjrKv4UfTU8STL9YBEbAAAAgCHwwhe+8OYkeetb33p0knz7298+7KKLLtp+3nnn3bxp06bs27cvr371q48/7bTTHnT44Yefc9JJJz3s5JNPfuill156xO23375x4bsPLz0jR4swEgAAAFi7Nm/bn1de+aVBl3GvzduW3Suy5QlPeMKdp59++u73vve9R09NTV37tre97eiqqvLCF77wpiR55StfedLrX//6k5/znOfc+NSnPvWqY489dt+GDRuq888//7779+8vq/dD9JcwcrQIIwEAAIC1q2zISoZFD6tnP/vZN7/+9a8/+XOf+9wR73nPe4457bTT7n7Sk550Z5K8//3vP+oxj3nM7e9+97u/2/6el770pRuPOuqovYOpuHuGaY+WVhg5Pj45vWa78wIAAACsBz//8z9/U5L89m//9smXXHLJEc961rNuar22cePGqqqqg67/3//7fx91/fXXr9mVtBM9I0fNVUnuSXJYklOSfG+w5QAAAACMrrPPPnvPwx/+8Ds+8pGPHJkkP/dzP3dz67WnP/3ps29605tOevaznz3+uMc9btdXv/rVI973vvcdc+qpp949sIJXgZ6RI2RmamJfkpn60FBtAAAAgAF77nOfe1OSPPjBD77jQQ960L1B42tf+9prXvziF1/3iU98Yufv/M7v3OerX/3q1r/7u7+77KSTTrpncNV2r3R29xw1pZSdSWaTjFVVddug6+m18cnpDyZ5RpJfmJma+MtB1wMAAADQ6aKLLjp706ZNHzzrrLN2bd26dfeg6xl1d9555+GXXXbZ9r179/7QOeecc0nn68vJ1/SMHD3fqtuzBloFAAAAACPHnJHrXWOsJDkuyWFpzF6V5Jv1Kw8YXFEAAAAAjCI9I9e/VyS5Lslr6+NWV9qzB1MOAAAAAKNKGLn+XV63Z9ZtK4w8c3xyek0vBQ8AAADA2iKMXP8654i8KsmdaQ7RP30gFQEAAAAwkoSR699ldXtcGmNjM1MT+3Ng3khDtQEAAADoG2HketeYvT3NOSOTA0O1LWIDAAAADLP9SVJV1aDrIAf9d9jf7b2EkaOhc6i2RWwAAACAYXZTVVV79+7du2nQhZDs3bt3U1VVe5Pc2O29hJGjoTVUu3MRG2EkAAAAMIxuqarq2tnZ2R2DLoRkdnZ2R1VV1ya5tdt7SZdHQ2fPSMO0AQAAgKF1zjnn7L/ooovecOutt/7xli1bjtm+ffsdpZRBlzVyqqrKrl27tt1666379+/f//pzzjmn62HawsjR0Nkz8tK6PWZ8cvrYmamJrrvYAgAAAKyy999zzz3ff8011zy/lLJ90MWMqqqqdu3bt+9vknxgNe4njBwNrTDyrCSZmZq4c3xy+ntJ7ptm70hhJAAAADBU6l54v3fRRRf9cZITY7rBQdif5NpzzjnnttW6oTByNLSGaR+XxthYGrOzac4bed8054381MAqAwAAAFhAHYStWhjGYEmUR0Fj9vYk19VHFrEBAAAAYCCEkaPDIjYAAAAADJQwcnR0LmKjZyQAAAAAfSWMHB0HLWKTA2HkGeOT05sHUA8AAAAAI0YYOTo6h2lfk2RXko1J7jeQigAAAAAYKcLI0XHQMO2ZqYkqhmoDAAAA0EfCyNHR6hl5XBpjY/W+RWwAAAAA6Bth5KhozN6e5Lr6yCI2AAAAAPSdMHK0zLeIjZ6RAAAAAPScMHK0dC5i0xqmffb45HQZQD0AAAAAjBBh5Gg5aBGb+rhKcmSS4wdREAAAAACjY6jCyFLKE0spHyilXF1KqUopP76E95xbSvl/pZS7SynfKqW8qPeVrlkHDdOemZrYnWSmPmeoNgAAAAA9NVRhZJJtSb6c5JeWcnEp5fQk00k+muRhSd6U5C9KKc/oUX1rXecw7SS5dI5zAAAAALDqhiqMrKrqn6uq+p2qqv5+iW95WZLLq6r6jaqqvlFV1ZuTvCfJr/WuyjWtFUYem8bYkfV+K4y8f//LAQAAAGCUDFUYuQKPS/LhjnMfqs/TqTF7e5Jr66PWvJHCSAAAAAD6Yq2HkScmua7j3HVJdpZSjpjrDaWULaWUna0tyY5eFzlkWr0j2xexSYSRAAAAAPTYWg8jV+KVSWbbtisHW07fHbSITQ70jLzf+OT0xgHUAwAAAMCIWOth5LVJTug4d0KS26qqumue97wuyVjbdmrvyhtK36nbM+r2e0n2JNmS5D4DqQgAAACAkbDWw8jPJHlKx7mn1efnVFXV3VVV3dbaktzeywKH0Lfr9n5JMjM1sS8Hhm4bqg0AAABAzwxVGFlK2V5KeVgp5WH1qdPr4/vWr7+ulHJh21v+LMkZpZQ/KKWcXUp5eZLnJvnD/la+phwURtbMGwkAAABAzw1VGJnkkUm+VG9J8sZ6/zX18UlJ7tu6uKqqy5NMpNkb8stJfiPJL1RV9aF+FbwGtcLIk9MYay3y05o38qw5rgcAAACAVbFp0AW0q6rqY0nKAq+/aJ73PLxnRa0/N6e5cM9YmvNG/nsOhJF6RgIAAADQM8PWM5Jea8xWOXSotmHaAAAAAPScMHI0dYaRrZ6R4+OT05sHUA8AAAAAI0AYOZo6w8hrk+xK83k4YyAVAQAAALDuCSNH03fq9owkmZmaqGKoNgAAAAA9JowcTZ09IxOL2AAAAADQY8LI0dQKI09PY2xjvd8KI88aQD0AAAAAjABh5Gi6Msk9SQ5Lcmp9zjBtAAAAAHpKGDmKGrP7klxeH3WuqC2MBAAAAKAnhJGjq3PeyFbPyJPHJ6e3D6AeAAAAANY5YeToOiiMnJmauDnJjfW5MwdSEQAAAADrmjBydM21orZ5IwEAAADoGWHk6PpO3Z7Rds68kQAAAAD0jDBydB3oGdkYK/V+K4w8awD1AAAAALDOCSNHV6tn5FiSo+t9w7QBAAAA6Blh5KhqzN6V5Or6qDVvZKtn5AP6XxAAAAAA650wcrR1LmLTOj5qfHL6yP6XAwAAAMB6JowcbQeFkTNTE7uS3FifO20gFQEAAACwbgkjR1tnz8gkmanb8b5WAgAAAMC6J4wcbQuFkaf3txQAAAAA1jth5GibK4y8vG7H+1sKAAAAAOudMHK0faduT05j7Ih6f6Zux/teDQAAAADrmjBytN2U5LZ6vzUse6Zux/tdDAAAAADrmzBylDVmqxzoHTletzMdxwAAAACwKoSRfK9u71u3363bsfHJ6SP7Xw4AAAAA65UwkoPCyJmpiTuS3FCfGx9EQQAAAACsT8JIOntGJoZqAwAAANADwkhaw7JPazt3ed2eHgAAAABYJcJI9IwEAAAAoC+EkbTCyFPSGNtU78/U7XjfqwEAAABg3RJGcm2Se5JsTHJSfW6mbscHUA8AAAAA65QwctQ1ZvcnubI+ag3Vnqnb8fHJ6dL3mgAAAABYl4SRJIcuYtM63pnkyL5XAwAAAMC6JIwk6VjEZmZq4s4k19fnxgdREAAAAADrjzCSZO4VtS+v29P7XAsAAAAA65QwkmTuMHKmbsf7WgkAAAAA65YwkkQYCQAAAEAfCCNJDl3AJhFGAgAAALDKhJEkyRV1uzONsbF6f6Zux/teDQAAAADrkjCSpDF7R5Kb6qPWUO2Zuh0fn5wufa8JAAAAgHVHGElL57yRraHbO5Ic1f9yAAAAAFhvhJG0HBRGzkxN3JXk2vrc+CAKAgAAAGB9EUbSstAiNqf3txQAAAAA1iNhJC2dw7QTi9gAAAAAsIqEkbQIIwEAAADoKWEkLQuFkYZpAwAAANA1YSQtrTDylDTGNnWcu88A6gEAAABgnRFG0nJdkj1pPhOn1OeuqtuTB1IRAAAAAOuKMJKmxuz+JFfUR62h2q0w8tjxyekt/S8KAAAAgPVEGEm7znkjb05yd72vdyQAAAAAXRFG0u6gMHJmaqLKgd6Rp8z5DgAAAABYImEk7eZaUfvqutUzEgAAAICuCCNp9926Pa3tnJ6RAAAAAKwKYSTt5uoZKYwEAAAAYFUII2nXCiP1jAQAAABg1QkjaXdl3W5PY2xHvS+MBAAAAGBVCCM5oDF7R5Lb66OT6tYCNgAAAACsCmEkna6p21b4eG/PyPHJ6TKAegAAAABYJ4SRdGqFkZ09Iw9PclT/ywEAAABgvRBG0qkVPp6UJDNTE7uT3FSfM28kAAAAACsmjKRTZ8/IxCI2AAAAAKwCYSSdFgojLWIDAAAAwIoJI+k0VxjZGrqtZyQAAAAAKyaMpFPnatqJYdoAAAAArAJhJJ3MGQkAAABATwgj6dQakj2WxtgR9b45IwEAAADomjCSTrcluaveb/WO1DMSAAAAgK4JIzlYY7bKoUO1W70ljx+fnD6s/0UBAAAAsB4II5lL5yI2Nya5J0nJwXNJAgAAAMCSCSOZy0E9I2emJvbnQO9IQ7UBAAAAWBFhJHNZaEVti9gAAAAAsCLCSObS6gU5VxipZyQAAAAAKyKMZC5z9Yw0TBsAAACArggjmctCw7SFkQAAAACsiDCSuXSupp0IIwEAAADokjCSubTCyGPSGNtc71vABgAAAICuCCOZy01J7qn3T6zbe3tGjk9Ol/6XBAAAAMBaJ4zkUI3ZKofOG9lawGZbkp19rwkAAACANU8YyXwOCiNnpibuTHJrfc68kQAAAAAsmzCS+Sy0iI15IwEAAABYNmEk8+kcpp1YURsAAACALggjmY8wEgAAAIBVJYxkPq0Fa05a5BwAAAAALIkwkvnM1TPy2ro9sc+1AAAAALAOCCOZjzASAAAAgFUljGQ+rTDyhDTGNtX71917DgAAAACWSRjJfG5Isj9JSXJ8fU7PSAAAAABWTBjJ3Bqz+3KgJ2RrqHYrjNwxPjm9rf9FAQAAALCWCSNZSOfq2buS3FnvG6oNAAAAwLIII1nIQYvYzExNVDFUGwAAAIAVEkaykFYYeXLbOWEkAAAAACsijGQhB/WMrLXmkRRGAgAAALAswkgWMlcY2eoZac5IAAAAAJZFGMlCWmFkey9Iw7QBAAAAWBFhJAu5vm6PbzsnjAQAAABgRYSRLEQYCQAAAMCqEUaykFYYuTWNsW31vjASAAAAgBURRrKQXUl21/ut3pH3rqY9Pjld+l8SAAAAAGuVMJL5NWarHDpUuxVGbk4y1veaAAAAAFizhJEs5qAwcmZqYneSW+tzhmoDAAAAsGTCSBZjERsAAAAAVoUwksUIIwEAAABYFcJIFiOMBAAAAGBVCCNZzFxh5L0rave5FgAAAADWMGEki9EzEgAAAIBVIYxkMQuFkSf0uRYAAAAA1jBhJIvRMxIAAACAVSGMZDGtMPK4NMZaz4swEgAAAIBlE0aymBvqdmOSo+r9Vhh5/Pjk9Mb+lwQAAADAWiSMZGGN2T1Jbq2PWkO1b0xSpfn8HDuAqgAAAABYg4SRLMVB80bOTE3szYEek4ZqAwAAALAkwkiWworaAAAAAHRNGMlSWFEbAAAAgK4JI1kKYSQAAAAAXRu6MLKU8kullJlSyu5SyudKKY9e5Pr/XEr5ZinlrlLKFaWUPyylHN6vekeEMBIAAACArg1VGFlKeV6SNyZ5dZJHJPlykg+VUo6f5/qfTjJVX//AJP9fkucleW1fCh4dc4WR19WtMBIAAACAJRmqMDLJryf5X1VVvbWqqq8neVmSO5P8/DzXPz7Jp6qqemdVVTNVVf1Lkr9JsmBvSpZNz0gAAAAAujY0YWQpZXOSc5J8uHWuqqr99fHj5nnbp5Oc0xrKXUo5I8mPJPmn3lY7coSRAAAAAHRt06ALaHNsko05MPy35bokZ8/1hqqq3llKOTbJ/y2llDR/nj+rqmreYdqllC1JtrSd2tFV1aNhoTDyhD7XAgAAAMAaNTQ9I1eilHJuklcleXmac0z+ZJKJUsp/WeBtr0wy27Zd2dsq14VWGHlkGmOb6/1WGHn0+OT0ljneAwAAAAAHGaYw8sYk+3JoT7sTciD46vTfkvxVVVV/UVXVV6uq+vs0w8lXllLm+9lel2SsbTu168rXv1vS/G+TJMe1nbun3p9zgSEAAAAAaDc0YWRVVXuSXJTkKa1zdaD4lCSfmedtW5Ps7zjXCs3KPJ9zd1VVt7W2JLd3VfgoaMzuT3JDfXR8ksxMTVSxojYAAAAAyzA0YWTtjUleXEp5YSnlgUn+NMm2JG9NklLKhaWU17Vd/4Ekv1hK+alSyumllKel2VvyA1VV7eu8OV2xiA0AAAAAXRmmBWxSVdW7SinHJXlNmgHXxUl+qKqqVg+8++bgnpD/PUlVt6ek2XvvA0l+u181jxBhJAAAAABdGaowMkmqqnpzkjfP89q5Hcd7k7y63ugtK2oDAAAA0JVhG6bN8NIzEgAAAICuCCNZKmEkAAAAAF0RRrJUc4WRVtMGAAAAYMmEkSyVnpEAAAAAdEUYyVIJIwEAAADoijCSpToQRjbGSr3fCiO3jU9Obx9ATQAAAACsIcJIlqoVRh6eZHuSzExN7EpyR33+hEEUBQAAAMDaIYxkaRqzdyS5sz4yVBsAAACAZRNGshxW1AYAAABgxYSRLIdFbAAAAABYMWEkyyGMBAAAAGDFhJEshzASAAAAgBUTRrIcC4WRVtMGAAAAYEHCSJbjhro9ru2cnpEAAAAALIkwkuWYK4y0mjYAAAAASyKMZDkW7Bk5Pjld+lwPAAAAAGuIMJLlWKhn5GFJjupvOQAAAACsJcJIluNAGNkYK0kyMzVxd5Jb6vOGagMAAAAwL2Eky9EKIw9LsrPtvBW1AQAAAFiUMJKla8zeleSO+siK2gAAAAAsizCS5bKiNgAAAAArIoxkuRZcUbvPtQAAAACwhggjWS5hJAAAAAArIoxkuYSRAAAAAKyIMJLlEkYCAAAAsCLCSJZroTDyhD7XAgAAAMAaIoxkuRZaTfu48cnpjX2uBwAAAIA1QhjJcs0VRt6QZH+az9Nxh7wDAAAAACKMZPkOCSNnpib2tZ03byQAAAAAcxJGslxz9YxMLGIDAAAAwCKEkSxXK4w8Io2xbW3nhZEAAAAALEgYyXLtSnJ3vW9FbQAAAACWTBjJ8jRmqyy8oraekQAAAADMSRjJSswVRhqmDQAAAMCChJGshDASAAAAgGUTRrISwkgAAAAAlk0YyUoIIwEAAABYNmEkK7HQAjZHjk9OH97negAAAABYA4SRrEQrjDy+7dwtSfbU+3pHAgAAAHAIYSQrcUjPyJmpiSrJ1fXhyX2vCAAAAIChJ4xkJeYapp0kV9WtMBIAAACAQwgjWYn5wshWz8hT+lgLAAAAAGuEMJKVaIWR29MYa1+sxjBtAAAAAOYljGQlbk2yt95v7x3ZGqatZyQAAAAAhxBGsnyN2SrJjfVRexipZyQAAAAA8xJGslJzzRtpARsAAAAA5iWMZKXmCiMtYAMAAADAvISRrNRCYeT28cnpHX2uBwAAAIAhJ4xkpQ4JI2emJnYlua0+NFQbAAAAgIMII1mpuXpGJoZqAwAAADAPYSQrtVgYqWckAAAAAAcRRrJS84WRVtQGAAAAYE7CSFbKMG0AAAAAlkUYyUoZpg0AAADAsggjWalWGHlkGmOHtZ03TBsAAACAOQkjWambk1T1/rFt5w3TBgAAAGBOwkhWpjG7L8lN9VH7UO17h2mPT06X/hYFAAAAwDATRtKNueaNvKZuD0tyTH/LAQAAAGCYCSPpxvV1e28YOTM1sScHQkpDtQEAAAC4lzCSbrTCyOM7zlvEBgAAAIBDCCPpxnxhpEVsAAAAADiEMJJuLBZG6hkJAAAAwL2EkXTjuro9oeO8YdoAAAAAHEIYSTcM0wYAAABgyYSRdMMwbQAAAACWTBhJN6ymDQAAAMCSCSPpRiuM3J7G2Na2862ekSeMT04f1ueaAAAAABhSwki6cVuSPfX+cW3nb0iyN0nJoYvbAAAAADCihJGsXGO2yoEVte8dqj0zNbE/yTX1oaHaAAAAACQRRtK91lDtzh6QVtQGAAAA4CDCSLplRW0AAAAAlkQYSbesqA0AAADAkggj6dZiPSMN0wYAAAAgiTCS7ukZCQAAAMCSCCPp1iGraddaPSNP7WMtAAAAAAwxYSTdmq9n5Pfq9r7jk9Olj/UAAAAAMKSEkXSrFUae0HG+FUZuS3JM/8oBAAAAYFgJI+lWK4w8Lo2xe5+nmamJ3UmurQ9P63tVAAAAAAydrsLIUsp9Syk/2HHuoaWUC0sp7yql/HhX1bEW3FC3G5Mc1fHaTN2O96sYAAAAAIZXtz0j/yhJo3VQSjkhyUeT/GSSJyb5u1LKT3b5GQyzxuyeJLfWR53zRs7U7XifqgEAAABgiHUbRj46yb+2Hf9skiOSPDTJKUk+kuQ3u/wMht98K2p/t24N0wYAAACg6zDy6ByYMzBJnpnk41VVfbuqqv1J3pvk7C4/g+E334raM3U73rdKAAAAABha3YaRN6Tu9VZKOTLJY5N8qO31TfXG+jbfitozdTvet0oAAAAAGFrdhpEfTvKrpZRfT3Jhfb/3tb3+fUmu6PIzGH7z9Yy8d5j2+OR06WM9AAAAAAyhbnstTia5f5I3JNmT5Derqro8SUopW5I8N8k7u/wMht9iYeTOJEcmuaVfBQEAAAAwfLrqGVlV1XVVVf1AkqOS7Kyq6n923PspaVttm3VrzjByZmrizrbXxvtZEAAAAADDp9th2kmSqqpmq6ra03HurqqqvlxV1c2r8RkMtflW006sqA0AAABAraswspTylFLK+R3nfr6U8r1SynWllD8spWzsrkTWgPmGaScWsQEAAACg1m3PyEaSh7YOSikPTvLnaa6y/bEkv5rkN7v8DIafMBIAAACARXUbRj4wyRfbjn8myW1JnlBV1fOS/K8kP9vlZzD8WmHkWBpjh3e8Zpg2AAAAAEm6DyO3pRk+tvxQkg9WVXVnffyFCKFGwa1J9tb7x3W8NlO3432qBQAAAIAh1W0YeUWSRyVJKeXMJA9K8i9trx+d5O4uP4Nh15itMv9Q7Zm6He9XOQAAAAAMp27DyHckeUkp5f1JPpTkliT/0Pb6OUku7fIzWBvmW1G7NUz7yPHJ6bE+1gMAAADAkOk2jPy9JFNJ7pPke0l+vKqqW5OklHJ0knOTvL/Lz2BtmLNn5MzUxK4kN9WHhuwDAAAAjLBN3by5qqq9SX673jpfuznJid3cnzVloRW1v5vkmDSHan+lXwUBAAAAMFy67Rl5r1LK9lLKA+tt+2rdlzWjFUaeMMdrM3WrZyQAAADACOs6jCylPKqU8tE054v8Wr3dUkr5t1LKI7u9P2vGQj0jZ+p2vC+VAAAAADCUuhqmXUp5TJKPJdmT5C+SfKN+6YFJnp/kE6WUc6uq+nw3n8OasNgw7UQYCQAAADDSugoj01zA5qokP1hV1bXtL5RSGkk+VV/ztC4/h+E332raiWHaAAAAAKT7YdqPSfLnnUFkklRVdV2StyR5bJefwdpgmDYAAAAAC+o2jNyfhXtXbqyvYf07EEY2xkrHa61h2seMT05b3AgAAABgRHUbRn46yS+VUg4ZfltKuW+Sl6c5VJv174a6PSzJke0vzExNzCa5tT40VBsAAABgRHUbRr4qyViSS0op7yylNOrtb5JckmYo9couP4O1oDG7OwcCx5PmuGKmbsf7UA0AAAAAQ6irBWyqqvpSvaL27yU5L8nW+qU7k3wwSSPJjd18BmvKNWkG0Ccl+XrHa99N8rAIIwEAAABGVrc9I1NV1derqvqJJDvTDKFOSrKzqqqfTPKjSa7o9jNYM66p24V6RhqmDQAAADCiuuoZ2a6qqv1Jrlut+7EmLRRGXl63Z/apFgAAAACGTNc9I6HNQmHkN+v2AX2qBQAAAIAhI4xkNV1dt3OFkZfU7Vnjk9Or1iMXAAAAgLVDGMlqWqhn5PeS7E5yWCxiAwAAADCSlt1DrZTyiGVcfvJy78+a1gojD/nvPjM1sX98cvqyJA9Oc6j2t/pZGAAAAACDt5Lhsl9MUi3x2rKMa1n7FuoZmTSHaj84ydlJpvtSEQAAAABDYyVh5M+tehWsF60wcnsaY9vTmN3V8bpFbAAAAABG2LLDyKqq3t6LQlgHGrO3pzF2R5JtafaOvKzjCmEkAAAAwAgbugVsSim/VEqZKaXsLqV8rpTy6EWuP7KUckEp5ZpSyt2llEtLKT/Sr3o5xEJDtVsrap/dp1oAAAAAGCJDFUaWUp6X5I1JXp3kEUm+nORDpZTj57l+c5J/TXN15men2ePuxUmu6ke9zGmhMPLSuj1+fHL6yP6UAwAAAMCwGKowMsmvJ/lfVVW9taqqryd5WZI7k/z8PNf/fJKjk/x4VVWfqqpqpqqqj1dV9eU+1cuh5g0jZ6YmbktydX1oqDYAAADAiBmaMLLu5XhOkg+3zlVVtb8+ftw8bzsvyWeSXFBKua6U8rVSyqtKKRt7XjDzWWxF7da8kYZqAwAAAIyYoQkjkxybZGOS6zrOX5fkxHnec0aaw7M3JvmRJP8tyW8k+Z35PqSUsqWUsrO1JdnRbeEcZKlhpJ6RAAAAACNmmMLIldiQ5PokL6mq6qKqqt6V5PfSHN49n1cmmW3brux5laOlNQz75Hleby1iI4wEAAAAGDHDFEbemGRfkhM6zp+Q5Np53nNNkkurqtrXdu4bSU6sh33P5XVJxtq2U1dcMXMxTBsAAACAOQ1NGFlV1Z4kFyV5SutcKWVDffyZed72qSRn1te13D/JNfX95vqcu6uquq21Jbl9VX4AWpYaRp45Pjltbk8AAACAETI0YWTtjUleXEp5YSnlgUn+NMm2JG9NklLKhaWU17Vd/6dprqb9P0sp9y+lTCR5VZIL+lw3B7TCyKPSGDt8jte/l2R3ks1JxvtVFAAAAACDN1RhZD3n428meU2Si5M8LMkPVVXVWtTmvmnrcVdV1RVJnpHkUUm+kuSPkvzPJFN9K5pOtyS5u94/ZOGhmamJfUkuqw8N1QYAAAAYIZsGXUCnqqrenOTN87x27hznPpPksT0ui6VqzFZpjF2b5LQ0g+OZOa76ZpIHp7mIzXT/igMAAABgkIaqZyTrxmLzRlpRGwAAAGAECSPpBStqAwAAAHAIYSS9sNQwUs9IAAAAgBEijKQXWmHkyfO83gojTxifnD6y9+UAAAAAMAyEkfTCgj0jZ6Ymbmu7Ru9IAAAAgBEhjKQXrq7b+YZpJwcWsTFvJAAAAMCIEEbSC4vNGZkkX63bh/a4FgAAAACGhDCSXmiFkcelMbZpnmsurtuH974cAAAAAIaBMJJeuCHJviQlyQnzXPOlun3Y+OR06UtVAAAAAAyUMJLV15jdn+S6+mi+odpfT3JPkiOTnNaHqgAAAAAYMGEkvbLYitp7kvx7fWioNgAAAMAIEEbSK0tZxKY1VFsYCQAAADAChJH0SiuMPHmBa+6dN7K3pQAAAAAwDISR9MpSekZeXLd6RgIAAACMAGEkvbKUMPLLdXvq+OT0sT2uBwAAAIABE0bSK1fX7bxh5MzUxG1JvlUfPqzXBQEAAAAwWMJIeqUVRp6yyHUX162h2gAAAADrnDCSXrmibk9MY2zzAtdZURsAAABgRAgj6ZUbkuxJUmJFbQAAAAAijKRXGrP7k1xZH91ngSsvrtsHjE9Ob+1pTQAAAAAMlDCSXmoN1Z43jJyZmrgmyXVpPosP7kdRAAAAAAyGMJJeWjSMrJk3EgAAAGAECCPpJWEkAAAAAPcSRtJLSw0jL67bh/WsEgAAAAAGThhJLy23Z+RDxienN/WwHgAAAAAGSBhJLy01jPx2ktuTHJ7kgT2tCAAAAICBEUbSS9+r22PTGNs630UzUxP7k3yhPnxcz6sCAAAAYCCEkfTSrUnuqPdPXeTaT9etMBIAAABgnRJG0juN2SpLH6r9mbp9fO8KAgAAAGCQhJH02lLDyM/W7f3HJ6eP7WE9AAAAAAyIMJJeW1IYOTM1cXOSS+rDx/a0IgAAAAAGQhhJry21Z2Ri3kgAAACAdU0YSa8tJ4w0byQAAADAOiaMpNdW0jPy0eOT05t6VA8AAAAAAyKMpNeWE0ZekuTWJFuTPKRXBQEAAAAwGMJIeq0VRu5MY2znQhfOTE3sz4FVtQ3VBgAAAFhnhJH0VmN2V5q9HZPlzRtpERsAAACAdUYYST+sZN5IPSMBAAAA1hlhJP2wnDDy80mqJOPjk9Mn9a4kAAAAAPpNGEk/LDmMnJmauC3JV+tDQ7UBAAAA1hFhJP3wvbpdSs/IxLyRAAAAAOuSMJJ+WM4w7cS8kQAAAADrkjCSflhpGPnI8cnpI3pQDwAAAAADIIykHw6EkY2xsoTrv53kmiSbkzymZ1UBAAAA0FfCSPrhyro9IsnRi108MzVRJflYfXhub0oCAAAAoN+EkfReY/buJNfXR0sdqv3xun3S6hcEAAAAwCAII+mX5c4b+bG6fdz45PThq18OAAAAAP0mjKRflhtGXprkuiRbkjy6JxUBAAAA0FfCSPplWWGkeSMBAAAA1h9hJP3yvbo9bRnvMW8kAAAAwDoijKRfLq/b05fxno/V7ePHJ6e3rG45AAAAAPSbMJJ+WUkYeUmaq3AfnuRRq14RAAAAAH0ljKRfWmHkCWmMbV3KG+p5I1tDtc/tRVEAAAAA9I8wkv5ozN6SZLY+Gl/GO80bCQAAALBOCCPpp27mjfyB8cnpzatbDgAAAAD9JIykn1YSRn49yY1JjkjyyFWvCAAAAIC+EUbST8sOI+t5Iz9RH5672gUBAAAA0D/CSPppJT0jkwNDtf/D6pUCAAAAQL8JI+mnlYaRH6nbHxyfnD58FesBAAAAoI+EkfRTK4w8I42xsoz3fSPJ1UkOT/IDq14VAAAAAH0hjKSfZup2Z5Kjlvym5ryRH64Pn7rKNQEAAADQJ8JI+qcxe2eS6+qj5Q7VFkYCAAAArHHCSPqt23kjzxmfnD56FesBAAAAoE+EkfTbisLImamJq5N8PUlJ8uTVLgoAAACA3hNG0m/fqdvl9oxMkn+tW0O1AQAAANYgYST9ttJh2ol5IwEAAADWNGEk/dZNGPnxJPuS3G98cnol7wcAAABggISR9FsrjBxPY2xZz9/M1MTtST5bHz5lVasCAAAAoOeEkfTbFWn2btyS5MQVvL81b+TTVq0iAAAAAPpCGEl/NWb3phlIJt3NG/mU8clpzy8AAADAGiLMYRC6mTfy80l2JTkmyUNXrSIAAAAAek4YySCsOIycmZq4J8nH6sOnr1ZBAAAAAPSeMJJB6KZnZJJ8sG5/ZBVqAQAAAKBPhJEMQrdh5HTd/sD45PRRq1APAAAAAH0gjGQQugojZ6YmZpJ8PcnGGKoNAAAAsGYIIxmEVhh5nzTGDlvhPVq9IydWoR4AAAAA+kAYySBcm2R3ms/ffVd4j1YY+cPjk9MbV6UqAAAAAHpKGEn/NWarJDP10Urnjfx0ktkkxyZ51CpUBQAAAECPCSMZlO/U7RkrefPM1MQ9Sf6lPjRUGwAAAGANEEYyKN+q2zO7uId5IwEAAADWEGEkg3JZ3Z7VxT3+OUmV5OHjk9Mnd18SAAAAAL0kjGRQWj0jVxxGzkxNXJ/kC/XhD3ddEQAAAAA9JYxkUFo9I++Xxlg3z6Gh2gAAAABrhDCSQflukr1JDk9yShf3aYWRTxufnN7SdVUAAAAA9IwwksFozO7NgRW1u5k38ktJrk2yPcl/6LYsAAAAAHpHGMkgdb2IzczUxP4kf18fPqfrigAAAADoGWEkg9T1Ija1d9ftT45PTm/u8l4AAAAA9IgwkkHqumdk7ZNpDtU+MslTu7wXAAAAAD0ijGSQViWMnJma2JfkPfXh87qqCAAAAICeEUYySK0w8n5pjG3s8l7vqtsft6o2AAAAwHASRjJI30tyT5LNSU7t8l6fTnJVkp1Jnt7lvQAAAADoAWEkg9OY3ZfkO/VRt0O19yf52/rQUG0AAACAISSMZNBWaxGb5MCq2j82Pjl9xCrcDwAAAIBVJIxk0FYzjPxckiuSbE/yjFW4HwAAAACrSBjJoK1aGFkP1W71jjRUGwAAAGDICCMZtG/V7ZmrdL9WGHne+OT0zlW6JwAAAACrQBjJoLV6Rp6RxtjGVbjfF5J8I8nWJD+7CvcDAAAAYJUIIxm0K5LsSbI5yX27vdnM1ESV5E/qw5ePT06Xbu8JAAAAwOoQRjJYjdl9Sb5dH63GIjZJcmGSXUkemOQ/rNI9AQAAAOiSMJJhsJoramdmauK2JH9VH/7SatwTAAAAgO4JIxkGrUVsVqtnZJJcULc/Nj45feoq3hcAAACAFRJGMgxaPSNXa0XtzExN/HuSjyfZmOSlq3VfAAAAAFZOGMkwWNVh2m1avSNfPD45vXmV7w0AAADAMgkjGQatMPKMNMY2reJ935fk6iQnJHnWKt4XAAAAgBUQRjIMrkyyO8mmJOOrddOZqYl7krylPvyN8cnpslr3BgAAAGD5hJEMXmN2fw70jjx7le/+p0l2JTknyXNW+d4AAAAALIMwkmHxjbp94GredGZq4vokr68PX2vuSAAAAIDBEUYyLHoSRtbemOS6JPeLlbUBAAAABkYYybBohZGrPUw7M1MTu5I06sPfHZ+c3rnanwEAAADA4oSRDIsDPSMbY71YaOYvk1ya5Ngk5/fg/gAAAAAsQhjJsLg0yf4kRyY5YbVvXq+s/cr68NfHJ6dPWu3PAAAAAGBhwkiGQ2N2d5LL66NezBuZJH+f5DNJtiZ50/jkdC96YAIAAAAwD2Ekw6SXi9hkZmqiSvKrSfYleW6SF/TicwAAAACY21CGkaWUXyqlzJRSdpdSPldKefQS3/dTpZSqlPK+HpdIb/Q0jEySmamJL+bAYjYXjE9Oj/fqswAAAAA42NCFkaWU5yV5Y5JXJ3lEki8n+VAp5fhF3jee5A1JPtnrGumZS+q2Z2Fk7XVJPpVkR5K/Gp+c3tjjzwMAAAAgQxhGJvn1JP+rqqq3VlX19SQvS3Jnkp+f7w2llI1J3pHkvyb5Tl+qpBd63jMySWamJvYl+Zkktyf5wSS/1cvPAwAAAKBpqMLIUsrmJOck+XDrXFVV++vjxy3w1t9Ncn1VVX/Z2wrpsVYYeXIaY2O9/KCZqYnLk/xyffjq8cnpJ/by8wAAAAAYsjAyybFJNia5ruP8dUlOnOsNpZQfTPL/JXnxUj6glLKllLKztaU5VJdh0Ji9Ncm19dHZffjEv0ryf5JsSvIP45PT39+HzwQAAAAYWcMWRi5LKWVHmoHSi6uqunGJb3tlktm27coelcfK9GWodnLv6to/n+TTSY5M8sHxyelTe/25AAAAAKNq2MLIG5PsS3JCx/kTcqDHXLv7JRlP8oFSyt5Syt4kP5vkvPr4fnO853VJxto24dNw6VsYmSQzUxN3JTkvzcVzTk3yz+OT00f247MBAAAARs1QhZFVVe1JclGSp7TOlVI21MefmeMtlyR5cJKHtW3vT/LRev+KOT7j7qqqbmttaS5iwvDoaxiZJDNTEzcl+aEk1yR5UJpDtg3fBwAAAFhlQxVG1t6Y5MWllBeWUh6Y5E+TbEvy1iQppVxYSnldklRVtbuqqq+1b0luTXJ7fbxnQD8DK9f3MDJJZqYmvpvkR9IMp5+Y5KPjk9PH97MGAAAAgPVu6MLIqqreleQ3k7wmycVp9nD8oaqqWova3DfJSQMpjn5ohZFnpDF2eD8/eGZq4uI0e+HemOaq7p8an5w+o581AAAAAKxnpaqqQdcwUPWK2rNJxuph2wxSY6yk2bt1Z5IHpzH7tX6XMD45ff8kH0pzPtLrkvzIzNTE/+t3HQAAAABrwXLytaHrGcmIa8xWGdBQ7ZaZqYlLkzw+yZfTXDzp0+OT0y8fn5wug6gHAAAAYL0QRjKMBhpGJsnM1MQ1SZ6U5J+SbElyQZL3jk9OHz2omgAAAADWOmEkw2jgYWSSzExNzCZ5ZpJfS3JPkh9P8uXxyelnDLIuAAAAgLVKGMkwGoowMklmpiaqmamJNyV5bJLLkpya5IPjk9N/Pz45ffpAiwMAAABYY4SRDKOv1+3ZaYxtGmgltXoBm0ck+cMk+9LsJfn18cnpxvjk9PZB1gYAAACwVlhN22raw6cxtiHN/ybbk3x/GrNfX+QdfTU+Of39Sf4oyZPrUzcmeX2SC2amJu4YWGEAAAAAA2A1bda2xuz+JF+tjx46yFLmMjM18e9JnprkuUm+leTYJL+f5PLxyenzxyenxwZZHwAAAMCwEkYyrL5Stw8ZaBXzqOeS/Ns057V8UZJvJzkuyR8kuWJ8cvqN45PTpw2wRAAAAIChY5i2YdrDqTH2i0n+JMk/pzH7I4MuZzHjk9OHJfmPSc5P8n316X1J3pfkz5L828zUxP7BVAcAAADQO8vJ14SRwsjh1Bh7fJJPJbk6jdlTBl3OUo1PTpckz0jyG2kO5W75dpK3JLlwZmri2kHUBgAAANALwshlEEYOqcbYjiSt/x7HpTF74yDLWYnxyekHJ3lpkp9JsrM+vT/JvyT56yTvs+ANAAAAsNYJI5dBGDnEGmPfTnJGkqekMftvgy5npcYnp7cleV6SFyd5bNtLdyb5pyTvTTI9MzXh+QMAAADWHGHkMggjh1hj7L1JfiLJr6cx+4eDLmc1jE9On5nm3JIvSHJm20t7kvxbkg+m2XPykpmpidH+zQkAAACsCcLIZRBGDrHGWCPJf03ytjRmf27A1ayqem7Jc9IMW5+V5AEdl1yR5ENpBpMfnpmauKW/FQIAAAAsjTByGYSRQ6wx9hNpDmH+Uhqzjxh0Ob00Pjn9fUkmkjw9yROTbG57eX+Szyf5aJJPJvn0zNTEbN+LBAAAAJiDMHIZhJFDrDF2RpqrUO9Jsi2N2b0DrqgvxientyZ5UprB5DOSPLDjkv1JvpJmMPnJJJ+0QjcAAAAwKMLIZRBGDrHG2IY0/9tsT/KgNGb/fcAVDcT45PR9kjwtzR6TT0hzUZ9O30qz9+QX6vZLM1MTd/WtSAAAAGBkCSOXQRg55Bpjn0ry+CT/MY3Zdw66nGEwPjl9cpqhZGt7cJLScdm+JF9NM5z8QpL/l+TfZ6YmdvexVAAAAGAECCOXQRg55Bpjf5LkF5P8fhqzk4MuZxiNT04fleQxSR7Vtp04x6X7klya5MtpDvNutVdZuRsAAABYKWHkMggjh1xj7KVJ/izJB9OY/eFBl7MW1Ct1n5Lk0TkQTj4syTHzvOWWJN9I8s0kl9TbN5N8Z2Zq4p5e1wsAAACsbcLIZRBGDrnG2OOSfDrJNWnMnjzoctaqOqA8KclDkjy0rT07ycZ53rY3zbkoO0PKbye5QW9KAAAAIBFGLoswcsg1xrYnuS3NORGPT2P2hgFXtK6MT05vSTOQfEDdnt12vHWBt96RZCbJ5XNtM1MTfi8BAADAiBBGLoMwcg1ojF2W5MwkT01j9iODLmcUjE9Ob0hzqHdnUPmA+nzngjmdbk4zmPxukqvq7cq2/atmpibu7EnxAAAAQF8JI5dBGLkGNMb+LslPJvmNNGbfOOhyRl3dm/K0JKfPs803N2WnW3JwUHl1kuuSXN/WXp/kFkPCAQAAYHgtJ1/b1J+SoCtfTjOMfOigCyGZmZq4O81VuS+d6/XxyekdORBM3ifNnpSn1m1rf2uSo+rtQYt85N7xyelWMNkeVN6UZg/MubZdAkwAAAAYPnpG6hk5/Bpjz0zygST/nsbsYsEVQ65eTGcsB4eTpyQ5OcnxbdsJ9XUrcU8ODidn05x79LYkty9h/7Ykt89MTexb4ecDAADAyDBMexmEkWtAY+yEJNcmqZIcmcas/04joh4SflyawWR7SHl8kqPn2I5JsnkVS7gzya4kd9X77e1c5+a6Zk/HdvcSz92jdycAAABrgTByGYSRa0RjbCbNeQqfnMbsRwdcDUOq7nV5RA4NKHd2bDvm2W8db+l37fOokuxLsrdu27elntuXZH99r/YtPTxOj9vVvmf7r1037d4cGjDf3bF/yGt64AIAAGudOSNZjz6fZhj56CTCSOZU9yS8s96uXOl96h6ZrZByW5oB59YVtIen2VNzrm3LHMedq5SXNL+nfVevY+OT0/tzaFC5Owee5aVsdyzy2u1pzqW6v18/FwAAwFz8BZe14vNJnpNmGAk9VS/Sc3eSG/v5ueOT0xtzIJg8LMnGetvUtr9xkfNznduQZrDZ2tLD48zTLvTaUttevbfz126l7WH1tiUHwub52nYb0gywj0iPjU9O78rBc6Te3rG/WDub5NYkd5lGAAAAWAnDtA3TXhsaY09M8vEkV6Uxe+qgywFYqXo6gcOycFh5eJq9a5ezbZvn/PY0w9LVtCfNUPLWJLfMsb/QudmZqYl7VrkeAABggMwZuQzCyDWiMbYtzZ45G5KcmsbsVQOuCGBNqMPPw3NgTtQdOXi+1KW2rW3DKpS1K81w8qY0V7y/aQn7t8xMTexdhc8GAABWmTByGYSRa0hj7MtJHpLkJ9KYfd+AqwEYOXWwuT3JUUmObGuXur+jyxJms7Tgsr2dNaQcAAB6ywI2rFefTzOMfHSS9w22FIDRU4d6rXkmv7fc949PTm9KMpZmQHlUmqvdH5MDK9/Ptz9W32Ks3s5YxsfuG5+cbg8rF9purNubZ6Ym9iz35wMAABYnjGQt+XySX0jymEEXAsDy1cOsW8HfktUhZiu8XCy4bN/fmuZ8mcfV23I+8/YsPbxsbbv0wgQAgIUZpm2Y9trRGHtIki+n2SPnyDRm9w+4IgCG2Pjk9OE5EFAudTs6B1ZbX657srzw8qaYCxMAgHXAnJHLIIxcQxpjm9L8b7U1yfelMfuNAVcEwDozPjm9Mc35LZcTYB6b5kroK3Vrlhdg3jQzNXFnF58HAACrShi5DMLINaYx9okkT0jyojRm3z7ocgCgXthna5bfC/PILj52dzpWG08z1Lxlsf2ZqYndXXwuAAAcwgI2rGefTzOMfEwSYSQAA1fPE3lHvS15YZ96Lsz2uS6X2gtzU5LDk5xSb8syPjm9O4eGlEsNM82LCQBAV4SRrDWfr9tHD7QKAOhSPVfk9fW2JHUvzB05OKBsrU5+ZNt+5/GR9VbSDDJPqrfl2jc+OX1rDoSUt6X5L+Cz8+zPdU6gCQAwwgzTNkx7bWmMnZZkJsneJDvSmDXUDACWYHxyekOSnZk7qFxKoHnYKpWyP83F6BYKMRfbvz3JHqEmAMBwMGfkMggj15jGWElybZLjkzwujdnPDrgiAFj36h6ZR+TgoHKs3nbOsT/XubEkG1exrL1phpLt2645zi3p/MzUxN2rWBsAwEgRRi6DMHINaox9IMkzk/xaGrNvGnA1AMAStAWaywkw5zq3rUcl3pPlBZq7cmCu0Pb99nN6bwIAI0EYuQzCyDWoMfbKJK9N8ndpzD570OUAAP0zPjm9Mcn2NOfO3NGxv2MJ5ztfO6KH5e7LoQHlXKHlss/NTE3s6WHdAADLIoxcBmHkGtQY+4Ek/zfJDUlOSGN2tB9iAGDF6lXNW+HkUgPM1vG2emvf35Zkcx9K35u5Q8s7ktyV5M629s45zi30Wmv/rpmpiX19+FkAgDVOGLkMwsg1qDG2Jc0VPA9P8sA0Zi8ZbEEAAAeMT04floPDyfatM7hc7rlNffxRkmRPVhZs7l7mdnfb/l7D2wFgbRFGLoMwco1qjH00yblJXprG7FsGXA0AQF+MT05vzsKh5dY0h55v7djvbBc6d3jffqC57c/KQsy5tj31NXsW2BZ6/e4IRwFgUcvJ1/r9L6uwWj6RZhj5xCTCSABgJNRzRe5JckuvPmN8cnpDmoFkN8Hm4QtsW+Y41z60fUPbfYfC+OT0SoPMPWkujtTa9tZbv/b31dv+jvagc8JWAPpJz0g9I9emxthTknw4yZVJ7mveSACAtasOQOcKKRcKMJeybZ5j2zLP+fbXS29/4qFTZQmhZRfnqgW2LPL6Srel3LeldLTz7S/2eq+uXerrC12/3LZf71kLn9fSr2d3tZ75zt+T7e1Cry3WdvvevYts+5ZwTfvmH1SGhGHayyCMXKMaY9vSnDdyU5Iz0pi9fLAFAQCwHoxPTpckG7NwWLmc17ak+WfW1nbYMvaXc+1c+xszesEqMHpWEmJ2vueePm17ZqYmvtCjX4eBMkyb9a8xe0caY19M8tg0h2oLIwEA6Frdw6b1l9M7B1xO1+pwdUOawWSr3bjIuW5fbz/XCkTbt8xxbinbar+vvWdO1dHOt7/Y6726dqmvL3T9ctt+vWctfN5qPYu92uaqZ0MO/T0537mltt28t/17YtMSt405+B9Y5tO6ZssC1wyLuzJE05AMijCStewTORBGvn3AtQAAwNCpw9XWsGmANaue0mM5AeZytsP6tO1e9V+YNUgYyVr2iSSvSDOMBAAAANapmamJ/TmwSBhr2IZBFwBd+FSa3ebPTGPs5EEXAwAAAMDChJGsXY3ZW5N8uT56wgArAQAAAGAJhJGsdZ+oW0O1AQAAAIacMJK1ThgJAAAAsEYII1nrPlm3D0pj7JiBVgIAAADAgoSRrG2N2euTfKM+OneAlQAAAACwCGEk68G/1u3TB1oFAAAAAAsSRrIe/EvdPiONsTLQSgAAAACYlzCS9eDjSe5JclqSMwdcCwAAAADzEEay9jVmdyX5VH1kqDYAAADAkBJGsl60hmoLIwEAAACGlDCS9eJDdfvkNMYOG2glAAAAAMxJGMl6cXGSG5NsT/LYwZYCAAAAwFyEkawPjdn9Sf61PjJUGwAAAGAICSNZT8wbCQAAADDEhJGsJ62ekY9KY+zogVYCAAAAwCGEkawfjdmrkvx7kpLkKQOuBgAAAIAOwkjWG0O1AQAAAIaUMJL15kN1+4w0xspAKwEAAADgIMJI1ptPJrkryX2SPGywpQAAAADQThjJ+tKYvTPJP9dHzx5kKQAAAAAcTBjJevR3dfssQ7UBAAAAhocwkvXoH5PsSfKAJN834FoAAAAAqAkjWX8as7flwKrazxpkKQAAAAAcIIxkvTowVBsAAACAoSCMZL16f5K9SR6SxthZgy4GAAAAAGEk61Vj9uYk/1Yf6R0JAAAAMASEkaxnhmoDAAAADBFhJOvZ+5LsT/LINMZOG3AtAAAAACNPGMn61Zi9Pskn66OfHGQpAAAAAAgjWf/eU7fPH2gVAAAAAAgjWffenWRPkkelMfbIQRcDAAAAMMqEkaxvzaHaf1sfvXyQpQAAAACMOmEko+CCun1+GmPHDLQSAAAAgBEmjGQUfDbJxUkOT/KigVYCAAAAMMKEkax/jdkqB3pH/mIaY557AAAAgAEQyjAq3plkNsn9kjxjwLUAAAAAjCRhJKOhMXtnkrfWRxayAQAAABgAYSSj5E/rdiKNsdMHWgkAAADACBJGMjoas5cm+dckJcmvD7gaAAAAgJEjjGTU/H7dviyNsQcMtBIAAACAESOMZLQ0Zj+S5B+TbEry+gFXAwAAADBShJGMovOT7E3yo2mMPWXQxQAAAACMCmEko6cxe0kOLGbzxjTGNg6yHAAAAIBRIYxkVL06ya1JHpLkRQOtBAAAAGBECCMZTY3Zm5K8pj76vTTGdg6yHAAAAIBRIIxklF2Q5LIkJyT5szTGyoDrAQAAAFjXhJGMrsbsniQ/l2RfkucnedlgCwIAAABY34SRjLbG7KeS/FZ99KY0xh45yHIAAAAA1jNhJCRvTPK+JJuTvCeNsaMHWw4AAADA+iSMhMZsleZw7e8kOS3JhWmMbRpsUQAAAADrjzASkqQxe2uSZye5O8lEkr8WSAIAAACsLmEktDRmv5TkeUnuqdt3pjF22GCLAgAAAFg/hJHQrjH7D0melWYg+ZwIJAEAAABWjTASOjVmP5DkJ5PsSXPo9j+kMXbMYIsCAAAAWPuEkTCXxuw/JvmJNOeQ/OEkF6cx9sTBFgUAAACwtgkjYT6N2X9K8tgklyY5NclH0xj73TTGNg62MAAAAIC1SRgJC2nMXpzknCRvT/P3y6uTfCWNseekMeb3DwAAAMAylKqqBl3DQJVSdiaZTTJWVdVtg66HIdYYe0GSP05yZH3my0kaSf4xjdm9A6oKAAAAYKCWk68JI4WRLEdjbCzJr9XbzvrsdUneneSdST6Xxuxo/6YCAAAARsqaDyNLKb+U5PwkJ6bZ++xXqqr6/DzXvjjJzyZ5UH3qoiSvmu/6Od4vjGT5GmNHJ/nNJC9NcnTbK1ck+UiSf0vy0TRmrxxAdQAAAAB9s6bDyFLK85JcmORlST6X5D8neU6SB1RVdf0c178jyaeSfDrJ7iS/leYqyN9fVdVVS/g8YSQr1xjbnORpSZ6f5MeTbOu44vI0n+PPJfl8ki+nMXtHP0sEAAAA6KW1HkZ+LskXqqr65fp4Q5q9zf64qqqpJbx/Y5JbkvxyVVUXLuF6YSSrozG2NckPJnlyvZ2TQxeJqpJcluQrafb6vbQ+viyN2V39KxYAAABgdazZMLKUsjnJnUmeXVXV+9rOvz3JkVVV/dgS7rEjyfVJnlNV1T8u4XphJL3RnF/yUUkeU2+PTnLCAu+4Ick1ac5BeW1He12Sm5PclubzeluSu81PCQAAAAzaWg4jT05yVZLHV1X1mbbzf5DkSVVVPWYJ9/iTJM9Ic5j27jle35JkS9upHUmujDCSfmiMnZDkoUkekuTBSc6qt2NXcLd7cnA42bnffrwrzaC/td0xx/FdVgUHAAAAlms5YeSm/pTUH6WUySQ/leTcuYLI2iuT/Nf+VQVtGrPXJfmXems7P3ZUktPS7Dl5Yt2275+Y5Mg0V/DeUb/rsCTH1Nsq1Te2J4cGlruT3J1kT0e7lP17kuxNsm+RdinX7E9zmHvVsd+L4yQpHe1c54btmsWs5nWr/ZnJgf8Wy9v0EAYAAFgzhq1n5IqHaZdSfjPJ7yR5alVVX1zgOj0jWdsaYxuSbE8ylmY4uXOB/dbxtiRb6619v7UtJzCCYbRQYLlYyNkKxO9Zwv5Sr5tr/57MHezP1851bp/wFQAAGDZrdph2cu8CNp+vqupX6uMNSb6X5M3zLWBTSnlFkt9O8oyqqj67zM8zZySjrTFWkhyeQwPKbfXWCvA3d7Tz7befOyzJxjR7Yc/XLvRa+zUb0gxNW9tix6NmsS/zXr/e7T3m+m/JoaqsPNC8e5Fzc21LuW6PKR6AdaP556LW/4s21u1C+8N43TDWtJzrFhsdspyRJKs1MqVloZE1q/Hact/b+ofVffW2lP2Vvrac6/YuYdu3xOsOfV9jdn+AobPWw8jnJXl7kpcm+XyS/5zkuUnOrqrqulLKhUmuqqrqlfX1v5XkNUl+Osmn2m61q6qqRVcnFkbCOnXgLxNLDS/bj1tfjJ3tUs+t5vWHvjYKPeMO/svgam1z3W9jvR2WA8H3au13Hm/OwgH+fO1aCGb3Z3WCzZVed08O7cHa3jNVj1JW1/yB1XK2UX/fsAZra+E7F0ZdK/xcSZjZTRg63581+nmNKYoYWms6jEySUsovJzk/zXnyLk7yq1VVfa5+7WNJZqqqelF9PJPmXHudXl1VVWMJnyWMBGA4NQOPjVm8J/Ji7ULbSq9Za39h7/xLx1x/yF8o0Gz9xaVz6H/nNAAreW2u61rm6rHTvr/Y692+r/0fa3rR9vLevWwhORCI7J9jf6HXlnrdqN6/vdfbfP9Iu5R/yF3JtQu91vkP3fP9A3c/r+kM1TfOsb/Qa0u9brn36BzhtNg237Ubw1yGKRzt1zX+YXkNWPNhZD8JIwFgmZoh6aasXrDZbUja3gPVX1wYNgvNW9sZwCx1Wyvvm++9Vdv5YQzDFr/OX4qh9w78o+xKw8xuwtD26aY6R77MdW03r883uoaDtf/D8moEn/sGtO1JY/b9q/2LMwyEkcsgjASAdeTAX1zm+4N/t+fn6tk3X0+/bq6bq5fOfPvLuXa572sFR71s+/EZvWjnC9QODt2EVgCsRHPh0m4CzX6Epr34jA2r8cs3xO5KY3broIvoheXka5v6UxIAQB80g5/Wv3gDAKxNzYV69tTb6Dg4hO1lqLpxQNvdq/eLtXbpGalnJAAAAACs2HLytfXe/RUAAAAAGBLCSAAAAACgL4SRAAAAAEBfCCMBAAAAgL4QRgIAAAAAfSGMBAAAAAD6QhgJAAAAAPSFMBIAAAAA6AthJAAAAADQF8JIAAAAAKAvhJEAAAAAQF8IIwEAAACAvhBGAgAAAAB9IYwEAAAAAPpCGAkAAAAA9IUwEgAAAADoC2EkAAAAANAXwkgAAAAAoC+EkQAAAABAXwgjAQAAAIC+EEYCAAAAAH0hjAQAAAAA+kIYCQAAAAD0hTASAAAAAOgLYSQAAAAA0BebBl3AENlRShl0DQAAAACw1uxY6oXCyAO/WFcOtAoAAAAAWNt2JLltoQtKVVV9qmU4lWZ3yJOT3D7oWnpoR5ph66lZ3z8nJJ53Ro9nnlHieWfUeOYZJZ53Rs16fOZ3JLm6WiRsHPmekfUv0FWDrqOX2oaf315V1YLpNKx1nndGjWeeUeJ5Z9R45hklnndGzTp95pf0c1jABgAAAADoC2EkAAAAANAXwsjRcHeSV9ctrHeed0aNZ55R4nln1HjmGSWed0bNyD7zI7+ADQAAAADQH3pGAgAAAAB9IYwEAAAAAPpCGAkAAAAA9IUwEgAAAADoC2HkOlZK2VJK+f1SytWllLtKKZ8rpTxt0HVBN0op55ZSqnm2x3Zc+/hSyv8tpdxZSrm2lPJHpZTtg6odFlNK2V5KeXUp5YOllJvr5/pF81z7wPq6XfW1f1VKOW6O6zaUUl5RSrm8lLK7lPKVUsrze/7DwCKW+ryXUt42z3f+JXNc63lnKJVSHlVKeXMp5d9LKXeUUr5XSnl3KeX+c1zr+501b6nPvO941oNSyveXUv62lPKd+u+eN5ZSPlFK+dE5rvUdn2TToAugp96W5NlJ3pTksiQvSvJPpZT/UFXV/x1cWbAq/ijJFzrOfau1U0p5WJKPJPlGkl9PcmqS30xyVpIf7k+JsGzHJvndJN9L8uUk5851USnl1CSfSDKb5FVJtqf5fD+4lPLoqqr2tF3+e0kmk/yvNH/P/FiSd5ZSqqqq/k+Pfg5YiiU977W7k/xCx7nZOa7zvDOsfivJDyT52yRfSXJikl9O8v9KKY+tquprie931pUlPfM13/Gsdacl2ZHk7UmuTrI1ybOSvL+U8tKqqt6S+I5vV6qqGnQN9EAp5dFJPpfk/Kqq3lCfOzzJ15JcX1XV4wdZH6xUKeXcJB9N8pyqqt6zwHX/lORhSc6uquq2+twvpPll/oyqqv6l58XCMpVStiQ5qqqqa0spj0zzDx4/V1XV2zqu+5M0/4Hp7Kqqvlefe2qSf03S/geeU5JcnuQtVVX9cn2uJPl4ktOTjFdVta8fPxt0Wsbz/rYkz66qasGe7Z53hlkp5fFJvtj+F81SyllJvprkPVVVvaA+5/uddWEZz/zb4juedaiUsjHJRUkOr6rq7Pqc7/iaYdrr17OT7EvyltaJqqp2J/nLJI8rpdxnUIXBaiml7CilHNLDu5SyM8nTkvx1K4isXZhkV5Ln9qlEWJaqqu6uquraJVz6rCT/2PpDTP3eDye5NAc/3z+W5LAkf9J2XZXkT9PsLfy41agbVmIZz3uS5h/q6+/3+XjeGVpVVX26o8dLqqq6LMm/J3lg22nf76wLy3jmk/iOZ/2pw8IrkhzZdtp3fE0YuX49PMmlHUFMkny+bh/W33Jg1b01yW1JdpdSPlr3qml5cJrTUHyx/Q31H4guTvP3B6xJ9b+UHp+O57v2+Rz8fD88yR1pTlfQeV3i9wJrx9Y0v/Nn6/mVLiiHzgHseWdNqXu5nJDkxvrY9zvrWucz38Z3POtCKWVbKeXYUsr9Sim/lub0YB+pX/Md38ackevXSUmumeN869zJfawFVtOeJH+X5J/S/IPM96U5z8YnSymPr6rqS2k+/8n8vwee0I9CoUcWe76PLqVsqarq7vra66pD52Tx/wLWkmuS/EGS/5fmP6T/UJKXJ3loKeXcqqr21td53llr/mOSU9KcOzXx/c761/nMJ77jWV/+R5KX1vv7k7w3zblSE9/xBxFGrl9HpDkRcKfdba/DmlNV1aeTfLrt1PtLKe9Jc2Ls16X5B5jW8z3f7wHPP2vZYs9365q74/8FrANVVb2y49T/KaVcmubE7s9O0prE3fPOmlFKOTvJBUk+k+aCB4nvd9axeZ553/GsN29K8p40w8LnJtmYZHP9mu/4NoZpr193Jdkyx/nD216HdaGqqm8l+Yck/6GeKLj1fM/3e8Dzz1q22PPdfo3/F7Be/WGaPQ6e2nbO886aUEo5Mcl0mqupPrttEQLf76xLCzzz8/Edz5pUVdUlVVV9uKqqC6uqemaaq2V/oJ6iwHd8G2Hk+nVNDnQDbtc6d3Ufa4F+uCLNf3XalgPd1+f7PeD5Zy1b7Pm+uR7e0br2xPoPQJ3XJX4vsEZVVXVXkpuSHN122vPO0CuljCX55zQXNPihqqran0vf76w7izzzc/IdzzryniSPSnL/+I4/iDBy/bo4yf3nWJHsMW2vw3pyRprd1ncl+VqSvUnaF7VJKWVzmos3Xdzn2mDVVFV1VZIb0vF81x6dg5/vi9OcFL5z1Ur/L2BNK6XsSHJsmr8XWi6O550hVko5PMkH0vxL6TOrqvp6++u+31lvFnvmF3if73jWi9Zw6jHf8QcTRq5f70lzfoKXtE6UUrYk+bkkn6uq6opBFQbdKKUcN8e5hyY5L8m/VFW1v6qq2SQfTvKC+g8zLT+TZlf5v+1LsdA7f5fkmaWU+7ROlFKekuYf9tuf739Ick+aE8G3ritJXpbkqhw8/yoMnVLK4R3f4y3/JUlJ8sG2c553hlY9jcy7kjwuyXOqqvrMPJf6fmddWMoz7zue9aKUcvwc5w5L8rNpDqluBfG+42sWsFmnqqr6XCnlb5O8rv6N8a0kL0wynuT/G2Rt0KV3lVLuSvML+Po0V9N+SZI7k0y2Xffb9TUfL6W8JcmpSX4jzcDyg4EhVUr55TSHMrVWyfvRUsqp9f4f12H7a5M8J8lHSyn/M82Q/fwkX03y1ta9qqq6spTypiTn138g+kKSH09zRfn/uIQ5m6CnFnvekxyV5EullL9Jckl9/hlJfiTNv6T+Q+tenneG3P9I8x9OP5DmiqkvaH+xqqq/rnd9v7NeLOWZPzG+41kf/rwelfqJNMPCE9NcPf7sJL9RVdWu+jrf8bVy6ErhrBd1t/j/luQFaf5h/itJ/ktVVR8aaGHQhVLKr6b5xX5mkp1pdnX/SJJX1wvZtF/7g0l+P8kjktye5N1JXllV1e19LRqWoZQyk+S0eV4+vaqqmfq670/yxiQ/mGRPmhPD/0ZVVdd13G9Dkt9K8tI055m5LMnrqqp6Ry/qh+VY7HlPcmuaoeRj0wwsN6b5D6zvSPKGqqru6bif552hVEr5WJInzfd6VVWl7Vrf76x5S3nmSylHxnc860Ap5afS7PT14CTHpPl3z4vS7Ejw/o5rfcdHGAkAAAAA9Ik5IwEAAACAvhBGAgAAAAB9IYwEAAAAAPpCGAkAAAAA9IUwEgAAAADoC2EkAAAAANAXwkgAAAAAoC+EkQAAAABAXwgjAQBYNaWUt5VSZgZdR7+UUl5USqlKKY8cdC0AAGuBMBIAYATUgdlStnMHXSsAAOvXpkEXAABAX/xMx/HPJnnaHOe/0eXnvDj+wRsAgHkIIwEARkBVVX/dflxKeWySp3We71RK2VpV1Z3L+Jx7VlgiAAAjwL9aAwCQJCmlfKyU8rVSyjmllE+UUu5M8tr6tR8rpUyXUq4updxdSvl2KeW/lFI2dtzjoDkjSynj9fDv3yylvKR+392llC+UUh61xLqOLKW8qZRyRf3eb5VSfquUsqHtmvbP+bVSyndLKXeVUj5eSnnQHPd8cinlk6WUO0opt5ZS/qGU8sA5rjullPKXbT/35aWUPy2lbO64dEsp5Y2llBvqe/59KeW4pfx8AACjRM9IAADaHZPkn5P8nyR/neS6+vyLkuxK8sa6fXKS1yTZmeT8Jdz3p5PsSPLnSaokr0jy3lLKGQv1piylbE3y8SSn1O/9XpLHJ3ldkpOS/OeOt/xs/TkXJDk8yX9K8m+llAdXVXVdfc+n1j/jd5I0khyR5FeSfKqU8oiqqmbq605O8vkkRyZ5S5JL6jqenWRrkj1tn/vHSW5J8uok43Vdb07yvCX82gAAjAxhJAAA7U5M8rKqqv684/xPV1V1V9vxn5VS/izJy0spv1NV1d2L3Pe+Sc6qquqWJCmlfDPJPyR5RpJ/XOB9v57kfkkeXlXVZfW5Py+lXJ3k/FLK/6iq6oq268+sP+eq+nM+mORzSX6rvleSvD7JzUkeV1XVzfV170vypTTDxBfW172u/vV4TFVVX2z7jN8tpZSOOm9K8vSqqqr6fhuS/GopZayqqtmFf2kAAEaHYdoAALS7O8lbO0+2B5GllB2llGOTfDLNHoJnL+G+72oFkbVP1u0Zi7zvOfW1t5RSjm1tST6cZGOSJ3Zc/75WEFnX/fk0w8gfqWs/KcnDkrytFUTW130lyb+2XbchyY8n+UBHENm6vuo49ZaOc5+s6zttkZ8PAGCk6BkJAEC7q6qq2tN5spTy/Un+e5rDs3d2vDy2hPt+r/2gqqpb6s6FRy3yvrOSPCTJDfO8fnzH8WVzXHNpkufW+61w8JtzXPeNJM8opWxLsj3Nn/Nri9TX8r2O41bwutjPBwAwUoSRAAC0u6vzRCnlyDTnbbwtye8m+XaS3UkekeT3s7TRNvvmOd853LnThjR7LP7BPK9fuoTP7oeV/nwAACNFGAkAwGLOTXNhm5+squoTrZOllNP78NnfTrK9qqoPL/H6s+Y4d/8kM/X+d+v2AXNcd3aSG6uquqOUclea4eshK3EDALBy5owEAGAxrV5/9/byK6VsTvLyPnz2u5M8rpTyjM4XSilHllI6/3H9x0spp7Rd8+gkj0lz9exUVXVNkouTvLDu8dm67kFJnp7kn+rr9id5X5IfLaU8co7P1uMRAGAF9IwEAGAxn05zDsS3l1L+KEmV5GfSnyHIr09yXpJ/LKW8LclFSbYleXCSZycZT3Jj2/XfSvJ/Syl/mmRLkv+c5krX7cO8z08znPxMKeUvkxyR5FeSzCZptF33qjQDyo+XUt6S5pySJ6W5qM4PJrl1tX5IAIBRIYwEAGBBVVXdVEp5ZpL/keYiNrck+eskH0nyoR5/9p2llCelGQw+J8nPpjl8+tIk/zXNALHdhUn2pxlCHp/k80l+ue4R2brnh0spP5Tk1Ulek+SeNOfE/K2qqi5vu+6qUspjkvy3JP8xzQVtrkozyLxz1X9YAIARUKqqGnQNAADQlVLKeJLLk5xfVdUbBlwOAADzMGckAAAAANAXwkgAAAAAoC+EkQAAAABAX5gzEgAAAADoCz0jAQAAAIC+EEYCAAAAAH0hjAQAAAAA+kIYCQAAAAD0hTASAAAAAOgLYSQAAAAA0BfCSAAAAACgL4SRAAAAAEBfCCMBAAAAgL74/wEOoo+f47C1hgAAAABJRU5ErkJggg==", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABSMAAAKvCAYAAACRY9qRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABhX0lEQVR4nO3deZhkd10v/vd39snMpLNnsneAQJCwhgBBkCgQwIbgvbIIcgH9ySLuSrDBrUCBFhC9CldBvSwXUJCLCraAwpVFCFsk7CQE0pA9ZOusM5OZOb8/6lSm0umtuqurqrter+c5z/ecU6dOfTo5XZm857uUqqoCAAAAALDS1vW7AAAAAABgOAgjAQAAAICeEEYCAAAAAD0hjAQAAAAAekIYCQAAAAD0hDASAAAAAOgJYSQAAAAA0BPCSAAAAACgJzb0u4B+K6WUJMcmubnftQAAAADAKrUjyRVVVVXzXTT0YWSaQeRl/S4CAAAAAFa545NcPt8FwsgDPSKPj96RAAAAANCpHWl29lswWxNGHnBzVVU39bsIAAAAAFhNmrMgLo4FbAAAAACAnhBGAgAAAAA9IYwEAAAAAHpCGAkAAAAA9IQFbAAAAAAYWOeff/6OJMdEp7p+2J/kytNPP33BVbIXq1RV1a17rUqllIOTTCcZsZo2AAAAwGA4//zz1yV5xfr1659bStmYZPFLNtMtVVVVd+zbt++dSV5z+umn75/tok7yNT0jAQAAABhEr9i4ceMv7ty5c8+2bdtuK6UMd4+6Pqiqqtx6660HXXXVVb94xx13JMkfLfeeekbqGQkAAAAwUM4///yD169f/6Vjjz1241FHHXVdv+sZdtdcc83hV1xxxR379u07fbYh253ka8baAwAAADBodpZSNm7btu22fhdCUvdM3Zjm3J3LIowEAAAAYNCsS1IMzR4M9b+Hki5kicJIAAAAAKAnhJEAAAAAQE8IIwEAAABgDfnpn/7p0eOOO+7+/a5jNhv6XQAAAAAADINSyumLue5DH/rQRU9+8pPvtmr1WiCMBAAAAIAeePOb33xJ+/G73/3uwz/72c8ePPP8Ax/4wNuX8znvec97vr9///7l3GLFCCMBAAAAoAde8pKXXN9+/LnPfW77Zz/72budn+nmm29et2PHjkWni5s3bx7YVcjNGQkAAAAAA+JhD3vYfU455ZT7ffrTnz7ooQ996H22bt364F/7tV87Lkne9a53HXLWWWfd66ijjnrApk2bHnLCCSecdu655x6zd+/eu9xj5pyRF1544aZSyum///u/f/Qb3vCGI0444YTTNm3a9JDTTjvtvp/85CcP6uXPp2ckAAAAAAyQG2+8cf1Tn/rUU84555zrf+Znfua6nTt37k2Sd7zjHYdv27Zt/4tf/OKrt2/fvv8Tn/jEjje84Q3H3nTTTevf8pa3XLbQfd///vcfduutt65/3vOe98NSSt70pjftfOYzn3mv73//+1/rVW9KYSQAAAAAq8L+qsptu/cOzEjfgzZv2L+ulK7f99prr934ute97vvnnnvute3n//Ef//F727dvvzM0fNnLXvbDZz/72Se+853vPPLP/uzPLt+6deu8geKVV1656aKLLvr6kUceuS9JTj311F3Pec5z7vWBD3zg4Gc961nTXf9BZiGMBAAAAGBVuG333nWnNf7twf2uo+XrjbO/vH3Lxq6vFLNp06bqV37lV66beb49iLzhhhvW7dq1a92jH/3oW/7u7/7uyAsuuGDLmWeeOe/CN09+8pNvaAWRSXL22WffkiTf/e53N3ez/vkIIwEAAABggBx11FF7tmzZcrdejl/60pe2vPzlLz/uc5/73I5bbrllfftrN9544/qZ18904okn7mk/bgWTN9xww4Lv7RZhJAAAAACrwkGbN+z/euPsL/e7jpaDNm/oeq/IJJktiLz22mvXP/7xj7/Ptm3b9r/sZS+74l73utfurVu37v/Sl7500Ktf/erj9+3bt+B48fXr1886jLuqqu6PNZ+DMBIAAACAVWFdKVmJYdGrwYc//OEdN95444b3vOc9Fz7pSU+6pXW+l0Osu0EYucaNjk8ek+ThSa6bmhj7dL/rAQAAAKBzrV6N+/cfyGJ37dpV/uZv/uaovhW1BMLIte85SV6X5H1JhJEAAAAAq9BP/MRP3HLwwQfve+ELX3jyC17wgmtKKdV73/vew6tq3gW0B87ALIXOivl63Z7W1yoAAAAAWLKdO3fue//73/+dI4888o4//uM/PvbNb37zzsc85jE3veY1r7ms37V1oqy29LTbSikHJ5lOMlJV1U39rqfbRscnj09yaZK9SbZPTYzt7nNJAAAAAPM6//zzT92wYcNHTjnllFsOOuigXf2uZ9jddtttW77zne9s37t37xNPP/30b898vZN8Tc/Ite/yNB+GDUnu0+daAAAAABhiwsg1bmpirIqh2gAAAAAMAGHkcBBGAgAAANB3wsjhIIwEAAAAoO+EkcPha3UrjAQAAACgb4SRw+EbdXvy6Pjkjr5WAgAAAMDQEkYOgamJsWuTXFUf/kg/awEAAABgeAkjh4d5IwEAAADoK2Hk8DBvJAAAAAB9JYwcHnpGAgAAANBXwsjh0Qoj79/XKgAAAAAYWsLI4fHNuj16dHzyyL5WAgAAAEBXXHjhhZtKKaf/+Z//+eH9rmUxhJFDYmpi7JYk36sP79fPWgAAAACG1U/8xE/ca+vWrQ++4YYb5szlzjnnnJM3btz4kKuuump9L2vrBWHkcDFvJAAAAEAfPetZz7pu165d69797ncfOtvrN99887qPfexjhzz60Y++aefOnft6Xd9KE0YOF2EkAAAAQB8961nPunHbtm373/ve9x422+vvec97Drn99tvXPetZz7qu17X1gjByuFjEBgAAAKCPtm/fXj3hCU+44bzzzttx+eWXb5j5+nvf+97Dtm3btv9xj3vcLS984QuPv/e97/0jBx100IO3b9/+4B/7sR875bzzztvaj7q7RRg5XL5Wt6eNjk+WvlYCAAAAMKSe85znXL9v377yjne84y5Dta+++ur1n/70pw8+++yzb7j00ks3fuQjHznk8Y9//PSrXvWqS3/xF3/xqgsvvHDr2WeffZ+pqamN/ap9ue6WvrKmXZRkb5KDkxyf5NL+lgMAAADQgWp/sufWwelct2nb/pTOy3nKU55y05FHHnnHP/zDPxz+ile84oet8+985zsP3bt3b3nOc55z/RlnnHH7JZdc8vX16w+sYfMLv/AL1z3gAQ847c1vfvMRr3/966/szg/RW8LIITI1MbZndHzywjRX0z4twkgAAABgNdlz67q89vgH97uMO738si9n8479nb5tw4YNOeecc67/27/926MvvPDCTfe5z332JMn73ve+ww8//PC955xzzk0bNhyI7fbu3Ztrr712/cEHH7x/dHR01wUXXHBQF3+KnhqcJJleaQ3VflA/iwAAAAAYZs973vOuT5K3ve1thyXJd7/73Y3nn3/+9nPOOef6DRs2ZN++fXnlK1951EknnXTali1bTj/mmGMedOyxxz7woosu2nrzzTevn//ug0vPyOHzxSQ/k+QR/S4EAAAAoCObtu3Pyy/7cr/LuNOmbR33imx59KMffdvJJ5+86wMf+MBhExMTV7397W8/rKqqPO95z7suSV7+8pcf8/rXv/7Ypz/96dc+7nGPu/yII47Yt27duurcc889cf/+/at2LRBh5PA5r27PHB2fLFMTY1VfqwEAAABYrLIuSxkWPaie9rSnXf/617/+2M9//vNb3//+9x9+0kkn7X7MYx5zW5J88IMfPPThD3/4ze973/u+3/6eF73oResPPfTQvf2pePkM0x4WjZHWv+v/SrInyZFJ7tG/ggAAAACG28///M9flyS/8zu/c+y3v/3trT/90z99Xeu19evXV1V11z5k//t//+9Dr7nmmlW7knYijFz7GiM/m8bI15O8JkmmJsZ2pxlIJsmZfasLAAAAYMideuqpex784Aff+vGPf/yQJPm5n/u561uvnX322dNf+MIXdjztaU8b/ZM/+ZMjnv/855/wm7/5mycdf/zxu/tWcBcII9e+9Wmunv3jbec+V7fCSAAAAIA+esYznnFdktz//ve/9bTTTrszaHzNa15z5Qte8IKrP/WpTx38u7/7uyd87WtfO+j//t//+51jjjnmjv5Vu3xlZnfPYVNKOTjJdJKRqqpu6nc9XdcYOSnJVJJ9SQ5NY/rm0fHJZyR5b5IvT02MPaSf5QEAAADMdP7555+6YcOGj5xyyim3HHTQQbv6Xc+wu+2227Z85zvf2b53794nnn766d+e+Xon+ZqekWtdY/r7aYaR65M8sj7bWsTmAaPjk9v6URYAAAAAw0cYORw+WbePSZKpibFLk1yeZkB5Rr+KAgAAAGC4CCOHw13CyFqrd6R5IwEAAADoCWHkcGiFkWekMXJQvS+MBAAAAKCnhJHD4ZIklyXZmAPh451h5Oj4ZOlLVQAAAAAMFWHkMGhMV7n7UO3/SrInyRFJ7tmPsgAAAAAYLsLI4TFzEZvdaQaSiaHaAAAAwGDZnyRVVfW7DnKXfw/7l3svYeTw+ETdPiKNka31vnkjAQAAgEF0XVVVe/fu3buh34WQ7N27d0NVVXuTXLvcewkjh8fFSa5MsinJw+tzwkgAAABgEN1QVdVV09PTO/pdCMn09PSOqqquSnLjcu8lXR4WjekqjZFPJvmZNIdqfyIHwsgHjI5Pbp+aGLulX+UBAAAAtJx++un7zz///DfceOONf7F58+bDt2/ffmsp1t/ttaqqcsstt2y78cYb9+/fv//1p59++rKHaQsjh0t7GJmpibHLRscnL0tyfJLTc2BeSQAAAIB+++Add9xxvyuvvPJZpZTt/S5mWFVVdcu+ffv+LsmHunE/YeRwaYWNZ6YxsjmN6d1Jzk8zjHxwhJEAAADAgKh74b36/PPP/4skO2O6wX7Yn+Sq008//aZu3VAYOVy+neSaJEclOSPJfyb5cpKnphlGAgAAAAyUOgjrWhhGf0mUh0ljukryqfrox+r2y3X7kN4XBAAAAMAwEUYOn8/UbWtF7f+q2/uOjk9u7UM9AAAAAAwJYeTw+VzdPiKNkZLk8iTXJlmf5LS+VQUAAADAmieMHD5fTrInzXkjR6cmxqoYqg0AAABADwgjh01zBe1W+PiIum0N1baIDQAAAAArRhg5nFpDtc+s21Y4KYwEAAAAYMUII4fTgXkjm1ph5ANGxyc39KEeAAAAAIaAMHI4tcLIB6cxsjXJxUluSbIlyal9qwoAAACANU0YOZy+n+TqJBuSPHhqYmx/kgvq1wzVBgAAAGBFCCOHUWO6ytxDta2oDQAAAMCKEEYOr5lhpBW1AQAAAFhRwsjhNVfPyAePjk96LgAAAADoOqHT8PpSkv1JTkhj5Lgk30yyJ8nBSU7uZ2EAAAAArE3CyGHVmL4lyVfro4dPTYzdkeRr9bGh2gAAAAB0nTByuM05VLsPtQAAAACwxgkjh5sVtQEAAADoGWHkcGuFkQ9NY2RjrKgNAAAAwAoSRg637yS5IcnWJPfPgTkjjx4dnzy8b1UBAAAAsCYJI4dZY3p/kgvqo/tPTYzdmuSy+vjefakJAAAAgDVLGMnX6/a0ur2oboWRAAAAAHSVMJKZYeSFdXufPtQCAAAAwBomjETPSAAAAAB6QhjJN+r2+DRGDokwEgAAAIAVIowcdo3p6SQ/qI/ulwPDtE8ZHZ/0fAAAAADQNcImkrsO1f5+kjuSbElyQt8qAgAAAGDNEUaSHAgj7z81MbY3ycX1sUVsAAAAAOgaYSSJRWwAAAAA6IGBCiNLKT9WSvlQKeWKUkpVSvmpRbznrFLKf5VSdpdSLi6lPH/lK11zDoSRjZESYSQAAAAAK2Cgwsgk25J8JckvLebiUsrJSSaT/EeSByX5syR/U0p5wgrVt1Z9O8n+JIcnOToHFrExTBsAAACArtnQ7wLaVVX14SQfTpJSymLe8uIkl1RV9Vv18bdKKY9K8htJProiRa5Fjenb0xi5OM2ekKdFz0gAAAAAVsCg9Yzs1JlJPjbj3Efr87MqpWwupRzc2pLsWMkCV5H2eSNbPSNPGh2f3NqnegAAAABYY1Z7GLkzydUzzl2d5OBSylwh2suTTLdtl61ceavK1+r2tCQ/TPOfTUlyz75VBAAAAMCastrDyKV4bZKRtu34/pYzMFo9I+8/NTFWxVBtAAAAALpstYeRV6W54Eq7o5PcVFXV7bO9oaqq3VVV3dTakty80kWuEq0w8n5pjKyLRWwAAAAA6LLVHkael+SxM849vj5PZy5OsifNFc1Pip6RAAAAAHTZQIWRpZTtpZQHlVIeVJ86uT4+sX79taWUd7a95a+S3KOU8rpSyqmllJckeUaSP+1t5WtAY3pvkm/VR+2L2AgjAQAAAOiKgQojkzw0yZfrLUneWO+/qj4+JsmJrYurqrokyViavSG/kuS3kvxCVVUf7VXBa0z7itqtnpGGaQMAAADQFRv6XUC7qqo+keYKznO9/vw53vPgFStquLSHkX9e7x8+Oj55+NTE2HV9qgkAAACANWLQekbSX3eGkVMTY7cmuaw+NlQbAAAAgGUTRtKuFUbeN42R9bGIDQAAAABdJIyk3aVJ7kiyMclxsYgNAAAAAF0kjOSAxvS+JN+vj06ORWwAAAAA6CJhJDNdUrcnJ7m43r9nn2oBAAAAYA0RRjLTVN2enOQH9f4J/SkFAAAAgLVEGMlM7T0jL633Dx8dnzyoT/UAAAAAsEYII5mpFUaOJrkxyS318fH9KAYAAACAtUMYyUx39oycmhircqB35Il9qgcAAACANUIYyUytMPK4NEY2x7yRAAAAAHSJMJKZfpjktiQlzd6QekYCAAAA0BXCSO6qMV3lrovY6BkJAAAAQFcII5nNbCtq6xkJAAAAwLIII5nNVN22h5F6RgIAAACwLMJIZjPrMO3R8cnSp3oAAAAAWAOEkcymPYy8rN7fluTQ/pQDAAAAwFogjGQ2rTBydGpi7PY0V9hODNUGAAAAYBmEkcymFUYemcbI9ljEBgAAAIAuEEZyd43p6SQ31EejaZs3si/1AAAAALAmCCOZS/u8kVbUBgAAAGDZhJHMZapu28NIw7QBAAAAWDJhJHNp7xlpmDYAAAAAyyaMZC6zDdPWMxIAAACAJRNGMpfZekYeNzo+ub5P9QAAAACwygkjmcudYeQj1n3zyiT7kmxIcnT/SgIAAABgNRNGMpeput3x95v+aCTJ5fWxodoAAAAALIkwktk1pm9PclV91D5vpEVsAAAAAFgSYSTzsYgNAAAAAF0jjGQ+U3XbvoiNnpEAAAAALIkwkvnM1jNSGAkAAADAkggjmU97GNnqGWmYNgAAAABLIoxkPq0A8vjoGQkAAADAMgkjmc+VdXtMDgSTR4+OT27uUz0AAAAArGLCSObTCiMP/8Sm37g5ye318fF9qgcAAACAVUwYyXyuS3JHkoyuu3pnDNUGAAAAYBmEkcytMV3lQO/IY2MRGwAAAACWQRjJQtrnjWz1jBRGAgAAANAxYSQLaQ8jL2vbBwAAAICOCCNZyBV1e2ySq+r9nX2qBQAAAIBVTBjJQtp7RgojAQAAAFgyYSQLEUYCAAAA0BXCSBYyaxg5Oj5Z+lQPAAAAAKuUMJKFtM8ZeXW9f1CS7f0pBwAAAIDVShjJQlo9I4+c2vLs3Uluro8N1QYAAACgI8JIFvLDJPuSlCRHx7yRAAAAACyRMJL5Nab358DwbIvYAAAAALBkwkgWo33eSGEkAAAAAEsijGQxZl1Ru0+1AAAAALBKCSNZDGEkAAAAAMsmjGQxhJEAAAAALJswksUwZyQAAAAAyyaMZDH0jAQAAABg2YSRLMZsYeTRo+OTnh8AAAAAFk2YxGK0wsidT1v/yeuSVEnWJzm8fyUBAAAAsNoII1mMq9MMINe9YeNbDk1ybX3+mP6VBAAAAMBqI4xkYY3pvUmuqY/MGwkAAADAkggjWSyL2AAAAACwLMJIFqsVRh4bYSQAAAAASyCMZLGuqFs9IwEAAABYEmEki2WYNgAAAADLIoxksYSRAAAAACyLMJLFMmckAAAAAMsijGSxzBkJAAAAwLIII1msVs/IndtyeyuMPHR0fHJzvwoCAAAAYHURRrJYrQBy4xc3v2Rdkjvq46P7VA8AAAAAq4wwksVpTO9Jcl2SHFR2mzcSAAAAgI4JI+mEeSMBAAAAWDJhJJ1ozRspjAQAAACgY8JIOtEKIw3TBgAAAKBjwkg6ceeK2hFGAgAAANAhYSSd+GHdHhlhJAAAAAAdEkbSiWvqVhgJAAAAQMeEkXSi1TPyqAgjAQAAAOiQMJJOzNozcnR8svSpHgAAAABWEWEknbhzzshTymVX1/tbk+zoUz0AAAAArCLCSDrRCiPX//vml21OclN9bKg2AAAAAAsSRrJ4jendORBAmjcSAAAAgI4II+lU+7yRraHawkgAAAAAFiSMpFPtK2q3B5MAAAAAMC9hJJ1qDyBb+0f1qRYAAAAAVhFhJJ2arWekMBIAAACABQkj6ZSekQAAAAAsiTCSTukZCQAAAMCSCCPplJ6RAAAAACyJMJJO6RkJAAAAwJIII+nUbD0jDxkdn9zUp3oAAAAAWCWEkXSq1TPyiF/f8P7pJHvr4yP7VA8AAAAAq4Qwkk5dW7frfn3DBw7NXYdtAwAAAMCchJF0pjG9J8mN9ZF5IwEAAABYNGEkS2FFbQAAAAA6JoxkKayoDQAAAEDHhJEshZ6RAAAAAHRMGMlS6BkJAAAAQMeEkSyFnpEAAAAAdEwYyVLoGQkAAABAx4SRLIWekQAAAAB0TBjJUszaM3J0fLL0qR4AAAAAVgFhJEvR3jOyFUxuSbK9P+UAAAAAsBoII1mKVgB5+NSWZ+9Kcmt9bKg2AAAAAHMSRrIU19ZtSXJ4zBsJAAAAwCIII+lcY3pvkuvrIytqAwAAALAowkiWyoraAAAAAHREGMlSzbqidp9qAQAAAGAVEEayVHpGAgAAANARYSRLpWckAAAAAB0RRrJUekYCAAAA0BFhJEvVHkAKIwEAAABYkDCSpWoN09YzEgAAAIBFEUayVLP1jDxidHxyfZ/qAQAAAGDADVwYWUr5pVLKVCllVynl86WUhy1w/a+XUi4spdxeSrm0lPKnpZQtvap3iLX3jLy23l+X5LD+lAMAAADAoBuoMLKU8swkb0zyyiQPSfKVJB8tpcw6/LeU8uwkE/X1903y/yV5ZpLX9KTg4dbqDXnY1JZnlyTX1ceGagMAAAAwq4EKI5P8ZpK/rqrqbVVVfTPJi5PcluTn57j+kUk+U1XVe6qqmqqq6t+S/F2SeXtT0hXXJ6nq/cNj3kgAAAAAFjAwYWQpZVOS05N8rHWuqqr99fGZc7zts0lObw3lLqXcI8lPJvnXeT5ncynl4NaWZEeXfoTh0pjelwPDs62oDQAAAMCCNvS7gDZHJFmf5OoZ569Ocupsb6iq6j2llCOS/GcppaT58/xVVVXzDdN+eZI/6EK9NOeNPDJW1AYAAABgEQamZ+RSlFLOSvKKJC9Jc47J/55krJTye/O87bVJRtq241e2yjVtthW1hZEAAAAAzGqQekZem2RfkqNnnD86yVVzvOcPk/yfqqr+pj7+WillW5K3llJeXQ/zvouqqnYn2d06bnaoZInaV9QWRgIAAAAwr4HpGVlV1Z4k5yd5bOtcKWVdfXzeHG87KMnMwHFf6+3drpG70TMSAAAAgEUbpJ6RSfLGJO8opXwpyReS/HqSbUneliSllHcmubyqqpfX138oyW+WUr6c5PNJ7pVmb8kPVVW1L6y09p6R/1XvCyMBAAAAmNVAhZFVVb23lHJkklcl2ZnkgiRPrKqqtajNiblrT8g/SlLV7XFphmMfSvI7vap5yOkZCQAAAMCiDVQYmSRVVb0pyZvmeO2sGcd7k7yy3ug9c0YCAAAAsGgDM2ckq9JsPSMPHh2f3NKnegAAAAAYYMJIlqO9Z+R0kj31sd6RAAAAANyNMJLlaPWGPGRqy7M3th0f3ad6AAAAABhgwkiW44YkrVXLj0jSWmhIGAkAAADA3QgjWbrG9P4k19ZHR0UYCQAAAMA8hJEsV/u8ka0wcmefagEAAABggAkjWa72FbX1jAQAAABgTsJIlqu9Z+RV9b4wEgAAAIC7EUayXHpGAgAAALAowkiWa7Y5I4WRAAAAANyNMJLl0jMSAAAAgEURRrJcs/WMPHR0fHJTn+oBAAAAYEAJI1mu9p6RNyTZ23YMAAAAAHcSRrJcd/aMnJoY258D4aSh2gAAAADchTCS5WqFjwenMbI55o0EAAAAYA7CSJbrxhwYmm1FbQAAAADmJIxkeRrTVQ4M1W5fUXtnfwoCAAAAYFAJI+mG2VbU1jMSAAAAgLsQRtIN7StqCyMBAAAAmJUwkm7QMxIAAACABQkj6Yb2npFX1fvCSAAAAADuQhhJN+gZCQAAAMCChJF0w2xzRh4+Oj65sU/1AAAAADCAhJF0Q3vPyOuS7Gs7BgAAAIAkwki6486ekVMTY/tzIJw0VBsAAACAOwkj6YZWGNnqCWneSAAAAADuRhhJN7R6Qm5PY2RrhJEAAAAAzEIYSTfclGRPvd++ovbO/pQDAAAAwCASRrJ8jekqB3pHtq+orWckAAAAAHcSRtIt7fNGCiMBAAAAuBthJN2iZyQAAAAA8xJG0i16RgIAAAAwL2Ek3aJnJAAAAADzEkbSLe09I6+q948YHZ/c0Kd6AAAAABgwwki6pb1n5LVJ9icpSY7oW0UAAAAADBRhJN1yZ8/IqYmxfWkGkomh2gAAAADUhJF0S3vPyMS8kQAAAADMIIykW9rnjEyEkQAAAADMIIykW1o9Iw9KY2RbhJEAAAAAzCCMpFtuSXJ7vb8zB8LInf0pBwAAAIBBI4ykOxrTVZIr66P2MFLPSAAAAACSCCPprlYYeUyEkQAAAADMIIykm66qW2EkAAAAAHcjjKSb2ntGXlHvH9unWgAAAAAYMMJIuql9zsjL6/0jRscnt/SpHgAAAAAGiDCSbmrvGXl9kl31sd6RAAAAAAgj6ao754ycmhircqB35HF9qgcAAACAASKMpJvae0YmyWV1e3wfagEAAABgwAgj6aZWGHlkGiMbIowEAAAAoI0wkm66Nsn+JCXJUTFMGwAAAIA2wki6pzG9L8nV9dEx0TMSAAAAgDbCSLqtfd5IPSMBAAAAuJMwkm5rhZE7o2ckAAAAAG2EkXTbVXXb3jPymNHxyfV9qgcAAACAASGMpNvah2lflWRfkvVJju5bRQAAAAAMBGEk3XZnGDk1MbYvB3pKmjcSAAAAYMgJI+m29jkjE/NGAgAAAFATRtJt7XNGJlbUBgAAAKAmjKTbDswZ2Rgp0TMSAAAAgJowkm5r9YzclOTQ6BkJAAAAQE0YSXc1pnclubE+2hk9IwEAAACoCSNZCQeGausZCQAAAEBNGMlKaA8j7+wZOTo+WfpUDwAAAAADQBjJSpitZ+TWJIf0pRoAAAAABoIwkpXQWsRm59TE2K4k19XH5o0EAAAAGGLCSFZCe8/I5MBQbfNGAgAAAAyxZYWRpZQTSymPmnHugaWUd5ZS3ltK+allVcdqNTOMbA3V1jMSAAAAYIhtWOb7/zzJ9iSPS5JSytFJ/iPJpiQ3J3laKeXpVVV9YJmfw+qiZyQAAAAAd7PcYdoPS/LvbcfPTXOhkgemGTx9PMlLl/kZrD53zhlZt3pGAgAAALDsMPKwJNe0HT85ySerqvpuVVX7k3wgyanL/AxWn1bPyJE0RrZGz0gAAAAAsvww8odJTkqSUsohSR6R5KNtr2/I8oeCs/pMJ9lV7x8TPSMBAAAAyPLDyI8l+dVSym8meWd9v39qe/1Hkly6zM9gtWlMV7nrvJF6RgIAAACw7DByPMm3krwhydlJXlpV1SVJUkrZnOQZac4byfBpnzey1TPysNHxya19qgcAAACAPlvWEOqqqq5O8qOllJEkt1dVtaft5XVJHhs9I4dVe8/I6SS3JtmWZu/Ii/tVFAAAAAD9s9yekUmSqqqmZwSRqarq9qqqvlJV1fXd+AxWnTvDyKmJsSrmjQQAAAAYessKI0spjy2lnDvj3M+XUn5QSrm6lPKnpZT1yyuRVao1TPuYujVvJAAAAMCQW27PyEaSB7YOSin3T/KWNFfZ/kSSX03y0mV+BqtTq2fkzrrVMxIAAABgyC03jLxvki+1Hf+PJDcleXRVVc9M8tdJnrvMz2B1ap8zMjnQM1IYCQAAADCklhtGbkszfGx5YpKPVFV1W338xSQnLfMzWJ1m9oT8ft2e3IdaAAAAABgAyw0jL01yRpKUUu6V5LQk/9b2+mFJdi/zM1idWuHjEWmMbEvy3fr4nn2qBwAAAIA+W24Y+e4kLyylfDDJR5PckOSf214/PclFy/wMVqfpJDfX+yckubjev8fo+KRFjQAAAACG0HLDyFcnmUgzbPpBkp+qqurGJCmlHJbkrCQfXOZnsBo1pqs0n4kkOTHNXrR3JNkUK2oDAAAADKVlhZFVVe2tqup3qqp6cFVVP15V1afbXru+qqqdVVW9dvllskq1hmqfNDUxti/JVH1sqDYAAADAEFpuz8g7lVK2l1LuW2/bu3VfVrX2npHJgaHawkgAAACAIbTsMLKUckYp5T/SnC/y6/V2Qynl/5VSHrrc+7OqzQwjW4vY3KsPtQAAAADQZxuW8+ZSysOTfCLJniR/k+Rb9Uv3TfKsJJ8qpZxVVdUXlvM5rFp3DtOuWytqAwAAAAyxZYWRaS5gc3mSR1VVdVX7C6WURpLP1Nc8fpmfw+pkmDYAAAAAd1ruMO2HJ3nLzCAySaqqujrJW5M8YpmfwerVCiOPT2NkfdqGaY+OT5Y+1QQAAABAnyw3jNyf+XtXrq+vYThdkWRfko1Jdia5JEmVZEeSI/pYFwAAAAB9sNww8rNJfqmUctLMF0opJyZ5SZpDtRlGjem9aQ7jT5ITpybGdiW5rD42VBsAAABgyCx3zshXJPlUkm+XUv4xyUX1+fskeWqaveJevszPYHX7QZpzRp6Y5Lw0h2qfkOaK2p/rY10AAAAA9Niywsiqqr5cr6j96iTnJDmofum2JB9J0khy7XI+g1Xv+0kelbuuqH1W9IwEAAAAGDrLHaadqqq+WVXVf0tycJJj6u3gqqr+e5KnJLl0uZ/BqjbXitr36kMtAAAAAPTRcodp36mqqv1Jru7W/VgzZoaRrRW19YwEAAAAGDLL7hkJC/h+3QojAQAAAIacMJKV1uoZ2T5nZJIcNTo+uaMP9QAAAADQJ8JIVlorjDwkjZGDpybGpnNgUSO9IwEAAACGSMdzRpZSHtLB5cd2en/WmMb0zWmM3JDk0CQnJPlGmr0jj0gzjLygf8UBAAAA0EtLWcDmS0mqRV5bOriWtesHaYaRJ6UZRl6c5OGxojYAAADAUFlKGPlzXa+Cte4HSR4Yi9gAAAAADLWOw8iqqt6xEoWwpllRGwAAAAAL2NATM1fUvrhuDdMGAAAAGCLCSHqhFUbO7Bl5wuj45OY+1AMAAABAHwgj6YWZw7SvSXJrmgscjfajIAAAAAB6TxhJL7R6Rh6XxsiGqYmxKoZqAwAAAAwdYSS9cFWSO5KsT3Jsfe47dXtqXyoCAAAAoOeEkay8xvT+JJfWR62h2l+r2/v3viAAAAAA+kEYSa/MXMRGGAkAAAAwZISR9EorjDypblth5P1Gxyc39KEeAAAAAHpMGEmvtFbUboWR30tyW5LNsYgNAAAAwFAYuDCylPJLpZSpUsquUsrnSykPW+D6Q0opby6lXFlK2V1KuaiU8pO9qpdFu6Ru75EkUxNj+5N8vT73gL5UBAAAAEBPDVQYWUp5ZpI3Jnllkock+UqSj5ZSjprj+k1J/j3JaJKnJblPkhckubwX9dKR79btPdvOfbVuzRsJAAAAMAQGKoxM8ptJ/rqqqrdVVfXNJC9Ocyjvz89x/c8nOSzJT1VV9ZmqqqaqqvpkVVVf6VG9LF4rjDwpjZGN9X5r3kg9IwEAAACGwMCEkXUvx9OTfKx1rqqq/fXxmXO87Zwk5yV5cynl6lLK10spryilrJ/nczaXUg5ubUl2dO+nYB5XJtmVZH2sqA0AAAAwlAYmjExyRJpB1dUzzl+dZOcc77lHmsOz1yf5ySR/mOS3kvzuPJ/z8iTTbdtlSy+ZRWtM709z0ZrkwFDtVhh58uj4pFAYAAAAYI0bpDByKdYluSbJC6uqOr+qqvcmeXWaw7vn8tokI23b8SteJS13mTdyamLs2jR7TCbJaX2pCAAAAICeGaQw8tok+5IcPeP80UmumuM9Vya5qKqqfW3nvpVkZz3s+26qqtpdVdVNrS3Jzcusm8WziA0AAADAEBuYMLKqqj1Jzk/y2Na5Usq6+vi8Od72mST3qq9ruXeSK+v7MVhmCyMtYgMAAAAwJAYmjKy9MckLSinPK6XcN8lfJtmW5G1JUkp5ZynltW3X/2Waq2n/z1LKvUspY0lekeTNPa6bxZkvjNQzEgAAAGCNG6gwsp7z8aVJXpXkgiQPSvLEqqpai9qcmOSYtusvTfKEJGekOdz3z5P8zyQTPSuaTrTCyHukMVLq/dYw7QeMjk+WWd4DAAAAwBqxod8FzFRV1ZuSvGmO186a5dx5SR6xwmXRHVNJ9qfZ27U1F+i30pwr9JAkx8Xq5gAAAABr1kD1jGSNa0zvSXJpfXSvJJmaGNud5ML6nKHaAAAAAGuYMJJes4gNAAAAwJASRtJrFrEBAAAAGFLCSHpttjDyzkVselwLAAAAAD0kjKTX5usZeero+OSmHtcDAAAAQI8II+m1i+u2PYz8fpKbkmxM8iM9rwgAAACAnhBG0mutnpFHpDFycJJMTYxVSb5Un39YX6oCAAAAYMUJI+mtxvTNSX5YH7X3jvx83T68twUBAAAA0CvCSPphtnkjP1e3j+hxLQAAAAD0iDCSfpgtjGz1jLzv6PjkwT2uBwAAAIAeEEbSD3cLI6cmxq5OcyGbkuSMfhQFAAAAwMoSRtIPs/WMTAzVBgAAAFjThJH0w1xhpEVsAAAAANYwYST90AojT0hjZFPb+TvDyNHxydLjmgAAAABYYcJI+uHqJLem+fyNtp3/cpI7khyV5KTelwUAAADAShJG0nuN6SrJ9+qj9kVsbk/ylfrQvJEAAAAAa4wwkn65uG5PmXHevJEAAAAAa5Qwkn65qG7vPeN8a0VtYSQAAADAGiOMpF/mCiNbPSMfMjo+uSkAAAAArBnCSPrlwrqdGUZenOT6JJuTPLCnFQEAAACwooSR9EurZ+SJaYxsbZ2cmhirYt5IAAAAgDVJGEm/XJvkhiQlyb1mvNYKI62oDQAAALCGCCPpj8Z0lQO9I+8z41VhJAAAAMAaJIykn+ZbUbtKcs/R8cljelsSAAAAACtFGEk/zbqIzdTE2I1JvlIf/lgvCwIAAABg5Qgj6ae5hmknySfr9jE9qgUAAACAFSaMpJ9m7RlZ+1TdCiMBAAAA1ghhJP10cd0elsbI4TNea4WRPzI6PnlkD2sCAAAAYIUII+mfxvRtSS6tj+4yVHtqYuzaJN+oDx/dy7IAAAAAWBnCSPptvqHa5o0EAAAAWEOEkfRbaxEbYSQAAADAGieMpN9aPSNnW1G7NW/kA0bHJw/tUT0AAAAArBBhJP02Z8/IqYmxq9IMK0vMGwkAAACw6gkj6bdWGHlKGiPrZ3m91Tvyx3pUDwAAAAArRBhJv30/yZ4km5OcMMvr5o0EAAAAWCOEkfRXY3pfkovro/kWsXnI6Pjkwb0pCgAAAICVIIxkEMy5iM3UxNhlSb6X5rP6o70sCgAAAIDuEkYyCOZcxKZmqDYAAADAGiCMZBAsNoz88R7UAgAAAMAKEUYyCOYcpl37eN0+dHR88pCVLwcAAACAlSCMZBC0ekaemMbI1pkv1vNGXpjm83pWD+sCAAAAoIuEkQyCa5PckKQkOWWOaz5Wt4/rSUUAAAAAdJ0wkv5rTFdJvlkf/cgcVwkjAQAAAFY5YSSDYqEw8hNJ9ie5z+j45Ak9qQgAAACArhJGMijmDSOnJsZuTPKl+vCxvSgIAAAAgO4SRjIoWmHk/ea5pjVUWxgJAAAAsAoJIxkU36jbU9IY2TTHNXfOGzk6Pll6UBMAAAAAXSSMZFBckeSmJOsz94ra5yW5PcnOzD23JAAAAAADShjJYLjritqzDtWemhjbleTT9aFVtQEAAABWGWEkg2ShFbWT5ON1K4wEAAAAWGWEkQyS1ryR84WRrXkjzxodn9y4wvUAAAAA0EXCSAbJYlbUviDJ9Um2JzljpQsCAAAAoHuEkQySVhh57zRGZu31ODUxtj8Hhmqf3ZOqAAAAAOgKYSSD5NIktyTZkORe81z30bp94opXBAAAAEDXCCMZHItYUbvWCiMfNjo+efjKFgUAAABAtwgjGTQLrqg9NTF2WZKvJSkxVBsAAABg1RBGMmgWDCNrH6lbQ7UBAAAAVglhJIPmG3U73zDtJPlw3T5xdHzScwwAAACwCghxGDStnpH3SWNkwzzXfSbJrUmOSvKglS4KAAAAgOUTRjJofpDktiQbk9xzroumJsb2JPl4fWioNgAAAMAqIIxksDSm9yf5Vn202KHaT1q5ggAAAADoFmEkg6g1b+RiF7E5c3R88pCVKwcAAACAbhBGMogWtaL21MTYVJJvJ1mf5HErXBMAAAAAyySMZBC1wsiFhmknB3pHmjcSAAAAYMAJIxlErWHap6YxsnGBa1vzRj5xdHyyrGBNAAAAACyTMJJBNJXk5iSbkpy6wLWfSnJ7kuOS3H9lywIAAABgOYSRDJ7mitpfrY8eON+lUxNju5J8vD48ZyXLAgAAAGB5hJEMqgvqdt4wsvZPdftTK1EIAAAAAN0hjGRQfaVuH7SIaz+UpEpy+uj45AkrVhEAAAAAyyKMZFBdULcPTGNk3oVppibGrknymfrwqStZFAAAAABLJ4xkUH09yf4kRybZuYjr/6luf2qF6gEAAABgmYSRDKbG9O1JLqyPHrSId/xz3Z41Oj556IrUBAAAAMCyCCMZZK15IxdcxGZqYuziJN9Isj7JT65kUQAAAAAsjTCSQdbJIjaJodoAAAAAA00YySC7oG4X7BlZ+6e6fdLo+OSWrlcDAAAAwLIIIxlkrZ6R905j5KBFXH9+ksuTbEvy2BWrCgAAAIAlEUYyyK5Kck2az+lpC108NTFWxVBtAAAAgIEljGRwNaardLCITe2f6vac0fHJ9V2vCQAAAIAlE0Yy6DoNIz+Z5PokRyX5iRWpCAAAAIAlEUYy6C6o2wct5uKpibE7kryvPnzOCtQDAAAAwBIJIxl0rZ6RD0hjZLHP67vq9r+Pjk8uZuEbAAAAAHpAGMmguzDJ7iQ7kpy8yPd8NslUku1JzlmZsgAAAADolDCSwdaYviPJN+qjRc0bWa+q/e768GdXoiwAAAAAOieMZDW4oG4Xu4hNciCMfOLo+OQR3S0HAAAAgKUQRrIatOaNfPBi3zA1MfatJP+VZEOSZ6xEUQAAAAB0RhjJanB+3T60w/cZqg0AAAAwQISRrAZfTrI/yTFpjBzXwfv+vn7fI0fHJ++xIpUBAAAAsGjCSAZfY/q2HFjEZtG9I6cmxq5I8v/qw2d3uywAAAAAOiOMZLX4Yt2e0eH73lW3zx8dn/S8AwAAAPSRcIbVYqlh5PuTTCe5Z5Kzu1oRAAAAAB0RRrJafKluH5rGSFnsm6Ymxm5N8vb68CXdLgoAAACAxRNGslp8NcmeJIclObnD9/5l3T55dHxytJtFAQAAALB4wkhWh8b0niRfqY86Gqo9NTF2YZKPJSlJXtTlygAAAABYJGEkq8mBodqde3Pd/sLo+OSWLtUDAAAAQAeEkawmS13EJkn+JcmlSY5I8rSuVQQAAADAogkjWU1aYeTpaYys7+SNUxNje5O8pT78pa5WBQAAAMCiCCNZTb6d5LYk25Pcewnv/5skdyR5xOj45EO6WRgAAAAACxNGsno0pvcm+a/6qOOh2lMTY1cneX99+BvdKgsAAACAxRFGstosZ97IJPmTun3W6PjkPbtQDwAAAACLJIxktWmFkUtZUTtTE2PnJ/lwkvVJxrtVFAAAAAALE0ay2nypbh+UxsjGJd7jj+r2eaPjkyd2oSYAAAAAFkEYyWpzcZIbk2xJctpSbjA1MfbZJP8vycYkL+taZQAAAADMSxjJ6tKYrnKgd+RS541MDvSO/IXR8cljllcUAAAAAIshjGQ1+kLdPmIZ9/hEks8m2ZzkpcstCAAAAICFCSNZjT5bt2cu9QZTE2NVDvSOfPHo+OSRy64KAAAAgHkJI1mNPle3p6Yxcvgy7vORNId8H5SksdyiAAAAAJifMJLVpzF9XZIL66MlD9Wue0e2FrB58ej45JIWxAEAAABgcYSRrFatodqPXM5NpibG/iPJB9L8XfjT0fHJstzCAAAAAJidMJLVatnzRrY5N8meJI9L8pQu3A8AAACAWQxkGFlK+aVSylQpZVcp5fOllIct8n0/U0qpSin/tMIl0n/n1e3D0xjZsJwbTU2MfS/JG+vDN46OT25eVmUAAAAAzGrgwshSyjPTDIZemeQhSb6S5KOllKMWeN9okjck+fRK18hA+FaS6TQXn3lAF+73miRXJblnkl/twv0AAAAAmGHgwsgkv5nkr6uqeltVVd9M8uIktyX5+bneUEpZn+TdSf4gyfd6UiX91ZjenwO9I5c1b2SSTE2M3Zzk5fXh742OT5643HsCAAAAcFcDFUaWUjYlOT3Jx1rnqqraXx/PNzfg7ye5pqqqv13ZChkwrTCyG/NGJsk763vuSPKO0fHJgfr9AAAAAFjtBi1sOSLJ+iRXzzh/dZKds72hlPKoJP9fkhcs5gNKKZtLKQe3tjSDJ1anrqyo3TI1MbY/yXOT3JrkrDR76QIAAADQJYMWRnaklLIjyf9J8oKqqq5d5NtenuZcg63tshUqj5X3hST7k4ymMXJMN244NTF2cZLfqA9fPTo+2Y35KAEAAADI4IWR1ybZl+ToGeePTnNxkZnumWQ0yYdKKXtLKXvT7Nl2Tn18z1ne89okI23b8V2qnV5rTN+U5Gv1UbeGaifJ3yT5YJJNSd49Oj65pYv3BgAAABhaAxVGVlW1J8n5SR7bOldKWVcfnzfLW76d5P5JHtS2fTDJf9T7l87yGburqrqptSW5uZs/Az3XtUVsWqYmxqo0h/1fk+S0JBPdujcAAADAMBuoMLL2xiQvKKU8r5Ry3yR/mWRbkrclSSnlnaWU1yZJVVW7qqr6evuW5MYkN9fHe/r0M9A7XZ03smVqYuyaNOciTZJfGx2ffFE37w8AAAAwjAYujKyq6r1JXprkVUkuSLOH4xOrqmotanNikq7MD8ia0AojT09jZHM3bzw1MfYvSf6gPvxfo+OTP9nN+wMAAAAMm4ELI5Okqqo3VVV1UlVVm6uqenhVVZ9ve+2sqqqeP897n19V1U/1ok4GwvfSHE69KclDV+D+f5jk7Wn+rrxvdHzy9BX4DAAAAIChMJBhJCxaY7pK8p/10Y91+/b1/JEvTPLvaU4X8C+j45Oj3f4cAAAAgGEgjGQt+ETdnrUSN5+aGLsjydPSXLl7Z5JPjY5P3nclPgsAAABgLRNGshZ8sm5/NI2RjSvxAVMTYzcleVKaK7ifkOQ/R8cnz1yJzwIAAABYq4SRrAVfT3J9msOoV2xOx6mJscuTPDrJ55McluTjo+OTYyv1eQAAAABrjTCS1a8xvT/Jp+qjx6zkR01NjF2b5LFJPpxka5J/Hh2fPHd0fNLvEgAAAMACBCisFZ+o27NW+oOmJsZuTfLUJO9Isj7J65L86+j45FEr/dkAAAAAq5kwkrXiE3X7qDRGNqz0h9WL2vxckhcl2ZXkCUm+Mjo++biV/mwAAACA1apUVdXvGvqqlHJwkukkI1VV3dTveliixsi6JNcmOTTJw9OY/kKvPnp0fPK0JH+f5H71qbcnednUxNgPe1UDAAAAQL90kq/pGcnacNd5I8/q5UdPTYx9PcnDkvxlfer5SS4cHZ98kbkkAQAAAA4QlLCWfLJuV3QRm9lMTYzdNjUx9pIkj0xyQZo9NP8qyRdHxyefNDo+WXpdEwAAAMCgEUaylnyibh/di3kjZzM1MXZekjOS/FqSm5M8JMm/JvnP0fHJH+9HTQAAAACDwpyR5oxcOxoj65Ncl2QkyRlpTH+pn+WMjk8emeS3k/xSki316c8k+bMk/zQ1Mba3T6UBAAAAdE0n+ZowUhi5tjRGPpjkKUnOTWP6Df0uJ0lGxyePTfKKJC9MsrE+/f0kf5HkHVMTY9f2qzYAAACA5RJGdkAYucY0Rn4ryRuS/Esa00/pdznt6lDyF5O8OMkR9em9SSaTvCPJ5NTE2J4+lQcAAACwJMLIDggj15jGyOlJvpTkpiSHpzE9cEOhR8cntyZ5dprB5OltL92Q5ENJ/jHJv01NjN3Wh/IAAAAAOiKM7IAwco1pzht5bZJDkjwyjenz+lvQ/EbHJ++X5LlJnpPk2LaXbkvysSQfr7dvTk2MDfcvKwAAADCQhJEdEEauQY2Rf0jytCSvTGO60edqFmV0fHJ9kh9N8t+T/LckJ8645Kok/y91QDk1MfaD3lYIAAAAMDthZAeEkWtQY+QXkvx1ks+lMX1mv8vp1Oj4ZEnyoCRnJ3lckkflwGrcLRcn+WySz9fbV6cmxu7oYZkAAAAASYSRHRFGrkGNkROS/CDJ/iRHpDF9Q58rWpbR8cktSc5M8th6OyPJ+hmX7UryX2kGk19I8sUkl0xNjO3vYakAAADAEBJGdkAYuUY1Rr6Z5L5Jnp7G9Pv7XU43jY5PjqQ5pPvh9fawJIfOcuktSb6W5Kv19pUkX5uaGPOcAwAAAF0jjOyAMHKNaoz8aZJfT/I3aUy/oM/VrKh6WPcpORBOPjzJ/ZNsnuMtU0m+leTb9XZh3V5jkRwAAACgU8LIDggj16jGyBOTfDjJpUlOSmN6qB700fHJDUnuneQBbdsDkxw/z9tuTDOYvCjJ95Jc0tZeYcg3AAAAMBthZAeEkWtUY+SgJNen2TvwR9KY/lafKxoIo+OTh6XZa/I+SU6tt/skOTlJmeetu5N8P3cPKS9JM/C9Vq9KAAAAGE7CyA4II9ewxsi/p7ka9W+kMf1nfa5moNWL5JySZjh5rzTDyXvU7Um5+4I5M+1JcnmSy+Zpr5yaGNu7EvUDAAAA/SOM7IAwcg1rjLw0yeuTfCSN6Sf1u5zVqh7yfXwOhJMnz9g/KvP3qmypkvwwyTVJrq63OfenJsZ2d/UHAQAAAFaEMLIDwsg1rDFy/zRXkb49yWFpTO/qc0Vr0uj45KYkxyQ5Ls3Q8vhZ9o9LsqHDW9+U5lD76xbR3pDm7/F0kl2GjAMAAEDvCCM7IIxcwxojJc3hwccmeXwa0x/rc0VDa3R8cl2SI5PsTHJ0mr0pj55lv3XcaXDZbm+aQeb0jHa+/VuT3FZvM/fvEG4CAADA3ISRHRBGrnGNkbcleX6SN6QxfW6fq2ERRscnS5JDkxyR5PAkh81oZzt3WJLtWdxw8U7ty11Dyvaw8rY0F/dZzLZnlnN3pBmeLnfbLzAFAACgX4SRHRBGrnGNkZ9J8ndJvpXG9I/0uxxWTt37cnuSg5OM1O3BsxzPtn9QvW1raxdatGfQVPW2f0Y727mF2pn77Vvm2J/vtcVet9L36Mb996UZAN/RhXZPkl1pBtMLtbunJsb2BQAAYAAJIzsgjFzjGiOHpLloyoYk90lj+qL+FsRqUc+FOTOknG1/8yK3TbOc27CEjeG1N3MHlu1TC8zsxdvRuamJsTt69hMBAABrgjCyA8LIIdAY+bckj0/ysjSmX9/vcmCp6iHs6zJ7SNl6rb1dzrn211pb5tif77XFXrfS9+jW/dcl2ZjmP/PltBvTDKi3pBlMz9WuS+/tTnMu1ZuX2wo2AQBgOAgjOyCMHAKNkZckeXOSz6Yx/aP9LgdgMerweUMO9KSdK7DcWm/t0wy07892brbXV2JqgluT3LjEbVqYCQAAq4MwsgPCyCHQGDk+yaVpzvd2bBrTV/W5IoCBUgefm9IMJXfU28HLaLd0qbRbMntQeUO9XT/HdsPUxNjeLtUAAAAsQBjZAWHkkGiMfCHJGUlemMb0X/e7HIC1bHR8cmMOLBJ1SIfboWkuRrVcN2eesHKu16Ymxm7vwmcDAMBQEUZ2QBg5JBojr0jy6iT/msb0WL/LAWBuo+OTGzJ3kHlo3R42Yzu0bg9Z5sfvygK9Luc4f9PUxNhw/6EKAIChJYzsgDBySDRGfiTJN5LsSXJEGtM397kiAFbA6Pjk+swfVs61HZrlrVi/L3cfPt5+fMOMrf3c7YJMAABWM2FkB4SRQ6IxUpJcmOSUJM9IY/of+lwRAAOknjdze+YOKucLMrcu8+P35O6B5aKOpybGdi/zswEAYNmEkR0QRg6Rxsjrkpyb5D1pTP9sv8sBYG0YHZ/cktkDy0Pbzh86x/FyVzG/PQuHl9OpVyhv225McvPUxNi+ZX4+AAAIIzshjBwijZFHJvlMmv++j0pjek+fKwJgiM3ojTlXWDnbcWsrXSjj5sweVM62P9trtxpiDgCAMLIDwsgh0hhZn+TyJEcnOTuN6X/vc0UAsCSj45Pr0lyxfDEB5kgOLAjU2t/SpVL2JbkpsweXN6UZdrba+fZv0UsTAGD1EkZ2QBg5ZBojb03ygiRvTWP6Rf0uBwD6YXR8cnMOBJMzg8rF7i93iPlMt2bx4eV8+7dMTYzd0eXaAACYhzCyA8LIIdMYeVySf09zLq1jDNUGgM7VQ8wPyt1DyvbjHWn23tyxwP5yVjGfy540w81b6m22/YVev9u+kBMAYHbCyA4II4dMc6j2pUmOSfLUNKY/2OeKAGBo1aHmliwcWC5mf0eSzStc8mJCztb+rUlum2e7feY5Q9UBgNVKGNkBYeQQaoy8MclvJHlfGtPP7Hc5AEB3jI5PbkpzUaBtM9qlnGvf39ijH2FP5g8wl7vdnmTX1MTY/h79PADAkBBGdkAYOYQaI6cn+VKSXUmOTmPav3cAYE51yDkzuFwo1Dyog63X9qT556DbZ7Sd7nf6vj1WXweAtUkY2QFh5BBqjJQk30pynyTPT2P6HX2uCAAYUm1D1TsJL5eyberVzzSPKrOHlbvrbU/b/szjxex3/J6pibG9K/sjA8BwEEZ2QBg5pBojv5fkVUn+LY3pJ/S7HACAlTQ6PrkhydY0g8/WtnWW/dnOLWZ/vtcH2f4cCCf3JLljhbZO7r03yb62dln7eqMC0AvCyA4II4dUY+ReSb6T5h9Aj0tj+qo+VwQAsObUPT83Zf7Ackuaiw9trq+dbX+h405eGzb7s/RQs6rfv3/GfrePF3qtXTXH/lJf69b9S1s73/5ir+t0fzXfdzadnh/keyXN52W2bf88r6306wu9tm+ettPXVur6vYvc9vuLmZUnjOyAMHKINUY+l+ThSX49jen/2e9yAABYWXU4uiFzh5YbB2DbkGR9W7uY/YWCEIBh10l4uZLb7qmJsT9d6R+2HzrJ1zb0piQYSO9OM4z82STCSACANa7uGdMaDn1Ln8vpmtHxyXU5EFDODCw7DTZb++vqrbTtzzye77VOj2d7bX3bjzkzcC3L2F+J97d6lCV37WGWDvdX8j2DXM9sOj0/qPcqC2zr+vj6XK+1fg/Xz9Iu9lw3r5/ttfbvq9a2cY5/B2m7vt895G9LsibDyE4IIxlm703zS+CMNEbuncb0Rf0uCAAAOjU1MdYa0nxHv2sB6Kf6L2c2LGKbGWT2arNwWgzTNkx72DVGJpP8ZJI/TmN6vN/lAAAAAKw2neRr63pTEgysv67bn09jZFNfKwEAAABY44SRDLt/SXJFkiOT/Lc+1wIAAACwpgkjGW6N6b1J/qY+elE/SwEAAABY64SR0Awj9yf58TRG7tPvYgAAAADWKmEkNKYvTfKv9dEL+1kKAAAAwFomjISmv6rb56cxsqWvlQAAAACsUcJIaPpIkh8kOSzJ0/pcCwAAAMCaJIyEJGlM70vy1/WRhWwAAAAAVoAwEg7430n2JXlUGiMP6XcxAAAAAGuNMBJaGtNXJPn7+uhl/SwFAAAAYC0SRsJdva5un57GyD37WgkAAADAGiOMhHaN6a8m+XCavxsv7XM1AAAAAGuKMBLu7o/r9ufSGDm6r5UAAAAArCHCSLi7TyX5fJLNSX61z7UAAAAArBnCSJipMV0lmaiPXpLGyMH9LAcAAABgrRBGwuw+mOTbSQ5J8sL+lgIAAACwNggjYTaN6f1JXl8fvTSNkR39LAcAAABgLRBGwtzeleTiJEcnObfPtQAAAACsesJImEtjek+S366PXprGyHH9LAcAAABgtRNGwvz+MclnkmxN8od9rgUAAABgVRNGwnyaK2v/Vn30/DRGHtjPcgAAAABWM2EkLKQx/fkk701SkrwhjZHS54oAAAAAViVhJCzOy5PsSfK4JE/qcy0AAAAAq5IwEhajMX1Jkj+vj/5XGiMH97McAAAAgNVIGAmL96oklyQ5Kcmf9rkWAAAAgFVHGAmL1Zi+OcnzklRJfj6Nkaf0uSIAAACAVUUYCZ1oTH86yZ/UR3+dxsgR/SwHAAAAYDURRkLnfi/JN5IcneQvra4NAAAAsDjCSOhUY3pXkucm2ZvkaUle1N+CAAAAAFYHYSQsRWP6v5L8bn30pjRGntjPcgAAAABWA2EkLN3rkrwjyfok70tj5AF9rgcAAABgoAkjYaka01WSFyb5jyQ7kkymMXJsf4sCAAAAGFzCSFiOxvSeJD+d5NtJjk8zkDysv0UBAAAADCZhJCxXY/qGJD+Z5JokD0ryST0kAQAAAO5OGAnd0Ji+JMlPJLkiyWlJ/jONkXv2tygAAACAwSKMhG5pTH8jyaOSfDfJyWkGkha1AQAAAKgJI6Gbmj0kH5Xkq0l2JvlMGiPP7G9RAAAAAINBGAnd1pi+Kslj0lxle3uSv09j5E1pjGzub2EAAAAA/SWMhJXQmL4xydlJXlOf+aWYRxIAAAAYcqWqqn7X0FellIOTTCcZqarqpn7XwxrUGPnJJP8nyWFJbk/SSPKnaUzf0c+yAAAAALqhk3xNz0hYaY3pf03y4DSHbW9N8sdJvpjGyBl9rQsAAACgx4SR0AuN6R8keWySn0tyfZIHJvl8GiNvT2Pk5L7WBgAAANAjhmkbpk2vNUaOTPLGJM+pz9yR5K1JXp3G9JV9qwsAAABgCTrJ14SRwkj6pTHysCR/lOTx9ZndSd6T5C/SmP5y3+oCAAAA6IAwsgPCSPquMfLjSV6d5My2s/+Z5C+T/HMa07f2pS4AAACARRBGdkAYyUBojJQ0w8hfTfLTSTbUr9yW5INJ/i7JR9OY3t2fAgEAAABmJ4zsgDCSgdMYOS7JC9OcU/Ieba/cluTjST6c5MNpTE/1vjgAAACAuxJGdkAYycBq9pY8I8mzkjwjybEzrvh+kk+nOaT7M0m+ncb03p7WCAAAAAw9YWQHhJGsCs1g8oFJnlRvj0yyfsZVtyf5WpIL2ravmnMSAAAAWEnCyA4II1mVGiM7kjwiyaOSPDrJw5Jsm+XKKslFSb6Z5OIZ22VpTO/vSb0AAADAmiWM7IAwkjWhMbIuyb2SPKhte3CSnfO8a3eS79XbpUkuS3L5XdrG9M0rVTIAAACwNggjOyCMZE1rjOxMc3j3vdMMK1vbPXJgxe753JzkqiQ/THJtW3vtHOduTmN6uL9UAAAAYMgIIzsgjGQoNUY2JDkhB4LJ45IcP6MdWcKd96b5+3RzkpsWsd2e5irhty+w3SHkBAAAgMEkjOyAMBLm0BjZnmYoeXSSI5IcWbdz7R+0gtXsz91DyzuS7KnbhbaFrttXf8Zit8VeX9Xbcq30PRa6fz/eW+Wu/6w7bed7bW+SvQJuAACA7hBGdkAYCV3SGDkoyWFJdqTZq/LgRWxb6+2gtv32DVbS3iwuzJ5v251kV1u7a4Fz8+3fVm96AgMAAKuKMLIDwkgYUI2RkmRz5g4qNyXZ2KVtXQfb+g6vX66ygvfo9Hwv3zPbP/NO29VqX5JbcyCcXO7+rUluqbeb05je3cOfBQAAGALCyA4IIwHWqGagPVtQuSGLC6kXc93mettSb53st5/bUtfWC3ekPZxcfntrGtP7e1Q7AAAwgISRHRBGAjAQGiOb0uwJfFCSbR3sL/T69nrbsoLVt3pfLhRetm+znWtttxmqDgAAq8eqDyNLKb+U5NwkO5N8JcmvVFX1hTmufUGS5yY5rT51fpJXzHX9LO8XRgKw9jVGNuRAMLk9zfldl9K29ndk5YbDV7nr8PJubLemMb13heoFAIChtqrDyFLKM5O8M8mLk3w+ya8neXqS+1RVdc0s1787yWeSfDbNBQB+O8l/S3K/qqouX8TnCSMBoFPNYfBbsvggc0eavTW3L7B1Y57UuezKXefUbG23L/LcYq7dZdg6AADDZrWHkZ9P8sWqqn65Pl6X5NIkf1FV1cQi3r8+yQ1Jfrmqqncu4nphJAAMgmbAuTVzB5U75nltvvf0aj7Oltvrbb4V1JeyAvtc53Yn2VNvd9y535jet+I/KQAApLN8bUNvSlqcUsqmJKcneW3rXFVV+0spH0ty5iJvc1CaiwpcP8dntBYbaNmxtGoBgK5qzhPZ6mF4t9EQS7vnSEmyKXcNKLfmwNyaB81yPNe5+a5t/7PF1nrrr8bI/swMKBd3vNRr9tbn9s7YZjvX2bXmEIXB0vxuLWlO19Fq1y3yuNNr2nvMz7U/32uLva6T11r2pzm1SDVjv9Pjpb53f73ta9v2+84EBt1A9YwspRyb5PIkj6yq6ry2869L8piqqh6+iHv8ryRPSHOY9q5ZXm8k+YNZ3qpnJACwNI2R9bl7UDlz5fSFVlVf7OszV2LflAMrwK9V+7L0gPPA/6DftV2J/cVeOzNYGJQtORC4DFLbadi1EuFYL+65mq5ZySk1WL6ZAeXM76HFbJ1e3/4dfMeM/X61+wSz0DurtmfkcpVSxpP8TJKzZgsia69N8sa24x1JLlvp2gCANaw5JLq1WE6fahhZl2Youamtbd9mnuvmNZvT/HNl+7ZxgePZzs01pH59vW2e43VgdZjZo2+24/ZzrbZlZrBUrcD+Yq+b2Tt05n6nxwtd24lWeLyxw/etPY2Rbo4K6NZIgrmuucO80wyLQQsjr03zb1WOnnH+6CRXzffGUspLk4wneVxVVV+d67qqqlpzK7Xet+RiAQAGRvN/YO7y55xVpzn0c6HAcrHnWsfr0/yf8vZ2rv1evT4zZOjWttz7toKWpbTLee9C95grtOrl8Urea7H36NY1K3Xf+a/RQ215DgyNn6238PoFtsVcs5zr1+eu37v9amfT+ouz1aExsjdzB5YLhZyL2br3HnNTswwDNUw7SWsBmy9UVfUr9fG6JD9I8qa5FrAppbwsye8keUJVVZ/r8PMW3Y0UAAAAGDDNsHZmKLqYHv8rNZJgMe/ZlNU95cH+9C8k7fR6Q/Z7YLWvpv3MJO9I8qIkX0jy60mekeTUqqquLqW8M8nlVVW9vL7+t5O8Ksmzk3ym7Va3VFW14FApYSQAAADQc805p5cSYs61dXJtp+8ZtJG1najSWYDZ7XlP2/f3pDH9wRX+eftiVc8ZWVXVe0spR6YZMO5MckGSJ1ZVdXV9yYm567whv5jmL8b7Z9zqlUkaK1osAAAAwFI0hzrfXm+D7cDc1CsZeHbz+nZljvP9cFuSbf0uot8Grmdkr+kZCQAAALBGHJiDejmB52LnK+10btM9aUw/fgV/+r5Z1cO0e00YCQAAAABL10m+tq43JQEAAAAAw04YCQAAAAD0hDASAAAAAOgJYSQAAAAA0BPCSAAAAACgJ4SRAAAAAEBPCCMBAAAAgJ4QRgIAAAAAPSGMBAAAAAB6QhgJAAAAAPSEMBIAAAAA6AlhJAAAAADQE8JIAAAAAKAnhJEAAAAAQE8IIwEAAACAnhBGAgAAAAA9IYwEAAAAAHpCGAkAAAAA9IQwEgAAAADoCWEkAAAAANATwkgAAAAAoCeEkQAAAABATwgjAQAAAICeEEYCAAAAAD0hjAQAAAAAemJDvwsYIDtKKf2uAQAAAABWmx2LvVAYeeAf1mV9rQIAAAAAVrcdSW6a74JSVVWPahlMpdkd8tgkN/e7lhW0I82w9fis7Z8TEs87w8czzzDxvDNsPPMME887w2YtPvM7klxRLRA2Dn3PyPof0OX9rmMltQ0/v7mqqnnTaVjtPO8MG888w8TzzrDxzDNMPO8MmzX6zC/q57CADQAAAADQE8JIAAAAAKAnhJHDYXeSV9YtrHWed4aNZ55h4nln2HjmGSaed4bN0D7zQ7+ADQAAAADQG3pGAgAAAAA9IYwEAAAAAHpCGAkAAAAA9IQwEgAAAADoCWHkGlZK2VxK+eNSyhWllNtLKZ8vpTy+33XBcpRSziqlVHNsj5hx7SNLKf9ZSrmtlHJVKeXPSynb+1U7LKSUsr2U8spSykdKKdfXz/Xz57j2vvV1t9TX/p9SypGzXLeulPKyUsolpZRdpZSvllKeteI/DCxgsc97KeXtc3znf3uWaz3vDKRSyhmllDeVUr5RSrm1lPKDUsr7Sin3nuVa3++seot95n3HsxaUUu5XSvmHUsr36v/3vLaU8qlSylNmudZ3fJIN/S6AFfX2JE9L8mdJvpPk+Un+tZTy41VV/Wf/yoKu+PMkX5xx7uLWTinlQUk+nuRbSX4zyfFJXprklCRP6k2J0LEjkvx+kh8k+UqSs2a7qJRyfJJPJZlO8ook29N8vu9fSnlYVVV72i5/dZLxJH+d5u/MU5O8p5RSVVX19yv0c8BiLOp5r+1O8gszzk3Pcp3nnUH120l+NMk/JPlqkp1JfjnJf5VSHlFV1dcT3++sKYt65mu+41ntTkqyI8k7klyR5KAkP53kg6WUF1VV9dbEd3y7UlVVv2tgBZRSHpbk80nOrarqDfW5LUm+nuSaqqoe2c/6YKlKKWcl+Y8kT6+q6v3zXPevSR6U5NSqqm6qz/1Cml/mT6iq6t9WvFjoUCllc5JDq6q6qpTy0DT/4PFzVVW9fcZ1/yvNv2A6taqqH9TnHpfk35O0/4HnuCSXJHlrVVW/XJ8rST6Z5OQko1VV7evFzwYzdfC8vz3J06qqmrdnu+edQVZKeWSSL7X/j2Yp5ZQkX0vy/qqqnlOf8/3OmtDBM//2+I5nDSqlrE9yfpItVVWdWp/zHV8zTHvtelqSfUne2jpRVdWuJH+b5MxSygn9Kgy6pZSyo5Rytx7epZSDkzw+ybtaQWTtnUluSfKMHpUIHamqandVVVct4tKfTvIvrT/E1O/9WJKLctfn+6lJNib5X23XVUn+Ms3ewmd2o25Yig6e9yTNP9TX3+9z8bwzsKqq+uyMHi+pquo7Sb6R5L5tp32/syZ08Mwn8R3P2lOHhZcmOaTttO/4mjBy7XpwkotmBDFJ8oW6fVBvy4Gue1uSm5LsKqX8R92rpuX+aU5D8aX2N9R/ILogzd8PWJXqvyk9KjOe79oXctfn+8FJbk1zuoKZ1yV+F1g9DkrzO3+6nl/pzeXucwB73llV6l4uRye5tj72/c6aNvOZb+M7njWhlLKtlHJEKeWepZTfSHN6sI/Xr/mOb2POyLXrmCRXznK+de7YHtYC3bQnyf9N8q9p/kHmR9KcZ+PTpZRHVlX15TSf/2Tu34FH96JQWCELPd+HlVI2V1W1u7726uruc7L4bwGryZVJXpfkv9L8i/QnJnlJkgeWUs6qqmpvfZ3nndXmZ5Mcl+bcqYnvd9a+mc984jueteVPkryo3t+f5ANpzpWa+I6/C2Hk2rU1zYmAZ9rV9jqsOlVVfTbJZ9tOfbCU8v40J8Z+bZp/gGk933P9Dnj+Wc0Wer5b1+yO/xawBlRV9fIZp/6+lHJRmhO7Py1JaxJ3zzurRinl1CRvTnJemgseJL7fWcPmeOZ9x7PW/FmS96cZFj4jyfokm+rXfMe3MUx77bo9yeZZzm9pex3WhKqqLk7yz0l+vJ4ouPV8z/U74PlnNVvo+W6/xn8LWKv+NM0eB49rO+d5Z1UopexMMpnmaqpPa1uEwPc7a9I8z/xcfMezKlVV9e2qqj5WVdU7q6p6cpqrZX+onqLAd3wbYeTadWUOdANu1zp3RQ9rgV64NM2/ddqWA93X5/od8Pyzmi30fF9fD+9oXbuz/gPQzOsSvwusUlVV3Z7kuiSHtZ32vDPwSikjST6c5oIGT6yqqv259P3OmrPAMz8r3/GsIe9PckaSe8d3/F0II9euC5Lce5YVyR7e9jqsJfdIs9v6LUm+nmRvkvZFbVJK2ZTm4k0X9Lg26Jqqqi5P8sPMeL5rD8tdn+8L0pwUfuaqlf5bwKpWStmR5Ig0fxdaLojnnQFWStmS5ENp/k/pk6uq+mb7677fWWsWeubneZ/veNaK1nDqEd/xdyWMXLven+b8BC9snSilbE7yc0k+X1XVpf0qDJajlHLkLOcemOScJP9WVdX+qqqmk3wsyXPqP8y0/I80u8r/Q0+KhZXzf5M8uZRyQutEKeWxaf5hv/35/uckd6Q5EXzrupLkxUkuz13nX4WBU0rZMuN7vOX3kpQkH2k753lnYNXTyLw3yZlJnl5V1XlzXOr7nTVhMc+873jWilLKUbOc25jkuWkOqW4F8b7jaxawWaOqqvp8KeUfkry2/sW4OMnzkowm+f/6WRss03tLKben+QV8TZqrab8wyW1Jxtuu+536mk+WUt6a5Pgkv5VmYPmRwIAqpfxymkOZWqvkPaWUcny9/xd12P6aJE9P8h+llP+ZZsh+bpKvJXlb615VVV1WSvmzJOfWfyD6YpKfSnNF+Z9dxJxNsKIWet6THJrky6WUv0vy7fr8E5L8ZJr/k/rPrXt53hlwf5LmX5x+KM0VU5/T/mJVVe+qd32/s1Ys5pnfGd/xrA1vqUelfirNsHBnmqvHn5rkt6qquqW+znd8rdx9pXDWirpb/B8meU6af5j/apLfq6rqo30tDJahlPKraX6x3yvJwWl2df94klfWC9m0X/uoJH+c5CFJbk7yviQvr6rq5p4WDR0opUwlOWmOl0+uqmqqvu5+Sd6Y5FFJ9qQ5MfxvVVV19Yz7rUvy20lelOY8M99J8tqqqt69EvVDJxZ63pPcmGYo+Yg0A8v1af4F67uTvKGqqjtm3M/zzkAqpXwiyWPmer2qqtJ2re93Vr3FPPOllEPiO541oJTyM2l2+rp/ksPT/H/P89PsSPDBGdf6jo8wEgAAAADoEXNGAgAAAAA9IYwEAAAAAHpCGAkAAAAA9IQwEgAAAADoCWEkAAAAANATwkgAAAAAoCeEkQAAAABATwgjAQAAAICeEEYCANA1pZS3l1Km+l1Hr5RSnl9KqUopD+13LQAAq4EwEgBgCNSB2WK2s/pdKwAAa9eGfhcAAEBP/I8Zx89N8vhZzn9rmZ/zgvgLbwAA5iCMBAAYAlVVvav9uJTyiCSPn3l+plLKQVVV3dbB59yxxBIBABgC/tYaAIAkSSnlE6WUr5dSTi+lfKqUcluS19SvPbWUMllKuaKUsruU8t1Syu+VUtbPuMdd5owspYzWw79fWkp5Yf2+3aWUL5ZSzlhkXYeUUv6slHJp/d6LSym/XUpZ13ZN++f8Rinl+6WU20spnyylnDbLPX+ilPLpUsqtpZQbSyn/XEq57yzXHVdK+du2n/uSUspfllI2zbh0cynljaWUH9b3/MdSypGL+fkAAIaJnpEAALQ7PMmHk/x9knclubo+//wktyR5Y93+RJJXJTk4ybmLuO+zk+xI8pYkVZKXJflAKeUe8/WmLKUclOSTSY6r3/uDJI9M8tokxyT59RlveW79OW9OsiXJryX5f6WU+1dVdXV9z8fVP+P3kjSSbE3yK0k+U0p5SFVVU/V1xyb5QpJDkrw1ybfrOp6W5KAke9o+9y+S3JDklUlG67relOSZi/hnAwAwNISRAAC025nkxVVVvWXG+WdXVXV72/FflVL+KslLSim/W1XV7gXue2KSU6qquiFJSikXJvnnJE9I8i/zvO83k9wzyYOrqvpOfe4tpZQrkpxbSvmTqqoubbv+XvXnXF5/zkeSfD7Jb9f3SpLXJ7k+yZlVVV1fX/dPSb6cZpj4vPq619b/PB5eVdWX2j7j90spZUad1yU5u6qqqr7fuiS/WkoZqapqev5/NAAAw8MwbQAA2u1O8raZJ9uDyFLKjlLKEUk+nWYPwVMXcd/3toLI2qfr9h4LvO/p9bU3lFKOaG1JPpZkfZIfm3H9P7WCyLruL6QZRv5kXfsxSR6U5O2tILK+7qtJ/r3tunVJfirJh2YEka3rqxmn3jrj3Kfr+k5a4OcDABgqekYCANDu8qqq9sw8WUq5X5I/SnN49sEzXh5ZxH1/0H5QVdUNdefCQxd43ylJHpDkh3O8ftSM4+/Mcs1FSZ5R77fCwQtnue5bSZ5QStmWZHuaP+fXF6iv5QczjlvB60I/HwDAUBFGAgDQ7vaZJ0oph6Q5b+NNSX4/yXeT7ErykCR/nMWNttk3x/mZw51nWpdmj8XXzfH6RYv47F5Y6s8HADBUhJEAACzkrDQXtvnvVVV9qnWylHJyDz77u0m2V1X1sUVef8os5+6dZKre/37d3meW605Ncm1VVbeWUm5PM3y920rcAAAsnTkjAQBYSKvX3529/Eopm5K8pAef/b4kZ5ZSnjDzhVLKIaWUmX+5/lOllOParnlYkoenuXp2qqq6MskFSZ5X9/hsXXdakrOT/Gt93f4k/5TkKaWUh87y2Xo8AgAsgZ6RAAAs5LNpzoH4jlLKnyepkvyP9GYI8uuTnJPkX0opb09yfpJtSe6f5GlJRpNc23b9xUn+s5Tyl0k2J/n1NFe6bh/mfW6a4eR5pZS/TbI1ya8kmU7SaLvuFWkGlJ8spbw1zTklj0lzUZ1HJbmxWz8kAMCwEEYCADCvqqquK6U8OcmfpLmIzQ1J3pXk40k+usKffVsp5TFpBoNPT/LcNIdPX5TkD9IMENu9M8n+NEPIo5J8Ickv1z0iW/f8WCnliUlemeRVSe5Ic07M366q6pK26y4vpTw8yR8m+dk0F7S5PM0g87au/7AAAEOgVFXV7xoAAGBZSimjSS5Jcm5VVW/oczkAAMzBnJEAAAAAQE8IIwEAAACAnhBGAgAAAAA9Yc5IAAAAAKAn9IwEAAAAAHpCGAkAAAAA9IQwEgAAAADoCWEkAAAAANATwkgAAAAAoCeEkQAAAABATwgjAQAAAICeEEYCAAAAAD0hjAQAAAAAeuL/BwB3eDNnECdLAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -363,7 +348,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "b3345522", "metadata": {}, @@ -376,7 +360,6 @@ "execution_count": 12, "id": "08f1cba4", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -409,7 +392,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "cca76db8", "metadata": {}, @@ -439,7 +421,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "5332e2b4", "metadata": {}, @@ -448,7 +429,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "45dbdd1e", "metadata": {}, @@ -464,7 +444,6 @@ "execution_count": 14, "id": "218d0983", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -482,7 +461,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "ce21c2dc", "metadata": {}, @@ -491,7 +469,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "4153c7db", "metadata": {}, @@ -510,7 +487,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "b5e254ad", "metadata": {}, @@ -523,7 +499,6 @@ "execution_count": 16, "id": "233a57da", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -535,7 +510,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABSUAAALGCAYAAACzhvREAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABS0ElEQVR4nO3dd5xdZZ0/8M83CQklMfQqTWSxoAhRFFcR24oFdxXboj/Fsj8L7i4rNiwL6q669t4Lrv4EXWGVYnfBsosNRVAEAaVJ6CT0UPL8/rh32MswSSZ3Jmcmk/f79bqvy33Oc8753jtzmJlPnvM81VoLAAAAAEBXZk11AQAAAADAukUoCQAAAAB0SigJAAAAAHRKKAkAAAAAdEooCQAAAAB0SigJAAAAAHRKKAkAAAAAdEooCQAAAAB0SigJAAAAAHRKKAkAzBhVdY+q+lBVXVBVt1dVq6oHVdV+/f8+cqprZHrrf5+cMqrtyH77flNU08H98x88qv2CqrpgKmoaqGFKPxsAYO0llAQAplQ/0GiTdLh3Jfn7JGcmeUeStyS5bJKODUOpqqP63+c7TXUtq2tFgSgAwETNmeoCAAAm0VOS/KG1dsBgY1XdZ4rqYWb4SJJjklw0Ref/zyQ/TbJ4is6/MlP92QAAaymhJAAwk2yb5EdTXQQzS2vtqiRXTeH5lyZZOlXnX5mp/mwAgLWX27cBgGmnqnbq3zJ6VP+/j6mqq6rqlqr6ZVU9ZVT/U/q3gFeSR43cEj56bsAxzrPCOflWNldeVd2nX9vFVXVrVV1eVV+uqt1WcKwNq+p1/dqvr6obqur3/fkvtxqj7+FVdXpV3djve2pV/e3K3ssY53xgVR3df4/LqurKqvpVVX2gqtYb1Xd2Vb2sqv67qpZW1c1VdV5Vfaaqdh3Vd2FVvaOqzul/Pa6tqu9U1ePGqOHOuTyrau+qOqmqrhl9K3NV/W1VnVxVS/rH/H1Vvamq5o1xzEdW1QlVdUn/fV1WVT+tqiNW47OZW1Vvrqrz+8f4U1X9y1jn6/cf83thPLX0vy9f0H/5p4HvzQsG+pzSb5tbVf/c/2yXVdVR/e0rvYW6/zX5SFX9uf/5nVVV/1BVNarfSudWHX099K+fz/dffn6g9ju/fqu4Th5bVd/uf82XVdUfquqdVbVwjL4jn8GcqnpDVZ3b3+fiqvq3qpo7Vs0AwNrLSEkAYDrbMcnPk/wxyReTbJrk2Um+UVWPa62d3O93VJJTkhyR5ML+6yS5YLILqqr9kxyXZL0kJyQ5L8k9kzw9yZOr6tGttV8N9N8kyclJ9khyTpLPJbk1yS5JXtg/1uX9vhsn+a8keyb5Vb/vrCRPSPLlqrp/a+1N46jxgUl+lqQlOT7Jn5LcI8m9k7wiyZuS3NbvOzfJiUken+TiJF9Ocl2SnZI8LclPkpw7UN9/J7lfkl8k+UCSzZM8K8l3q+rlrbVPjlHSPkkO7x/rc/19bu0f83P9z+GSJMcmWZLkYUneluSxVfX41trtA5/9Sf36jk/y5/S+J+7bf19vGcdnU0m+muSvk5yf3u3Hc5O8KMkDVrX/wHHGW8tbkvxNel//D/bfXwaeBx2b5CFJvpXk60muGEcpc5N8P8nG6d1GPTfJgf1z7ZbkkPG+pzEc1a/zr5N8I8npA9uWrGzHqnppko8nuTHJf6T3XvZL8rokB1TVX7bWxjrGl5M8Mr3P4LokT0ry2iRbpvd9AgDMEEJJAGA62y/Jka21O8Omqvpykm8neU16YV9aa0f1tx2R5ILW2pFroph+wHh0kpuS7NtaO2tg2+7pzfv3mSR7Dez20fQCqU8kOaS1tnxgn/lJZg/0/UB6geTrWmvvGui3fnoh1Ruq6muttdNXUeoLkqyf5G9aa98Y4z3cNNB0ZHqB5AlJntlaWzbQd156YeaIf0svkPxUkpe11lq/378l+WWSD1XVd1prF4yq56/6/e8SWPZH/r0wvTkTn9tau3lg25HphcyHpBewJcnfpRfS7tda+82oY22+wk/jrv42vZDtp0ke3Vq7pb//EekFreM1rlpaa0f2RxXukeQDY3w2g3ZMsnv/lujx2ia90H73ka/dwHt5RVV9pbU21JQGrbWj+oMt/zrJ10eus1Wpqh2TfCjJDUn2bq2dPbDtY0lent6iVP93jN13SXL/1to1/f5vTPKbJM+vqsNbaxauAoAZwu3bAMB0dmGSfxlsaK19J71FNfaegnqen96ItCMGA8l+Xb9N8ukke1bV/ZKkqrZMb2Tn4iSvHgwk+/vc0J8vMFW1WZLnJfnlYCDZ73dLeiPMKslBq1HvzaMbWmvXjtRRVbPTG9V3c3qh4bJRfZe11q7s953br++GJIePBJL9fuemF0LNTe8zGu30FYyg/Mcktyd50WAg2fe2JFcnee4439d4g7yR0XZvGAkk+/tf0z/n6ppILaO9ech9Dx/82o16L1MxuvB56X0vfGQwkOx7Y5Lrk/yfFdwu/7qRQDJJWms3Jvl/6f3d8uA1VC8AMAWMlAQAprPTW2t3jNF+cXq3BHdt5Jx7rGBevr/oP983yVnp3Yo7K8mP+uHKyjwkvVGTK5rzb2QeyPuOo86vpBf4fb2qvpbe7b3/3Vo7f1S/+yRZmORnrbVLV3HM3ZJs2D/ONWNs/6/0bgvfc4xtPx/dUFUbpjd68Kokh46a/nDEstz1/f6/9G6T/1lVfSW9kbL/3Vq7ZBW1D9oryfL0biUf7ZTVOM5k1DLa3T6ncbg9yf+M0X5K/3msr8eaNjJS+L9Gb2itXVtVv06yb3rff78Z1eWXYxzv4v7zJpNWIQAw5YSSAMB0tmQF7bdnau742Kz//Her6De//7xx//nPq3Hsh/Qfqzr2CrXWfl5Vj0xvVNozkvyfJKmqc5K8pbV29BD1jSxOsngF20faNx5j21i33G6S3sjPLdK7TXuVWmvHVW+Ro8PSmwPypUlSVaelN1rwe+M4zMIk17TWbhtnnWuylqHPP+CqFQT3I8e626IyHRj6e2UF80ze3n+ePcY2AGAt5fZtAGBdtjwr/kfajcdoW9p/3qO1Vit5fKHfb0n/ebtx1DJy7Pev4tiPHs8ba62d2lp7Snrh31+mdzvvVuktmDOyUvYw9W29gu3bjOp3l3JWcrxfr+L93mUIZWvtpNbaY9J7X49N8v4k909y4sht8+N4H5vWqBXI+1b03sY0CbWMPt5Yn9OqbN6/DX+0kfcy+PUYmT5gdb7nhzGR7xUAYB0hlAQA1mXXJtlqBQHVWPPX/bT//MhxHv/n6QVB+1bVRuPsO95jj0t/Xsj/aa39c5J/6Df/df/57PSCyQdW1barONQ56S2Qs0d/Fe7RRsLSX42xbay6bkjyuyT3r6pNx7PPqP1vbK39V2vtVUnent4chk8cx66/Su934EeMsW2/1a1jnLWMjGRcEyP95iR5+Bjt+/Wffz3Qdm3/efvRnavq3hl7VOUwtY+cc7/RG/rfOw9KckuS36/GMQGAGUYoCQCsy36eXqhzl8VA+qtC/+UY/T+fXoh3RFXdbaGdqppVVfuNvO4vEnNMeiPD3lNVs0b1n19VC/t9r0hvnsIHV9Wbxxr9VlW7VNXOq3pTVfXwqtpgjE1b9Z9v6p/zjiQfS7JBkk+MXnikquZW1Rb9vrf261uQUQvCVNUu6QWetyX54qrqG/C+9AK8z40VdFbVJlW118DrfatqrFF+d3lfq/D5/vO/9lc1Hzn2punNiTkuq1nL1f3nHcZ7/NX0jsGv3aj38vmBfmcnuS7JX/cXYRrpv0F6CxWNZZjav5Te98Lf98POQW9Lb0X3L41eWAkAWLeYUxIAWJd9OL1A8uNV9dj0FtR4UHoL2pyY5CmDnVtrV1fVM5L8Z5KfVtUP0hvt19IbfbZPenNDrj+w2yuT7J7kZUn2q6rvJLk1yc5JnpDkqfnfRUlemWTXJG9Nb3XinyS5PMm26S348pAkf5vkT6t4X69N8piq+nG/7w3p3Vb8xPRGy31qoO9bkjw0yQFJ/lBVJ6a3OvL2Sf4qyWuSHNXv+/r0RnK+sqoekt7iLpsneVZ6YeUrW2urqu1OrbXPVdWi9FYAP7//2VyUZNP+57NveqHay/q7fCjJdlX130kuSO9zXJTkMemt1H7MOE57dHoroj81yW+r6hvpLSL0jCS/SLLLOMtfnVp+kN7n+OmqOja9z3dJa+0j4zzXyixOMi+993J8/ve9bJPkY621H410bK3dVlUfTPLmJL+uqv9M7++Bxye5tP8Y7dT0AtZD+yvEj8xV+eGRleNHa61dUFWHJvlokl9V1VeTXJnkUeldI2ent5o8ALAOE0oCAOus1tpZ/fkV355eKHd7kh+nF5w8PaNCyf4+P6iqByZ5dXqh4iPTC6QuTW+14WNH9b+2qh6e5ND0wrD/m94tsRcn+Vx6q3SP9L2uqh7V73NQkgPTCzgvT3Jukn9KMp4FVD6WXvj40PRuU56T5JJ++3tbaxcOnPPWqto/veDv+UlekN4CNJemF77+ZKDvNVW1T5LD+5/Pq5LcnN6I03e31r47jtruorV2SFV9q3/+x6U3r+E16YWT705v1N2Ityd5Wnq31j8uvdvdL+q3f6C1dm1WobXWquqZ6QWsB6cXBC9OL/x8a3q3FY/HuGtprX2nqg5Lb4GkQ9MbHXphkskIJW/tn//tSZ6TXkj8xyTvTC90H+2I9ELGv0vv++yy9ALUIzPwvThQ+7VVdWB/v4OTjExD8KWsZE7I1trHquq89K6TA9Nbuf3i9L6mb1/BgjYAwDqkhptPGwAAAABgOOaUBAAAAAA6JZQEAAAAADollAQAAAAAOiWUBAAAAAA6JZQEAAAAADollAQAAAAAOjVnqgvoWlVVkm2TXD/VtQAAAADAWmpBkktba22Ynde5UDK9QPKSqS4CAAAAANZy90zy52F2XBdDyZERkveM0ZIAAAAAsLoWpDfob+hsbV0MJUdc31q7bqqLAAAAAIC1SW92xImx0A0AAAAA0CmhJAAAAADQKaEkAAAAANApoSQAAAAA0Kl1eaEbAAAAgHXKaaedtiDJNjFQjbtbnuTqJNcuWrRo+Zo+WbXW1vQ5ppWqukeSpUkWWn0bAAAAWBecdtpps5K8Yfbs2c+vqvWSTHz5ZGac1trtrbXLli9f/p4kx68onJyMfM1ISQAAAICZ7w3rrbfey7feeutbN9poo5uqat0apcYqtdZy++23z1m6dOnOS5Ys+fBtt912/yT/uqbOZ6QkAAAAwAx22mmn3WP27Nm/3Hbbbdfbcsstr57qepj+Lr/88s0WL1584x133PHwRYsW3S0/m4x8zfwBAAAAADPb1lW13kYbbXTTVBfC2mH+/Pk3VtX8JFuvqXMIJQEAAABmtllJyi3bjFfVnVOOrrHsUCgJAAAAAHRKKAkAAAAAdEooCQAAAADTxN57773b3nvvvdtU17GmCSUBAAAAgE7NmeoCAAAAAJgaO73+pEVTXUOSXPDOJ5821TXQLSMlAQAAAGAMy5cvzw033FCr7snqEkoCAAAAsFZ61atetW1VLfrtb38778ADD9xpwYIFD1qwYMGDnvGMZ+x0/fXX35l73XbbbXnNa16zzfbbb7/73Llz99puu+0e8MpXvnK7m2+++S6B43bbbfeARz/60fc+9thj77H77rvfd4MNNtjrfe973xYnnnjigqpa9JnPfGaTww47bJstt9zygRtttNGe+++//72uvvrq2TfffHO96EUv2n7TTTfdY8MNN9zzGc94xk6jj/3BD35ws4c97GF/semmm+4xd+7cvXbZZZf7/9u//dsWXX1W043btwEAAABYqz3rWc+61/bbb3/rm970pj//+te/3vArX/nK5ltsscVtH//4x/+cJM95znN2Ou644zbbf//9rz3kkEMu//nPf77RRz/60a3POeec9b/3ve+dP3isP/7xj+u/6EUvutfznve8K1/wghdced/73nfZyLb3vve926y//vrL//Ef//Gy8847b94XvvCFLQ8++OBWVVm6dOns1772tZf+7Gc/2+jYY4/dbKeddlr2nve8Z/HIvp/5zGe23G233W5+0pOetGTOnDntm9/85savf/3rd1i+fHkOP/zwK7v7tKYHoSQAAAAAa7Xdd9/9pq9+9asXjry+5ppr5hxzzDGbf/zjH//zqaeeusFxxx232bOf/eyrjjnmmJE+V770pS+9/VOf+tRWJ5xwwoIDDjjg+pF9L7roonlf+9rXzj3wwAOvG2k78cQTFyTJHXfckZ/+9KfnzJs3ryXJVVddNeekk07a9JGPfOTSH/7wh+eNHHvPPfdc/+ijj958MJQ89dRTz54/f34bef2GN7zhykc+8pG7fuxjH9tqXQwl3b4NAAAAwFrtkEMOuUuo95d/+ZfXL1myZM4111wz6/jjj1+YJK997WsvH+zzxje+8bIkOeGEExYOtm+33Xa3DgaSg5797GdfPRJIJsnee+99Y2stBx988NWD/fbaa68bL7vssrm33XbbnW2DgeTVV189e/HixXMe8YhHXH/JJZfMu/rqq2ev9pteyxkpCQAAAMBa7V73utetg6832WSTO5LeSMYLL7xw7qxZs3L/+99/2WCfHXbY4fYFCxbccfHFF88dbN9+++3v0m/UPnc5z8KFC+9Ikh133PFu7cuXL8/VV189e+utt74jSb773e9udOSRR27361//eqNbbrnlLgMFr7nmmtmbbbbZHeN/x2s/oSQAAAAAa7U5c8aOuFq7c3BiZs2a1cbsNMr666+/fHXPM2fOnDGP3VqrJPnd734374ADDtht5513vuWtb33rxTvssMNt8+bNW37iiScu/OxnP7vV8uUrPOWMJZQEAAAAYMbacccdb12+fHnOPPPM9ffaa69bRtovvvjiOddff/3s7bff/taV7T8Zjj322IW33nprnXDCCeftuuuud57vBz/4wT3W9LmnK3NKAgAAADBjPfWpT12aJO95z3u2Gmx/+9vfvlWSHHDAAUvXdA2zZ/emjBwcuXn11VfP/spXvrLZmj73dGWkJAAAAAAz1j777HPz05/+9KuPPvrozZcuXTr7kY985PW/+MUvNjruuOM2e9zjHrdkcOXtNeUpT3nK0re85S33fMpTnnLvF77whVfecMMNs7/4xS9uvummm95+5ZVXrremzz8dGSkJAAAAwIx2zDHHXHDYYYdd+pvf/GajN7/5zdv/z//8z4JDDjnksuOPP/6PXZx/jz32WHbUUUedX1V5y1vesv1RRx21xfOf//wrX/7yl1++6r1nphocNrouqKp7JFmaZGFrbczl3QEAAHZ6/Ukz4o+lC9755JrqGoCpddppp91nzpw53951111v2HDDDW9Z9R6s62666ab1zz333Pm33377/osWLTp79PbJyNeMlAQAAAAAOiWUBAAAAAA6JZQEAAAAADollAQAAAAAOiWUBAAAAAA6JZQEAAAAADollAQAAAAAOiWUBAAAAAA6JZQEAAAAADollAQAAAAAOiWUBAAAAAA6JZQEAAAAADollAQAAACAdURVLXrVq1617VTXMWeqCwAAAABgihy5cNFUl5AkOXLpaVNdwnTyiU98YtMrrrhizj//8z9fMdW1rClGSgIAAADANPKVr3xl009+8pNbTXUda5JQEgAAAADGcNNNN9Udd9wx5rbrrrtOrjYBPjwAAAAA1mp/+tOf1nvWs56145ZbbvnAuXPn7rXddts94LnPfe4Ot9xySyXJWWedNfeJT3zivRYuXPigDTbYYM899tjjPsccc8zCwWOceOKJC6pq0ac+9alN/uEf/mHbLbfc8oHz58/f69prr5194IEH7rThhhvu+bvf/W7eox71qHtvtNFGez796U/fOUm22267Bxx44IE7ja5p77333m3vvffebfTxP/3pT2/yyle+crvNN998jw022GDPxzzmMfc+77zz1hvc75RTTll46aWXzq2qRVW1aLvttnvAyPabb765/umf/mnbHXbYYfe5c+futfXWWz/wZS972T1vvvnmGjz/zTffXC9+8Yu332STTfbYaKON9nzMYx5z7/PPP3+9TBPmlAQAAABgrXXBBRes99CHPvS+119//eyDDjroqvvc5z43//nPf557wgknbHLDDTfMuvLKK2vfffe97y233DLrRS960eWbbbbZ7UcfffTmz33uc+996623nv/85z9/yeDx3vWud2273nrrtUMOOeSyZcuWzZo3b15LkjvuuKOe+MQn7vqQhzzkhiOPPPLiDTfccPkw9b773e/epqry93//94uvuOKK9T772c9u9bjHPW633/72t7+bP39+O/zwwxe/4Q1vuOdll1223r/+679enCQLFixY3q8hj3/84+992mmnzT/ooIOuuu9973vzmWeeucFnPvOZLc8777x53//+988fOc/f/u3f7vSNb3xj0wMOOOCaffbZ54ZTTjnlHk960pN2HfqDnmRCSQAAAADWWq961au2u/rqq9c7+eSTf7/vvvveNNL+gQ984NLly5fn7/7u77a/+uqr53z7298+5wlPeMINSXLooYdedf/73//+hx9++PbPfe5zl8yePfvO4y1btqxOP/30s+bPn98Gz3PrrbfWAQcccO1HP/rRP0+k3qVLl845++yzf7vJJpssT5JFixbd9OIXv/heH/jAB7Z405vedMXTnva06z70oQ/det11181+xStecc3gvp/85Cc3PfXUU+/xzW9+8873kiS77777za997Wt3/N73vrfR4x//+BtPPfXUDb7xjW9s+rznPe/KL37xixclyeGHH37lU5/61J3/8Ic/bDCR+ieL27cBAAAAWCvdcccd+d73vrfxox/96CWDgeSIWbNm5Qc/+MHCBzzgATcOhngLFy5c/vznP//KSy+9dO6vfvWr9Qf3efazn3316EByxKGHHnrlRGt+5jOfefVIIJkkBx988LVbbLHFbd/5zncWrmy/JDn22GM3ude97nXLAx/4wFsWL148Z+Sx//77X58k3//+9xckyfHHH78wSV796ldfPrj/YYcddvndjzo1jJQEAAAAYK106aWXzrnhhhtm3+9+97t5RX0WL148d88997xhdPv97ne/W5Lk/PPPn/eQhzzklpH2nXfeedlYx5k9e3a7173udetEa951111vGXw9a9as7LDDDssuueSSuava94ILLlj/j3/84/rbbrvtHmNtv+KKK9ZLkgsvvHDurFmzcr/73e8u7+UBD3jALWPtNxWEkgAAAADQt+GGG445SnLu3Llt8DbvVbnjjjuyOv3HY/ny5dl1111vfte73nXxWNt33nnnCYemXRFKAgAAALBW2nbbbW+fP3/+HWedddYK50ncZpttbj3//PPXH93++9//fv0k2WWXXcYcGTleCxcuvH3p0qV3Sx8vvfTSudtvv/3dQsJzzz33LrUsX748F1100bzddtvtztGeVTV6tyTJjjvuuOz3v//9hk996lOvnzVrxbMy7rjjjrcuX748Z5111rw99tjjzvd35pln3u1zmCrmlAQAAABgrTR79uw8/vGPX3LyySdv/KMf/WjD0duXL1+exz72sUvPPPPMjb7//e9vNNJ+3XXXzfr3f//3zbfddttb99prrwnd0rzjjjsuO/300+ffcsstdyaJRx999MLLLrtszNux/+M//mOza6+99s5M7qijjtrkyiuvXO+v/uqvlo60bbjhhsuvv/76uwWdBx544LVXXHHFeu973/s2H73thhtuqOuuu25WkhxwwAFLk+Q973nPVoN93vve9241er+pYqQkAAAAAGut9773vX/+8Y9/fI8nPOEJux100EFX3fe+97158eLF6x1//PGbnnrqqWcfeeSRi7/xjW9s+rSnPW3XF7/4xVdsuummtx999NGb//nPf5531FFHnT/RW6xf8pKXXPXtb397k/3222/Xpz/96deef/7584477rhNt99++zFHYC5cuPD2hz3sYfd57nOfe9Xll1++3mc/+9mtdthhh2WHHnroVSN99txzzxtPOumkTV7ykpfc8yEPechNCxYsuOOggw5a+opXvOLqY489dpPXvva1O/7whz9csM8++9xwxx131Nlnn73+SSedtOnxxx//h3333femhz/84Tc/5SlPueZLX/rSFtddd93sffbZ54aTTz75HhdccMG8Cb3ZSSSUBAAAAFhXHbn0tKkuYaJ23nnn2/7nf/7n7Ne97nXb/ud//uemX/rSl2ZvueWWtz760Y++bv78+cs333zz9qMf/ej3hx122D0/97nPbXnrrbfO+ou/+IubvvzlL5/3nOc8Z+mqz7ByBx544HVHHHHEJR//+Me3evOb37z97rvvfuNxxx133mGHHbb9WP1f/epXLz7jjDM2/OAHP7jNTTfdNGufffa57lOf+tRFCxYsuHNF7te85jVX/uY3v9nwq1/96uaf/exnZ2+77ba3HnTQQWfOnj073/nOd85/29vetuVXvvKVzb/73e9usv766y/ffvvtl73kJS+5fPfdd79z1OdXvvKVCw455JDbv/71r2/6ve99b+OHPexh13/zm9889973vvcDJ/qeJ0O1NubcnTNWVd0jydIkC1tr1011PQAAwPS00+tPmhF/LF3wziePPTEZsM447bTT7jNnzpxv77rrrjdsuOGG02b15XXNiSeeuOCAAw74i8997nN/fOELX3jtVNezMjfddNP655577vzbb799/0WLFp09evtk5GvTak7Jqnp5VZ1RVdf1H6dW1RMHtp9SVW3U4xNTWTMAAAAAsHqm2+3blyR5fZJzk1SSFyT5RlXt2Vr7Xb/Pp5P888A+N3VbIgAAAAAwEdMqlGytnTCq6Y1V9fIkD0syEkre1Fq7rNvKAAAAAIDJMq1CyUFVNTvJM5NslOTUgU3PrarnJbksyQlJ3tZaW+Foyaqal2RwZaEFa6BcAAAAAFihpzzlKde31tb6hYUmy7QLJavqAemFkOsnuSHJ01prZ/U3fznJhUkuTfLAJP+WZLckT1/JIQ9PcsQaKxgAAAAAWC3TLpRMck6SByVZmOQZSb5QVY9qrZ3VWvvUQL8zq2pxkh9U1S6ttfNXcLx3JHnfwOsF6c1dCQAAALAuWJ4krbWproO1xMD3yvI1dY5pF0q21m5Ncl7/5WlV9ZAk/5jkpWN0/1n/+d5JxgwlW2vLkiwbeV1Vk1csAAAAwPR3dWvt9ttvv33a5UBMT7fddtt6rbXbkyxZU+eYtaYOPIlm5a5zQg56UP95cTelAAAAAKx1rm2tXbZ06VLrbLBKrbUsWbJk4fLly09ftGjRFWvqPNMqIa+qdyT5VpKL0rvN+qAk+yV5QlXt0n/9zSRXpzen5PuT/Ki1dsaUFAwAAAAwzS1atGj5aaed9p4lS5Z8eN68eZvNnz//RneSMlprLbfddtt6S5YsWbhkyZLrW2ufXJPnm1ahZJItk/x7km2SLE1yRpIntNa+V1XbJ3lckkPTW5H74iTHJvmXqSkVAAAAYK1x/G233Xb/xYsX/21VzZ/qYpieWmu3L1++/CettU8uWrToe2vyXNMqlGytvXgl2y5O8qgOywEAAACYERYtWrQ8yb+edtppH06yddaOKf3o1vIkS9bkLduDplUoCQAAAMCas2jRouuSXDfVdYBUHAAAAADolFASAAAAAOiUUBIAAAAA6JRQEgAAAADolFASAAAAAOiUUBIAAAAA6JRQEgAAAADolFASAAAAAOiUUBIAAAAA6JRQEgAAAADolFASAAAAAOiUUBIAAAAA6JRQEgAAAADolFASAAAAAOiUUBIAAAAA6JRQEgAAAADolFASAAAAAOiUUBIAAAAA6JRQEgAAAADolFASAAAAAOiUUBIAAAAA6JRQEgAAAADolFASAAAAAOiUUBIAAAAA6JRQEgAAAADolFASAAAAAOiUUBIAAAAA6JRQEgAAAADolFASAAAAAOiUUBIAAAAA6JRQEgAAAADolFASAAAAAOiUUBIAAAAA6JRQEgAAAADolFASAAAAAOiUUBIAAAAA6JRQEgAAAADolFASAAAAAOiUUBIAAAAA6JRQEgAAAADolFASAAAAAOiUUBIAAAAA6JRQEgAAAADolFASAAAAAOiUUBIAAAAA6JRQEgAAAADolFASAAAAAOiUUBIAAAAA6JRQEgAAAADolFASAAAAAOiUUBIAAAAA6JRQEgAAAADolFASAAAAAOiUUBIAAAAA6JRQEgAAAADolFASAAAAAOiUUBIAAAAA6JRQEgAAAADolFASAAAAAOiUUBIAAAAA6JRQEgAAAADolFASAAAAAOiUUBIAAAAA6JRQEgAAAADolFASAAAAAOiUUBIAAAAA6JRQEgAAAADo1LQKJavq5VV1RlVd13+cWlVPHNi+flV9tKqurqobqurYqtpqKmsGAAAAAFbPtAolk1yS5PVJFiV5cJL/SvKNqrp/f/v7kxyQ5JlJHpVk2yTHTUGdAAAAAMCQ5kx1AYNaayeManpjVb08ycOq6pIkL05yUGvtv5Kkql6Y5PdV9bDW2k87LhcAAAAAGMJ0Gyl5p6qaXVXPSbJRklPTGz25XpLvj/RprZ2d5KIk+6zkOPOq6h4jjyQL1mzlAAAAAMDKTLtQsqoeUFU3JFmW5BNJntZaOyvJ1kluba0tGbXL5f1tK3J4kqUDj0smvWgAAAAAYNymXSiZ5JwkD0ry0CQfT/KFqrrfBI73jiQLBx73nGiBAAAAAMDwptWckknSWrs1yXn9l6dV1UOS/GOSrySZW1UbjxotuVWSy1ZyvGXpjbpMklTVpNcMAAAAAIzfdBwpOdqsJPOSnJbktiSPHdlQVbsl2SG9OScBAAAAgLXAtBopWVXvSPKt9BavWZDkoCT7JXlCa21pVX02yfuq6pok1yX5cJJTrbwNAAAAAGuPaRVKJtkyyb8n2Sa9RWnOSC+Q/F5/+z8lWZ7k2PRGT34nySumoE4AAAAAYEjTKpRsrb14FdtvSXJI/wEAAAAArIXWhjklAQAAAIAZRCgJAAAAAHRKKAkAAAAAdEooCQAAAAB0SigJAAAAAHRKKAkAAAAAdEooCQAAAAB0SigJAAAAAHRKKAkAAAAAdEooCQAAAAB0SigJAAAAAHRKKAkAAAAAdEooCQAAAAB0SigJAAAAAHRKKAkAAAAAdEooCQAAAAB0SigJAAAAAHRKKAkAAAAAdEooCQAAAAB0SigJAAAAAHRKKAkAAAAAdEooCQAAAAB0SigJAAAAAHRKKAkAAAAAdEooCQAAAAB0SigJAAAAAHRKKAkAAAAAdEooCQAAAAB0SigJAAAAAHRKKAkAAAAAdEooCQAAAAB0SigJAAAAAHRKKAkAAAAAdEooCQAAAAB0SigJAAAAAHRKKAkAAAAAdEooCQAAAAB0SigJAAAAAHRKKAkAAAAAdEooCQAAAAB0SigJAAAAAHRKKAkAAAAAdEooCQAAAAB0SigJAAAAAHRKKAkAAAAAdEooCQAAAAB0SigJAAAAAHRKKAkAAAAAdEooCQAAAAB0SigJAAAAAHRKKAkAAAAAdEooCQAAAAB0SigJAAAAAHRKKAkAAAAAdEooCQAAAAB0SigJAAAAAHRqzlQXAAAAzCw7vf6kNtU1AADTm5GSAAAAAECnhJIAAAAAQKeEkgAAAABAp4SSAAAAAECnhJIAAAAAQKeEkgAAAABAp4SSAAAAAECnhJIAAAAAQKeEkgAAAABAp4SSAAAAAECnhJIAAAAAQKemVShZVYdX1S+q6vqquqKqvl5Vu43qc0pVtVGPT0xVzQAAAADA6plWoWSSRyX5aJKHJXl8kvWSfLeqNhrV79NJthl4vLbLIgEAAACA4c2Z6gIGtdb2H3xdVQcnuSLJoiQ/Gth0U2vtsg5LAwAAAAAmyXQbKTnawv7zNaPan1tVV1XVb6vqHVW14YoOUFXzquoeI48kC9ZYtQAAAADAKk2rkZKDqmpWkg8k+e/W2m8HNn05yYVJLk3ywCT/lmS3JE9fwaEOT3LEmqsUAAAAAFgd0zaUTG9uyd2TPGKwsbX2qYGXZ1bV4iQ/qKpdWmvnj3GcdyR538DrBUkumexiAQAAAIDxmZahZFV9JMlTkuzbWltVgPiz/vO9k9wtlGytLUuybODYk1UmAAAAADCEaRVKVi8x/HCSpyXZr7X2p3Hs9qD+8+I1VRcAAAAAMHmmVSiZ3i3bByX56yTXV9XW/falrbWbq2qX/vZvJrk6vTkl35/kR621M6aiYAAAAABg9Uy3UPLl/edTRrW/MMlRSW5N8rgkhybZKMnFSY5N8i+dVAcAAAAATNi0CiVbayud8LG1dnGSR3VUDgAAAACwBsya6gIAAAAAgHWLUBIAAAAA6JRQEgAAAADolFASAAAAAOiUUBIAAAAA6JRQEgAAAADolFASAAAAAOiUUBIAAAAA6JRQEgAAAADolFASAAAAAOiUUBIAAAAA6JRQEgAAAADolFASAAAAAOjUnMk6UFVtmOQ5SeYl+WZr7cLJOjYAAAAAMHMMFUpW1WeTPLS1tnv/9dwkP02ye7/L0qp6TGvt15NTJgAAAAAwUwx7+/ajkxw38Pqg9ALJ5/afL0tyxMRKAwAAAABmomFDya2TXDDw+m+S/LK1dnRr7awkn07y0ImVBgAAAADMRMOGkjcm2ThJqmpOkv2SfGdg+/VJFk6kMAAAAABgZhp2oZtfJfm7qjo5yVOTLEhywsD2XZJcPsHaAAAAAIAZaNhQ8o3pjYz8ZZJK8rXW2s8Htj8tyX9PsDYAAAAAYAYaKpRsrf2yqu6T5OFJlrTWfjiyrao2TvKxJKdMRoEAAAAAwMwy1JySVbVvkrTWvjEYSPbbliT5cswpCQAAAACMYdiFbk5O8viVbH9Mvw8AAAAAwF0MG0rWKrbPS3LHkMcGAAAAAGawcc8pWVU7JNlpoOk+I7dxj7JxkpcmuXBClQEAAAAAM9LqLHTzwiRHJGn9xxv7j9EqvVGSL51wdQAAAADAjLM6oeRXk/w2vdDxq0k+lOTHo/q0JDcmOb21dvmkVAgAAAAAzCjjDiVba79P8vskqaoXJvlRa+1Pa6owAAAAAGBmWp2RkndqrX1hsgsBAAAAANYNQ4WSSVJV901vnsl7Jdkkd1+Ru7XWHjuB2gAAAACAGWioULKq/k+Szye5Lck5Sa4dq9sE6gIAAAAAZqhhR0oemeTXSZ7YWrtq8soBAAAAAGa6WUPut22SzwkkAQAAAIDVNWwoeUZ6wSQAAAAAwGoZNpR8VZIXV9XDJ7MYAAAAAGDmG3ZOydclWZrkx1V1VpKLktwxqk9rrf31RIoDAAAAAGaeYUPJByZp6YWR85Pcb4w+bdiiAAAAAICZa6hQsrW20yTXAQAAAACsI4adUxIAAAAAYCjjGilZVTskSWvtosHXqzLSHwAAAABgxHhv374gSauqDVprt468Hsd+s4esCwAAAACYocYbSr4ovRDytlGvAQAAAABWy7hCydbaUSt7DQAAAAAwXpOy0E1VbVBVG0zGsQAAAACAmW3oULKqdqiqz1fV5UluSHJDVV1eVZ+rqh0nr0QAAAAAYCYZ75ySd1FV90nykyQbJ/lekt/3N90nyfOTHFBVj2itnTMZRQIAAAAAM8dQoWSSdyZZnmTP1tqZgxuqavckP+j3edrEygMAAAAAZpphb99+VJIPjQ4kk6S19tskH0my3wTqAgAAAABmqGFDyfWS3LyS7Tf1+wAAAAAA3MWwoeSvk7ykqhaO3lBV90jy4iS/mkhhAAAAAMDMNOyckkck+XaSs6vq80n+0G/fLckLkmyW5JCJlwcAAAAAzDRDhZKttf+qqicleXeS14/afHqS/9NaO3mCtQEAAAAAM9CwIyXTWvt+kj2rauskO/abL2ytXTYplQEAAAAAM9LQoeSIfggpiAQAAAAAxmXYhW5SVVtU1Xuq6qyquqn/OKvfttVkFgkAAAAAzBxDhZJVdf8kZyZ5VZKlSf6j/1jabzujqnafrCIBAAAAgJlj2Nu3P5pkdpKHttZ+MbihqvZO8s0kH07y6ImVBwAAAADMNMPevr13kg+ODiSTpLX28yQfTPLQiRQGAAAAAMxMw4aSVyS5ZSXbb+n3AQAAAAC4i2FDyQ8keXlVbT16Q1Vtm+Tl/T4AAAAAAHcx7JySs5LckOS8qvrPJOf123dN8jf917Oq6lUD+7TW2vuHLRQAAAAAmBmGDSXfM/Dfzx1j+wNH9UmSlkQoCQAAAADruGFDyZ0ntQoAAAAAYJ0xVCjZWrtwsgsBAAAAANYNwy50AwAAAAAwFKEkAAAAANApoSQAAAAA0CmhJAAAAADQqXGFklX1D1X1F2u6GAAAAABg5hvvSMn3J3nwyIuquqOqDprsYqrq8Kr6RVVdX1VXVNXXq2q3UX3Wr6qPVtXVVXVDVR1bVVtNdi0AAAAAwJox3lDy2iSDwV+tgVqS5FFJPprkYUken2S9JN+tqo0G+rw/yQFJntnvv22S49ZQPQAAAADAJJszzn6nJDmyqh6UZGm/7flV9bCV7NNaa/+4OsW01vYffF1VBye5IsmiJD+qqoVJXpzkoNbaf/X7vDDJ76vqYa21n67O+QAAAACA7o03lHxFkg8k+askWyZp/f/+q5Xs05KsVig5hoX952v6z4vSGz35/TtP0trZVXVRkn2S3C2UrKp5SeYNNC2YYE0AAAAAwASM6/bt1toVrbWDWmvbtNZmp3f79vNaa7NW8pg9kcKqalZ6Qeh/t9Z+22/eOsmtrbUlo7pf3t82lsPTG9058rhkInUBAAAAABMz3jklR3thkv+ZzELG8NEkuyd5zgSP8470RlyOPO45weMBAAAAABMw3tu376K19oWR/66q+yXZsf/ywtbaWRMtqqo+kuQpSfZtrQ2ObLwsydyq2njUaMmt+tvGqnVZkmUDx55oeQAAAADABAw7UjJV9ddVdX6SM5Oc2H+cWVXnVdVThzxm9QPJpyV5TGvtT6O6nJbktiSPHdhntyQ7JDl1mHMCAAAAAN0aaqRkVT0pybFJLkzyhiS/72+6b5L/m+S4qnpKa+3bq3nojyY5KMlfJ7m+qkbmiVzaWru5tba0qj6b5H1VdU2S65J8OMmpVt4GAAAAgLXDUKFkkjcnOSPJI1trNw60H98f6fiTJEckWd1Q8uX951NGtb8wyVH9//6nJMvTC0XnJflOequDAwAAAABrgWFDyQcmecOoQDJJ0lq7saqOSvL21T1oa22VEz621m5Jckj/AQAAAACsZYadU/KWJJuuZPum/T4AAAAAAHcxbCj5X0n+sar2Gb2hqh6a5B+SfH8ihQEAAAAAM9Owt2+/Nr3Vrn9SVT9Pck6/fbckeye5IsnrJl4eAAAAADDTDDVSsrX2p/TmlfxQkk2SPLv/2CTJB5Ps0Vq7YJJqBAAAAABmkGFHSqa1dkV6K2H/0+SVAwAAAADMdMPOKQkAAAAAMBShJAAAAADQKaEkAAAAANCpoeeUBAAAYPrb6fUntamuYTJc8M4n11TXAMDkMVISAAAAAOjUaoeSVbVhVZ1WVS9bEwUBAAAAADPbaoeSrbWbkuycZEbcAgAAAAAAdGvY27e/neQJk1kIAAAAALBuGDaUfFuSv6iqL1bVI6pqu6radPRjMgsFAAAAAGaGYVff/l3/+X5JDlpJv9lDHh8AAAAAmKGGDSXfGnNKAgAAAABDGCqUbK0dOcl1AAAAAADriGHnlLyLqlpYVW7VBgAAAABWaehQsqoeXFXfrqqbklyd5FH99s2r6htVtd/klAgAAAAAzCRDhZJV9fAkP0mya5IvDR6ntXZVkoVJXjoZBQIAAAAAM8uwIyXfnuT36a2+/YYxtp+c5KHDFgUAAAAAzFzDhpIPSfL51tqyjL0K95+TbD10VQAAAADAjDVsKHnbKvbdLskNQx4bAAAAAJjBhg0lf5rkGWNtqKqNkrwwyQ+HLQoAAAAAmLmGDSWPSPLgqjopyRP7bXtU1UuSnJZkiyRvm4T6AAAAAIAZZqhQsrX2syRPSnLvJP/eb35vkk8lmZ3kSa21MyalQgAAAABgRpkz7I6ttf9KsltV7ZleODkryflJTmutjbX4DQAAAADA8KHkiNbar5P8ehJqAQAAAADWAUOHklU1L8nfpXcb90795guSfDPJZ1prt0y0OAAAAABg5hlqTsmqumeS05N8KMkeSa7sP/bot53e7wMAAAAAcBfDrr790SQ7JnlWa2271tqj+o/tkjw7yQ79PgAAAAAAdzHs7duPTfL+1trXRm9orf1HVe2V5O8nVBkAAAAAMCMNO1Ly+iRXrGT7Zf0+AAAAAAB3MWwo+fkkB1fVhqM3VNX8JC9M8tmJFAYAAAAAzEzjun27qp4+qunXSZ6c5Oyq+kKS8/rtuyZ5fpJrkpwxWUUCAAAAADPHeOeU/FqSlqT6rwf/+41j9L9nkqOTfHVC1QEAAAAAM854Q8lHr9EqAAAAAIB1xrhCydbaD9d0IQAAAADAumHYhW4AAAAAAIYy3tu376aqHpHkRUnulWST/O8ckyNaa22PCdQGAAAAAMxAQ4WSVfWqJO9OckuSc9JbbRsAAAAAYJWGHSn5miT/neSA1trSSawHAAAAAJjhhp1TcsMk/08gCQAAAACsrmFDyZOTPGAyCwEAAAAA1g3DhpJ/n+SxVfXqqtp0MgsCAAAAAGa2oULJ1trFST6Z5J1JrqyqG6vqulEPt3YDAAAAAHcz7Orbb03yxiR/TvLLJAJIAAAAAGBchl19+2VJTkryN6215ZNYDwAAAAAwww07p+TcJCcJJAEAAACA1TVsKHlikkdOZiEAAAAAwLph2FDyLUnuV1Ufq6pFVbVFVW06+jGZhQIAAAAAM8Owc0qe039+UJKXrqTf7CGPDwAAAADMUMOGkm9N0iazEAAAAABg3TBUKNlaO3KS6wAAAAAA1hHDzikJAAAAADCUoUZKVtU/j6Nba629bZjjAwAAAAAz17BzSh65km0tSfWfhZIAAAAAwF0Mdft2a23W6Ed6AecuSd6f5JdJtpzEOgEAAACAGWLS5pRsrS1vrf2ptfbqJOcm+fBkHRsAAAAAmDnW1EI3P0rypDV0bAAAAABgLbamQskHJ1m+ho4NAAAAAKzFhl19+/kr2LRxkn2TPD3JZ4asCQAAAACYwYZdffuolWy7Ksk7k7x1yGMDAAAAADPYsKHkzmO0tSTXttaun0A9AAAAAMAMN1Qo2Vq7cLILAQAAAADWDcOOlLxTVc1PskmSGr2ttXbRRI8PAAAAAMwswy50s36SI5K8OMlmK+k6e5jjAwAAAAAz17AjJT+W5AVJvp7kx0munayCAAAAAICZbdhQ8ulJPtNae+lkFlNV+yZ5TZJFSbZJ8rTW2tcHth+VXhg66Duttf0nsw4AAAAAYM2ZNeR+LcmvJrOQvo2S/CbJISvp8+30AsuRx9+ugToAAAAAgDVk2JGS30jyuCSfnMRa0lr7VpJvJUnV3dbNGbGstXbZZJ4XAAAAAOjOsCMl35bkXlX1qapaVFVbVNWmox+TWeiA/arqiqo6p6o+XlUrW2gnVTWvqu4x8kiyYA3VBQAAAACMw7AjJc/tP++Z3grcKzLZq29/O8lxSf6UZJckb0/yrarap7V2xwr2OTy9lcIBAAAAgGlg2FDyrenNK9mp1toxAy/PrKozkpyfZL8kP1jBbu9I8r6B1wuSXLJGCgQAAAAAVmmoULK1duQk1zGU1tofq+qqJPfOCkLJ1tqyJMtGXq9krkoAAAAAoAPDzik5LVTVPZNslmTxVNcCAAAAAIzPsLdvrxFVNT+9UY8jdq6qByW5pv84IsmxSS5Lb07JdyU5L8l3uq0UAAAAABjWtAolkzw4yckDr0fmgvxCkpcneWCSFyTZOMmlSb6b5M39W7QBAAAAgLXAtAolW2unJFnZpI9P6KgUAAAAAGANWavnlAQAAAAA1j5CSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU9MqlKyqfavqhKq6tKpaVf3NqO1VVW+tqsVVdXNVfb+qdp2icgEAAACAIUyrUDLJRkl+k+SQFWx/bZJ/SPKyJA9NcmOS71TV+t2UBwAAAABM1JypLmBQa+1bSb6VJFV1l23Vazg0yb+01r7Rb3t+ksuT/E2SYzosFQAAAAAY0nQbKbkyOyfZOsn3Rxpaa0uT/CzJPivaqarmVdU9Rh5JFqzxSgEAAACAFVqbQsmt+8+Xj2q/fGDbWA5PsnTgccnklwYAAAAAjNfaFEoO6x1JFg487jm15QAAAADAum1azSm5Cpf1n7dKsnigfaskp69op9basiTLRl6PnqsSAAAAAOjW2jRS8k/pBZOPHWnozxH50CSnTlVRAAAAAMDqmVYjJatqfpJ7DzTtXFUPSnJNa+2iqvpAkjdV1bnphZRvS3Jpkq93XCoAAAAAMKRpFUomeXCSkwdev6///IUkByd5V5KNknwqycZJfpJk/9baLd2VCAAAAABMxLQKJVtrpyRZ4aSPrbWW5J/7DwAAAABgLbQ2zSkJAAAAAMwAQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU0JJAAAAAKBTQkkAAAAAoFNCSQAAAACgU2tVKFlVR1ZVG/U4e6rrAgAAAADGb85UFzCE3yV53MDr26eqEAAAAABg9a2NoeTtrbXLxtu5quYlmTfQtGDySwIAAAAAxmttDCV3rapLk9yS5NQkh7fWLlpJ/8OTHNFJZQAAALAKO73+pDbVNUyGC9755JrqGoC111o1p2SSnyU5OMn+SV6eZOckP66qlY1+fEeShQOPe67hGgEAAACAlVirRkq21r418PKMqvpZkguTPCvJZ1ewz7Iky0ZeV/mHHAAAAACYSmvbSMm7aK0tSfKHJPee4lIAAAAAgHFaq0PJqpqfZJcki6e6FgAAAABgfNaqULKq3lNVj6qqnarq4Un+M8kdSY6e4tIAAAAAgHFaq+aUTG+RmqOTbJbkyiQ/SfKw1tqVU1oVAAAAADBua1Uo2Vp7zlTXAAAAAABMzFp1+zYAAAAAsPYTSgIAAAAAnRJKAgAAAACdEkoCAAAAAJ0SSgIAAAAAnRJKAgAAAACdEkoCAAAAAJ0SSgIAAAAAnRJKAgAAAACdEkoCAAAAAJ0SSgIAAAAAnRJKAgAAAACdEkoCAAAAAJ0SSgIAAAAAnRJKAgAAAACdEkoCAAAAAJ0SSgIAAAAAnRJKAgAAAACdEkoCAAAAAJ0SSgIAAAAAnRJKAgAAAACdEkoCAAAAAJ0SSgIAAAAAnRJKAgAAAACdmjPVBbAGHLmwTXUJwDRw5NKa6hIAWD07vf4kv8fBCrg+AGYWIyUBAAAAgE4JJQEAAACATgklAQAAAIBOCSUBAAAAgE4JJQEAAACATgklAQAAAIBOCSUBAAAAgE4JJQEAAACATgklAQAAAIBOCSUBAAAAgE4JJQEAAACATgklAQAAAIBOCSUBAAAAgE4JJQEAAACATgklAQAAAIBOzZnqAgCANeTIhW2qS2CKHbm0proEAIDVsdPrT5oxv8Ne8M4n+11sJYyUBAAAAAA6JZQEAAAAADollAQAAAAAOiWUBAAAAAA6JZQEAAAAADollAQAAAAAOiWUBAAAAAA6JZQEAAAAADollAQAAAAAOiWUBAAAAAA6JZQEAAAAADollAQAAAAAOiWUBAAAAAA6JZQEAAAAADollAQAAAAAOjVnqgsAYA05cmGb6hKAKeb/A2udC9af3OPtdMuXJ/eAADPQTq8/aUb8vLzgnU+uqa4BVoeRkgAAAABAp4SSAAAAAECnhJIAAAAAQKeEkgAAAABAp4SSAAAAAECnhJIAAAAAQKeEkgAAAABAp4SSAAAAAECnhJIAAAAAQKeEkgAAAABAp4SSAAAAAECn1spQsqoOqaoLquqWqvpZVe091TUBAAAAAOOz1oWSVfXsJO9L8pYkeyX5TZLvVNWWU1oYAAAAADAua10omeRVST7dWvt8a+2sJC9LclOSF01tWQAAAADAeMyZ6gJWR1XNTbIoyTtG2lpry6vq+0n2WcE+85LMG2haMPJcVWuq1Cm19PULVt0JAIAZb/mym6a6BGAGq6p7THUNk2H7Q7861SVMCl+P6WemfE1WYMLhU7XWJqOQTlTVtkn+nOThrbVTB9rfleRRrbWHjrHPkUmO6KxIAAAAAFg33LO19udhdlyrRkoO6R3pzUE5aNMk10xBLTPdgiSXJLlnkuunuBbANQnTjWsSph/XJUwvrkmYXlZ1TS5IcumwB1/bQsmrktyRZKtR7VsluWysHVpry5IsG9V83eSXxsDt8Ne31nzGMMVckzC9uCZh+nFdwvTimoTpZRzX5ISu07VqoZvW2q1JTkvy2JG2qprVf33qivYDAAAAAKaPtW2kZNK7FfsLVfXLJD9PcmiSjZJ8fiqLAgAAAADGZ60LJVtrX6mqLZK8NcnWSU5Psn9r7fIpLYykd5v8W3L32+WBqeGahOnFNQnTj+sSphfXJEwva/SaXKtW3wYAAAAA1n5r1ZySAAAAAMDaTygJAAAAAHRKKAkAAAAAdEooCQAAAAB0SijJUKpqm6p6Z1WdXFXXV1Wrqv1WY/8j+/uMftyy5qqGmW2i12X/GNtV1VeraklVXVdV36iqe62ZimHmq6qNq+pTVXVlVd3Yvz73Gue+R63gZ+XZa7puWNtV1byq+requrSqbq6qn1XV48e5r5+FMMmGvSb93QhrRlXNr6q3VNW3q+qa/nV18GrsP/TvuIPmrO4O0LdbktclOTfJmUn2GfI4L09yw8DrOyZYF6zLJnRdVtX8JCcnWZjk7UluS/JPSX5YVQ9qrV09ueXCzFZVs5KclGSPJO9OclWSVyQ5paoWtdbOHcdhliV5yai2pZNaKMxMRyV5RpIPpPdz8eAk36yqR7fWfrKinfwshDXmqAxxTQ7wdyNMrs2T/HOSi5L8Jsl+491xkn7HTSKUZHinJdmstXZNVT0jyX8MeZyvtdaumsS6YF020evyFUl2TbJ3a+0XSVJV30ry2ySHJXnDZBYL64BnJHl4kme21r6WJFX11SR/SPKWJAeN4xi3t9a+tOZKhJmnqvZO8pwkr2mtvaff9u/p/Tx7V3rX5Yr4WQiTbILX5Ah/N8LkWpxkm9baZVX14CS/WI19J+N33CRu32ZIrbXrW2vXTMKhqqruUVU1CceCddokXJfPSPKLkT/C+sc8O8kPkjxrovXBOugZSS5PctxIQ2vtyiRfTfLXVTVvPAepqtlVdY81UyLMSM9IbxTVp0YaWmu3JPlskn2qavtV7OtnIUyuiVyTI/zdCJOotbastXbZkLtPyu+4iVCSqffH9G5Du76qvlRVW011QbAu6g/Bf2CSX46x+edJdqmqBd1WBWu9PZP8qrW2fFT7z5NsmOQvxnGMDZNcl2Rpf76fj/ZvLwVWbM8kf2itXTeq/ef95weNtZOfhbDGDHVNjuLvRpg+JuN33CRu32bqXJvkI0lOTW++rEcmOSTJ3lX14DF+YAFr1qZJ5qU3jH+0kbZtk5zTWUWw9tsmyY/GaB+8ps5cyf6L07ut7Vfp/UPy/undWrpHVe3XWrt9EmuFmWSbrPrn2Vj8LIQ1Y9hrMvF3I0xHE/0d905CSUb+VXjuOLsva621iZ6ztfbBUU3HVtXPk/y/9P7geudEzwFrsym4LjcYOdYY224Z1QfWOUNekxtkAtdUa+3wUU3HVNUfkvxrerfNHDPOemBdM+y152chrBlD/zz0dyNMSxP6HXeQ27dJkn2T3DzOx25rqojW2peTXJbkcWvqHLAW6fq6vLn/PNb8H+uP6gPromGuyZsz+dfU+5Msj5+VsDLDXnt+FsKaMak/D/3dCFNu0q5pIyVJkrOTvHCcfccadj+ZLk7v1hlY13V9XV6T3r92bTPGtpG2SyfhPLC2GuaaXJxJvqZaazdX1dXxsxJWZnGS7cZoX9W152chrBnDXpMr4+9GmDqT9juuUJL0V1w6aqrr6K+ktlOSX09xKTDlur4uW2vLq+rMJA8eY/NDk/yxtXZ9V/XAdDPkNXl6kkdW1axRE4E/NMlNSf6wunX0F9nYPMmVq7svrENOT/LoqrrHqPnmHjqw/W78LIQ15vQMcU2uiL8bYcqdnkn6Hdft26xxVbVDVd1nVNsWY3R9eZItkny7k8JgHTbWdZnka0keUlUPHui3W5LHJPmPLuuDGeJrSbZK8vSRhqraPMkzk5zQWls20L5LVe0y8Hr9Fazy++YkFT8rYWW+lmR2kv870lBV89Ib7fyz1trF/TY/C6EbQ1+T/m6EqVVV21TVfapqvYHmcf+Ou8rjT8KaJayjqupN/f+8f5LnJPlckj8lSWvtXwb6nZLkUa21Gmi7KclX0luR6ZYkj+gf4zdJ/rK1dlMHbwFmnAlelwvS+xfnBUnek+S2JK9K75fIB7XWjMyC1VBVs5P8JMnuSd6d5Kr0JuXfIclDWmvnDPS9IElaazv1X++U3vV4dHq3jifJE5I8Kb0/wp486l+mgQFV9dUkT0tvHtbzkrwgyd5JHtta+1G/zynxsxA6MYFr0t+NsIZU1SuTbJzeatkvT3Jc/ncE8odba0ur6qj0rtedW2sX9Pcb9++4q6xBKMmwqmqF3zyjfpCckrv/cPl0kocn2T69yVAvTHJskn91WwwMbyLXZb/9nun9svhX6Y2mPyXJP7XWzlsT9cJMV1WbpPfL2t+ktxLhL5K8urX2y1H9LkjuEkpunOTDSR6W3i+Ks9P7I+7/JXlPa+22LuqHtVVVrZ/kbUmel2STJGckeXNr7TsDfU6Jn4XQiWGvSX83wprT//1zxxVs3rm1dsFYoWR/33H9jrvKGoSSAAAAAECXzCkJAAAAAHRKKAkAAAAAdEooCQAAAAB0SigJAAAAAHRKKAkAAAAAdEooCQAAAAB0SigJAAAAAHRKKAkAAAAAdEooCQAAAAB0SigJALCWqaqDq6pV1U5D7r9rVX23qpb2j/M3Ez0mAACsjjlTXQAAAJ37QpKdk7wxyZIkv0zyuKksCACAdYtQEgBg7fPFJMckWba6O1bVBkn2SfKvrbWPDLRPXnUAALAKbt8GAFjLtNbuaK3d0lprQ+y+Rf95ySSWxICq2miqawAAmO6EkgAAa5mx5n+sqguq6sSqekRV/byqbqmqP1bV8wf6HJnkwv7Ld/ePccFKztP6+4xuv6CqjhrVtnFVfaCqLq6qZVV1XlW9rqpmjeo3q6r+sarO7Nd4ZVV9u6oePKrf86rqtKq6uaquqapjqmr7cXw2C/p1XNCv44qq+l5V7TWq30Or6ptVdW1V3VhVZ1TVP47q85iq+nF/+5Kq+kZV3XdUnyP7n9P9qurLVXVtkp9M9H0AAMx0bt8GAJg57p3ka0k+m968kS9KclRVndZa+12S49IbIfn+JEcn+WaSGyZ60qraMMkPk2yX5JNJLkry8CTvSLJNkkMHun82ycFJvpXkM+n9PvrIJA9Lb27LVNUbk7wtyVf7fbZI8vdJflRVe7bWlqyknE8keUaSjyQ5K8lmSR6R5L5JftU//uOTnJhkcZIPJrmsv/0p/depqsf1a/xjkiOTbNCv4b+raq/W2gWjzvsfSc5N8oYkNQnvAwBgRhNKAgDMHLsl2be19uMkqaqvJrk4yQuTvLq1dkZVXZdeKPmr1tqXJum8r0qyS5I9W2vn9ts+WVWXJnlNVb23tXZxVT06vUDyQ621wVGJ763+pJZVtWOStyR5U2vt7SMdquq4JL9O8ookb8+KPTnJp1trhw20vWvgOLPTC04XJ3nQYDA4UkPfu5Nck2Sf1to1/e1f79fwliQvGHXe37TWDho41kTfBwDAjOb2bQCAmeOskUAySVprVyY5J8m91vB5n5nkx0murarNRx5Jvp9kdpJ9+/0OTNLSC+vuYmB+zKen9zvqV0cd67L0RiI+ehW1LEny0KradgXb90xv5fEPjB6pOFJDVW2T5EFJjhoJJPvbz0jyvSRPGuO4nxj1eqLvAwBgRjNSEgBg5rhojLZrk2yyhs+7a5IHJrlyBdu37D/vkuTSwaBvBceq9IK7sdy2ilpem96t6xdX1Wnp3aL+7621Pw7UkCS/Xckxduw/nzPGtt8neUJVbdRau3Gg/U+j+k30fQAAzGhCSQCAmeOOFbTXCtqHNXvU61npjSB81xh9k+QPq3HsWemNpnxixn4/K50Ds7X21ar6cZKnJfmrJK9J8rqqenpr7VurUcfqunnU6wm9DwCAmU4oCQDAilybZOPBhqqam97iNYPOTzK/tfb9VRzv/PRGGW66ktGS56cXov6ptbY6YeadWmuLk3wsyceqasv0Frh5Y3oL15zf77Z7ereXj2VkhfLdxth2nyRXjRolOZYJvw8AgJnMnJIAAKzI+fnf+SBH/N/cfaTkV5PsU1VPGH2Aqtq4qkb+IfzY9IK6I8boNzKa87j0RhYeMWrhmVTPZisqtqpmV9XCwbbW2hVJLk0yr9/0q/RutT60qjYeq4Z+qHl6khcM9qmq3dMbffnNFdUwYOj3AQCwLjBSEgCAFflMkk9U1bHp3Z69R5InJLlqVL93J3lqkhOr6qgkpyXZKMkDkjwjyU7pjS48uaq+mOQfqmrXJN9O7x/JH5nk5CQfaa2dX1VvSvKOJDv1V7y+Pr3FaZ6W5FNJ3rOCehckuaSqvpbkN+ndIv24JA9JcliStNaWV9XLk5yQ5PSq+nx6K3HfJ8n9++8v6d32/a0kp1bVZ5NskOTvkyxNcuSqPrgJvg8AgBlPKAkAwIp8Or0Q7cVJ9k9vhe3HJ/nBYKfW2k1V9agkb0hvJe7nJ7kuvbkkj0gvyBvxwiRn9I/57v62Xyb5n4HjvbOq/pDkn/K/oyovTvLdJMevpN6b0rtt+6/yv6tfn5fkFa21jw8c/ztV9ej+sQ/r9zu//35H+ny/qvZPb6Xwt6a3MM0Pk7yutTZ6UZsxTeB9AADMeNVam+oaAAAAAIB1iDklAQAAAIBOCSUBAAAAgE4JJQEAAACATgklAQAAAIBOCSUBAAAAgE4JJQEAAACATgklAQAAAIBOCSUBAAAAgE4JJQEAAACATgklAQAAAIBOCSUBAAAAgE4JJQEAAACATv1/j0CcE5vA6k0AAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -558,7 +533,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "8dd63529", "metadata": {}, @@ -571,7 +545,6 @@ "execution_count": 17, "id": "8bc72789", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -584,8 +557,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average influence of corrupted points: -1.055609\n", - "Average influence of other points: 0.107684255\n" + "Average influence of corrupted points: -1.0782924\n", + "Average influence of other points: 0.10896263\n" ] } ], @@ -601,7 +574,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "f1e747b1", "metadata": {}, @@ -610,7 +582,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "b00a6164", "metadata": {}, @@ -623,7 +594,6 @@ "execution_count": 18, "id": "462d545e", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -642,7 +612,6 @@ "execution_count": 19, "id": "1e096222", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -654,7 +623,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -678,7 +647,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "656e14dd", "metadata": {}, @@ -687,7 +655,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "3bf8c4dd", "metadata": {}, @@ -700,7 +667,6 @@ "execution_count": 20, "id": "efdb4050", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -720,7 +686,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Conjugate gradient: 100%|██████████| 54/54 [00:06<00:00, 8.31it/s]\n" + "Conjugate gradient: 100%|██████████| 54/54 [00:04<00:00, 12.30it/s]\n" ] } ], @@ -739,7 +705,6 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "28f46c8c", "metadata": {}, @@ -752,7 +717,6 @@ "execution_count": 21, "id": "599bab0a", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, @@ -765,7 +729,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Percentage error of cg over direct method:0.00019243561837356538 %\n" + "Percentage error of cg over direct method:0.00014557354006683454 %\n" ] } ], @@ -815,13 +779,17 @@ "cell_type": "code", "execution_count": 23, "id": "e0a6763d", - "metadata": {}, + "metadata": { + "tags": [ + "hide-input" + ] + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Percentage error of Arnoldi over direct method:87.29403018951416 %\n" + "Percentage error of Arnoldi over direct method:95.7504391670227 %\n" ] } ], @@ -870,13 +838,17 @@ "cell_type": "code", "execution_count": 25, "id": "8479274e", - "metadata": {}, + "metadata": { + "tags": [ + "hide-input" + ] + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Percentage error of EK-FAC over direct method:2013.3354187011719 %\n" + "Percentage error of EK-FAC over direct method:1927.0627975463867 %\n" ] } ], @@ -898,11 +870,15 @@ "cell_type": "code", "execution_count": 26, "id": "03927fb8", - "metadata": {}, + "metadata": { + "tags": [ + "hide-input" + ] + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -922,7 +898,6 @@ " edgecolors=\"r\",\n", " s=60,\n", ")\n", - "plt.legend([\"ekfac\", \"direct\"])\n", "plt.xlabel(\"Direct Influence Score\")\n", "plt.ylabel(\"EK-FAC Influence Score\")\n", "plt.title(\"Influence of training points - EK-FAC vs direct method\")\n", @@ -947,8 +922,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Pearson Correlation EK-FAC vs direct 0.9621345709705068\n", - "Spearman Correlation EK-FAC vs direct 0.9007179383832532\n" + "Pearson Correlation EK-FAC vs direct 0.9608164875442669\n", + "Spearman Correlation EK-FAC vs direct 0.8946217598307178\n" ] } ], @@ -968,35 +943,39 @@ "id": "3a88b8c5", "metadata": {}, "source": [ - "The correlation between the EK-FAC and the direct method is quite good, and it improves significantly if we just keep the points with highest absolute influence." + "The correlation between the EK-FAC and the direct method is quite good, and it improves significantly if we just keep top-20 highest absolute influences." ] }, { "cell_type": "code", "execution_count": 28, "id": "a3256f00", - "metadata": {}, + "metadata": { + "tags": [ + "hide-input" + ] + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Pearson Correlation EK-FAC vs direct 0.9898618538582042\n", - "Spearman Correlation EK-FAC vs direct 0.9127819548872179\n" + "Pearson Correlation EK-FAC vs direct - top-20 influences 0.9901775015427601\n", + "Spearman Correlation EK-FAC vs direct - top-20 influences 0.9428571428571428\n" ] } ], "source": [ "highest_inlfuence_idxs = np.argsort(np.abs(mean_train_influences))[-20:]\n", "print(\n", - " f\"Pearson Correlation EK-FAC vs direct\",\n", + " f\"Pearson Correlation EK-FAC vs direct - top-20 influences\",\n", " pearsonr(\n", " mean_ekfac_train_influences[highest_inlfuence_idxs],\n", " mean_train_influences[highest_inlfuence_idxs],\n", " ).statistic,\n", ")\n", "print(\n", - " f\"Spearman Correlation EK-FAC vs direct\",\n", + " f\"Spearman Correlation EK-FAC vs direct - top-20 influences\",\n", " spearmanr(\n", " mean_ekfac_train_influences[highest_inlfuence_idxs],\n", " mean_train_influences[highest_inlfuence_idxs],\n", @@ -1021,11 +1000,9 @@ ] }, { - "attachments": {}, "cell_type": "markdown", "id": "9245791c", "metadata": { - "editable": true, "slideshow": { "slide_type": "" }, From 886cb070f8c24eb345596623bc94734cb9338307 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Wed, 3 Jan 2024 13:55:39 +0100 Subject: [PATCH 26/87] fix to method in ekfac influence --- src/pydvl/influence/torch/influence_function_model.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index 5898cf1f8..e0fcdebd7 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -1196,6 +1196,10 @@ def _solve_hvp(self, rhs: torch.Tensor) -> torch.Tensor: return x def to(self, device: torch.device): - return EkfacInfluence( - self.model.to(device), self.ekfac_representation.to(device) + ekfac_influence_device = EkfacInfluence( + self.model.to(device), self.hessian_regularization ) + ekfac_influence_device.ekfac_representation = self.ekfac_representation.to( + device + ) + return ekfac_influence_device From 56c14d2271a0dbfd2ff3fffcc1ce07cdce3e747d Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Wed, 3 Jan 2024 14:04:31 +0100 Subject: [PATCH 27/87] update changelog --- CHANGELOG.md | 2 ++ src/pydvl/influence/base_influence_function_model.py | 4 ++-- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index efd1a1b6d..d80b7fe85 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,8 @@ - Bug in using `DaskInfluenceCalcualator` with `TorchnumpyConverter` for single dimensional arrays [PR #485](https://github.com/aai-institute/pyDVL/pull/485) +- Implement new method: `EkfacInfluence` + [PR #451](https://github.com/aai-institute/pyDVL/issues/451) ## 0.8.0 - 🆕 New interfaces, scaling computation, bug fixes and improvements 🎁 diff --git a/src/pydvl/influence/base_influence_function_model.py b/src/pydvl/influence/base_influence_function_model.py index 1274941c6..3147b90e6 100644 --- a/src/pydvl/influence/base_influence_function_model.py +++ b/src/pydvl/influence/base_influence_function_model.py @@ -37,8 +37,8 @@ def __init__(self): class NotImplementedLayerRepresentationException(ValueError): - def __init__(self): - super().__init__(f"Layer representation not implemented for this module.") + def __init__(self, message: str): + super().__init__(message) """Type variable for tensors, i.e. sequences of numbers""" From b464294164a7c3f0c43c67d16d86802d8e761923 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Wed, 3 Jan 2024 14:21:37 +0100 Subject: [PATCH 28/87] fix tests --- tests/influence/torch/test_influence_model.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/tests/influence/torch/test_influence_model.py b/tests/influence/torch/test_influence_model.py index f9e5942f4..b18c30c42 100644 --- a/tests/influence/torch/test_influence_model.py +++ b/tests/influence/torch/test_influence_model.py @@ -5,7 +5,10 @@ import pytest from numpy.typing import NDArray -from pydvl.influence.base_influence_function_model import NotFittedException +from pydvl.influence.base_influence_function_model import ( + NotFittedException, + NotImplementedLayerRepresentationException, +) from pydvl.influence.torch.influence_function_model import ( ArnoldiInfluence, CgInfluence, @@ -557,7 +560,7 @@ def test_influences_ekfac( ekfac_influence.influence_factors(x_test, y_test) if not are_active_layers_linear: - with pytest.raises(NotImplementedError): + with pytest.raises(NotImplementedLayerRepresentationException): ekfac_influence.fit(train_dataloader) elif isinstance(loss, nn.CrossEntropyLoss): ekfac_influence = ekfac_influence.fit(train_dataloader) From e2621d3511657d4212baddc81ee53afad1607149 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Wed, 3 Jan 2024 14:32:24 +0100 Subject: [PATCH 29/87] fix to method --- src/pydvl/influence/torch/influence_function_model.py | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index e0fcdebd7..2072323f2 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -1196,10 +1196,7 @@ def _solve_hvp(self, rhs: torch.Tensor) -> torch.Tensor: return x def to(self, device: torch.device): - ekfac_influence_device = EkfacInfluence( - self.model.to(device), self.hessian_regularization - ) - ekfac_influence_device.ekfac_representation = self.ekfac_representation.to( - device - ) - return ekfac_influence_device + self.model.to(device) + if self.is_fitted: + self.ekfac_representation.to(device) + return self From 02ff35d611219b357a821f7bf187e97ded9d087e Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Wed, 3 Jan 2024 14:39:39 +0100 Subject: [PATCH 30/87] fix dask tests --- tests/influence/test_influence_calculator.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/influence/test_influence_calculator.py b/tests/influence/test_influence_calculator.py index d11731d9a..a4d117478 100644 --- a/tests/influence/test_influence_calculator.py +++ b/tests/influence/test_influence_calculator.py @@ -12,6 +12,7 @@ from pydvl.influence import DaskInfluenceCalculator, InfluenceMode from pydvl.influence.base_influence_function_model import ( + NotImplementedLayerRepresentationException, UnsupportedInfluenceModeException, ) from pydvl.influence.influence_calculator import ( @@ -368,7 +369,7 @@ def test_dask_ekfac_influence(model_and_data, test_case): ) if not are_active_layers_linear(model): - with pytest.raises(NotImplementedError): + with pytest.raises(NotImplementedLayerRepresentationException): EkfacInfluence(model).fit(train_dataloader) elif isinstance(loss, nn.CrossEntropyLoss): ekfac_influence = EkfacInfluence( From e161c42c49d39d85efc01f13a4d46e1dc14fb911 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Wed, 3 Jan 2024 18:30:49 +0100 Subject: [PATCH 31/87] notebook - first complete version --- notebooks/influence_sentiment_analysis.ipynb | 569 +++++++++++------- .../torch/influence_function_model.py | 43 +- 2 files changed, 349 insertions(+), 263 deletions(-) diff --git a/notebooks/influence_sentiment_analysis.ipynb b/notebooks/influence_sentiment_analysis.ipynb index 953fcd0bd..c3a97df98 100644 --- a/notebooks/influence_sentiment_analysis.ipynb +++ b/notebooks/influence_sentiment_analysis.ipynb @@ -30,20 +30,48 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Setup" + "
\n", + "\n", + "If you are reading this in the documentation, some boilerplate has been omitted for convenience.\n", + "\n", + "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Let's start by importing the required libraries. If not already installed, you can install them with `pip install -r requirements-notebooks.txt`." + "## Setup" ] }, { "cell_type": "code", "execution_count": 1, + "metadata": { + "tags": [ + "hide-input" + ] + }, + "outputs": [], + "source": [ + "%load_ext autoreload" + ] + }, + { + "cell_type": "markdown", "metadata": {}, + "source": [ + "Let's start by importing the required libraries. If not already installed, you can install them with `pip install -r requirements-notebooks.txt`." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "tags": [ + "hide-output" + ] + }, "outputs": [ { "name": "stderr", @@ -69,8 +97,31 @@ }, { "cell_type": "code", - "execution_count": 2, - "metadata": {}, + "execution_count": 3, + "metadata": { + "tags": [ + "hide-input" + ] + }, + "outputs": [], + "source": [ + "plt.rcParams[\"figure.figsize\"] = (16, 8)\n", + "plt.rcParams[\"font.size\"] = 12\n", + "plt.rcParams[\"xtick.labelsize\"] = 12\n", + "plt.rcParams[\"ytick.labelsize\"] = 10\n", + "plt.rcParams[\"axes.facecolor\"] = (1, 1, 1, 0)\n", + "plt.rcParams[\"figure.facecolor\"] = (1, 1, 1, 0)\n", + "DEVICE = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "tags": [ + "hide" + ] + }, "outputs": [], "source": [ "seed = 42\n", @@ -94,7 +145,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -102,7 +153,7 @@ "output_type": "stream", "text": [ "Found cached dataset imdb (/Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0)\n", - "100%|██████████| 3/3 [00:00<00:00, 528.25it/s]\n" + "100%|██████████| 3/3 [00:00<00:00, 310.53it/s]\n" ] } ], @@ -119,7 +170,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -168,7 +219,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The review seems quite negative, so label 0 seems to be associated to negative sentiment." + "The review is negative, and so label 0 is associated to negative sentiment." ] }, { @@ -180,7 +231,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -199,7 +250,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -234,8 +285,12 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, + "execution_count": 9, + "metadata": { + "tags": [ + "hide-input" + ] + }, "outputs": [ { "name": "stdout", @@ -259,7 +314,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -281,8 +336,12 @@ }, { "cell_type": "code", - "execution_count": 9, - "metadata": {}, + "execution_count": 11, + "metadata": { + "tags": [ + "hide-input" + ] + }, "outputs": [ { "name": "stdout", @@ -311,8 +370,12 @@ }, { "cell_type": "code", - "execution_count": 10, - "metadata": {}, + "execution_count": 12, + "metadata": { + "tags": [ + "hide-output" + ] + }, "outputs": [ { "name": "stderr", @@ -321,13 +384,6 @@ "Loading cached shuffled indices for dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-c1eaa46e94dfbfd3.arrow\n", "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-c5cc0d728c27151c.arrow\n" ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "F1 Score: 0.955\n" - ] } ], "source": [ @@ -343,8 +399,23 @@ " input_ids=sample_test_set[\"input_ids\"],\n", " attention_mask=sample_test_set[\"attention_mask\"],\n", " )[0]\n", - " predictions = torch.argmax(logits, dim=1)\n", - "\n", + " predictions = torch.argmax(logits, dim=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "F1 Score: 0.955\n" + ] + } + ], + "source": [ "f1_score_value = f1_score(sample_test_set[\"label\"], predictions)\n", "print(f\"F1 Score: {round(f1_score_value, 3)}\")" ] @@ -372,7 +443,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -440,7 +511,7 @@ " print(f\"True label: {true_label} \\n\")\n", "\n", "\n", - "def strip_param_names(param_names: Sequence[str]):\n", + "def strip_layer_names(param_names: Sequence[str]):\n", " \"\"\"\n", " Helper function that strips the parameter names of the model and the transformer,\n", " so that they can be printed and compared more easily.\n", @@ -463,7 +534,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -491,8 +562,12 @@ }, { "cell_type": "code", - "execution_count": 13, - "metadata": {}, + "execution_count": 16, + "metadata": { + "tags": [ + "hide-input" + ] + }, "outputs": [ { "name": "stdout", @@ -535,8 +610,12 @@ }, { "cell_type": "code", - "execution_count": 14, - "metadata": {}, + "execution_count": 17, + "metadata": { + "tags": [ + "hide-output" + ] + }, "outputs": [ { "name": "stderr", @@ -544,8 +623,8 @@ "text": [ "Loading cached shuffled indices for dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-9c48ce5d173413c7.arrow\n", "Loading cached shuffled indices for dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-c1eaa46e94dfbfd3.arrow\n", - "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-b86b62990cd870b5.arrow\n", - "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-74aeeb1b0543e07c.arrow\n" + "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-9aaaa3770ef3f9bf.arrow\n", + "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-7a8cbae367cafa72.arrow\n" ] } ], @@ -580,14 +659,21 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "K-FAC blocks - batch progress: 100%|██████████| 15/15 [01:45<00:00, 7.04s/it]\n" + "K-FAC blocks - batch progress: 0%| | 0/15 [00:00" ] }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "torch.mean(ekfac_train_influences, axis=0).numpy().astype(int)" + "plt.imshow(ekfac_train_influences.numpy().astype(int), vmin=-1000, vmax=500)\n", + "plt.colorbar(label=\"Influence value \")\n", + "plt.title(\"Influence of training examples on test examples\")\n", + "plt.xlabel(\"Training examples idx\")\n", + "plt.ylabel(\"Test examples idx\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Most of the test and training examples have similar influence, close to zero. However, there is one test and one training example that stand out. In particular, their influence is a very large negative values. Let's see what these examples are." ] }, { "cell_type": "code", - "execution_count": 20, - "metadata": {}, + "execution_count": 23, + "metadata": { + "tags": [ + "hide-input" + ] + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ + "Training example with idx 3: \n", + "\n", "Positive probability: 18.099999999999998%\n", "Negative probability: 81.89999999999999%\n", "True label: Positive \n", @@ -733,6 +857,8 @@ "source": [ "train_sentence_idx = 3\n", "\n", + "print(f\"Training example with idx {train_sentence_idx}: \\n\")\n", + "\n", "print_sentiment_preds(\n", " wrapped_model,\n", " train_input[train_sentence_idx],\n", @@ -747,42 +873,24 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Highest influence on test examples" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 35, 23, 15, -322, 11, 0, 9],\n", - " [ -147, -11, -30, 918, -46, 111, 2],\n", - " [ -4, 2, -3, 81, 0, 8, 0],\n", - " [ 0, 0, 0, 4, 0, 0, 0],\n", - " [ 770, 336, 487, -19124, 367, -71, 151]])" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ekfac_train_influences.numpy().astype(int)" + "We can see that, despite being positive, this review is quite hard to classify. Its language is overall negative, mostly related to the facts narrated rather than the movie itself. Notice also how several terms are related to war and invasion." ] }, { "cell_type": "code", - "execution_count": 67, - "metadata": {}, + "execution_count": 24, + "metadata": { + "tags": [ + "hide-input" + ] + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ + "Test example with idx 4: \n", + "\n", "Positive probability: 39.6%\n", "Negative probability: 60.4%\n", "True label: Negative \n", @@ -806,6 +914,8 @@ "source": [ "test_sentence_idx = 4\n", "\n", + "print(f\"Test example with idx {test_sentence_idx}: \\n\")\n", + "\n", "print_sentiment_preds(\n", " wrapped_model, test_input[test_sentence_idx], test_labels[test_sentence_idx].item()\n", ")\n", @@ -815,45 +925,20 @@ ] }, { - "cell_type": "code", - "execution_count": 25, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Positive probability: 18.099999999999998%\n", - "Negative probability: 81.89999999999999%\n", - "True label: Positive \n", - "\n", - "Sentence:\n" - ] - }, - { - "data": { - "text/html": [ - "In the process of trying to establish the audiences' empathy with Jake Roedel (Tobey Maguire) the filmmakers slander the North and the Jayhawkers. Missouri never withdrew from the Union and the Union Army was not an invading force. The Southerners fought for State's Rights: the right to own slaves, elect crooked legislatures and judges, and employ a political spoils system. There's nothing noble in that. The Missourians could have easily traveled east and joined the Confederate Army.

It seems to me that the story has nothing to do with ambiguity. When Jake leaves the Bushwhackers, it's not because he saw error in his way, he certainly doesn't give himself over to the virtue of the cause of abolition." - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ - "train_sentence_idx = 3\n", - "\n", - "print_sentiment_preds(\n", - " wrapped_model,\n", - " train_input[train_sentence_idx],\n", - " train_labels[train_sentence_idx].item(),\n", - ")\n", + "This review is also quite hard to classify. This time it is negative, but it contains several positive terms. The parallel with the previous review is quite interesting, since both reviews talk about an invasion. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As it is often the case when analysing influence functions, it is hard to understand why these examples have such a large influence. We have seen some interesting patterns, mostly related to similarities in the language and words used, but it is hard to say with certainty if these are the reasons for the large influence.\n", "\n", - "print(\"Sentence:\")\n", - "display(HTML(train_text[train_sentence_idx]))" + "A [recent paper](https://arxiv.org/abs/2308.03296) has explored these patterns in high detail, even for much larger language models than bert (up to ~50 billion parameters!). What has been found is that while smaller models tend to rely a lot on word-to-word correspondencies, larger models are more capable to extract higher level concepts, drawing connections between words from the whole sentence.\n", + "For more info, you can visit our [blog on influence functions for large language models](https://transferlab.ai/pills/2023/llm-influences-with-ekfac/)" ] }, { @@ -867,12 +952,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "What happens if we corrupt the training data? Let's try to corrupt the same training example we used before, and see how the influence function changes." + "The limited computational resources available to us do not allow us to compute the influence function for all the training examples. However, we can still get an idea of how the influence function changes when we corrupt the training examples. In the next cell we will flip the label of all the training examples and compute the influence function for the same test examples as before." ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ @@ -889,44 +974,40 @@ }, { "cell_type": "code", - "execution_count": 27, - "metadata": {}, + "execution_count": 26, + "metadata": { + "tags": [ + "hide-input" + ] + }, "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "tensor([ 130.7261, 70.4297, 93.8776, -3688.6289, 66.4447, 9.6771,\n", - " 32.7693])" + "
" ] }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "torch.mean(ekfac_train_influences, axis=0)" + "plt.imshow(corrupted_ekfac_train_influences.numpy().astype(int), vmin=-1000, vmax=500)\n", + "plt.colorbar(label=\"Influence value \")\n", + "plt.title(\"Influence of corrupted training examples\")\n", + "plt.xlabel(\"Training examples idx\")\n", + "plt.ylabel(\"Test examples idx\")\n", + "plt.show()" ] }, { - "cell_type": "code", - "execution_count": 28, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "tensor([-2576.7700, -2709.6460, -3631.7090, 815.2777, -2247.4573, -872.0656,\n", - " -1619.0323])" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "torch.mean(corrupted_ekfac_train_influences, axis=0)" + "Overall, when corrupted the influences turn from positive to negative and vice versa, as expected. More interestingly, some influences that were close to zero before corruption now have a large magnitude, while others keep having a small magnitude." ] }, { @@ -936,20 +1017,18 @@ "## Influence functions by layer" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since ekfac is based on a block diagonal approximation of the Fisher information matrix, we can compute the influence function separately for each layer of the neural network. In this section we show how to do that and we briefly analyse the results." + ] + }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 27, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/fabio/miniconda3/envs/pydvl_env/lib/python3.9/site-packages/transformers/models/distilbert/modeling_distilbert.py:222: UserWarning: There is a performance drop because we have not yet implemented the batching rule for aten::masked_fill.Tensor. Please file us an issue on GitHub so that we can prioritize its implementation. (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/functorch/BatchedFallback.cpp:84.)\n", - " scores = scores.masked_fill(\n" - ] - } - ], + "outputs": [], "source": [ "influences_by_layer = ekfac_influence_model.influences_by_layer(\n", " test_input,\n", @@ -959,59 +1038,84 @@ ")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The method `influences_by_layer` returns a dictionary containing the influence function values for each layer of the neural network as a tensor. To recover the full influence values as returned by `influences`, we need can sum the values in the dictionary as follows." + ] + }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ "influences = torch.zeros_like(ekfac_train_influences)\n", "for layer_id, value in influences_by_layer.items():\n", - " influences += value" + " influences += value.detach()" ] }, { - "cell_type": "code", - "execution_count": 37, + "cell_type": "markdown", "metadata": {}, + "source": [ + "And if we plot the influence values as a heatmap, as done in section [Negative influence training examples](#Negative-influence-training-examples), we can see that the results are the same." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "tags": [ + "hide-input" + ] + }, "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "tensor([[ 3.5063e+01, 2.3881e+01, 1.5637e+01, -3.2224e+02, 1.1226e+01,\n", - " -1.4874e-01, 9.6876e+00],\n", - " [-1.4736e+02, -1.1331e+01, -3.0170e+01, 9.1802e+02, -4.6235e+01,\n", - " 1.1149e+02, 2.7890e+00],\n", - " [-4.4213e+00, 2.7296e+00, -3.2295e+00, 8.1575e+01, -3.3690e-01,\n", - " 8.3784e+00, -3.1832e-01],\n", - " [-9.1143e-02, -9.6700e-02, -1.4497e-01, 4.0539e+00, -9.4822e-02,\n", - " 4.7056e-01, -3.4283e-02],\n", - " [ 7.7044e+02, 3.3697e+02, 4.8730e+02, -1.9125e+04, 3.6766e+02,\n", - " -7.1804e+01, 1.5172e+02]], grad_fn=)" + "
" ] }, - "execution_count": 37, - "metadata": {}, - "output_type": "execute_result" + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], "source": [ - "influences" + "plt.imshow(influences.numpy().astype(int), vmin=-1000, vmax=500)\n", + "plt.colorbar(label=\"Influence value \")\n", + "plt.title(\"Influence from layers\")\n", + "plt.xlabel(\"Training examples idx\")\n", + "plt.ylabel(\"Test examples idx\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's analyse how the influence values change across different layers for given test and train examples. " ] }, { "cell_type": "code", - "execution_count": 78, + "execution_count": 30, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -1029,11 +1133,11 @@ "plt.legend()\n", "plt.xticks(\n", " range(len(influences_by_layer.keys())),\n", - " strip_param_names(influences_by_layer.keys()),\n", + " strip_layer_names(influences_by_layer.keys()),\n", " rotation=70,\n", ")\n", "plt.xlabel(\"Layer id\")\n", - "plt.ylabel(\"Influence\")\n", + "plt.ylabel(\"Influence value\")\n", "plt.title(f\"Influence of test example {test_idx} on test examples\")\n", "plt.show()" ] @@ -1042,19 +1146,47 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Appendix" + "The plot above shows the influences for test idx 0 and all train idx apart idx=3 (excluded for clarity since it has a very large influence). We can see that the influence values keep their sign across layers, but in almost all casesthey tend to decrease when approaching the output layer. This is not always the case, and in fact other test examples show different patterns. Understanding why this happens is an interesting research direction." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conclusion" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ekfac is a powerful approximate method for computing the influence function of models that use a cross-entropy loss. In this notebook we have shown how to use it for a sentiment analysis with BERT on the IMDB dataset. However, this method can be applied to much larger models and problems, e.g. to analyse the influence of entire sentences generated by GPT, Llama or Claude. For more info, you can visit our [blog on influence functions for large language models](https://transferlab.ai/pills/2023/llm-influences-with-ekfac/)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Appendix: Choosing the Hessian regularization value" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The Hessian regularization value impacts a lot the quality of the influence function approximation. In general, the value should be chosen as small as possible so that the influence values are finite. However, even when finite the influence values can be very large, which can lead to numerical instabilities. In this section we show how to efficiently analyse the impact of the Hessian regularization value in the ekfac representation. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Choosing the Hessian regularization value" + "Let's start with a few additional imports." ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ @@ -1063,63 +1195,35 @@ ] }, { - "cell_type": "code", - "execution_count": 24, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "K-FAC blocks: 100%|██████████| 2/2 [00:11<00:00, 5.78s/it]\n" - ] - } - ], "source": [ - "wrapped_model = ModelLogitsWrapper(model)\n", - "wrapped_model.eval()\n", - "\n", - "ekfac_influence_model = EkfacInfluence(\n", - " wrapped_model,\n", - " progress=True,\n", - ")\n", - "ekfac_influence_model = ekfac_influence_model.fit(train_dataloader)" + "The method `explore_hessian_regularization` will calculate the influence values of the training examples with each other for a range of Hessian regularization values. The method optimises gradient calculation and Hessian inversion to minimise the computation time." ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ - "first_train_batch = next(iter(train_dataloader))" + "influences_by_reg_value = ekfac_influence_model.explore_hessian_regularization(\n", + " train_input,\n", + " train_labels,\n", + " regularization_values=[1e-15, 1e-9, 1e-5, 1],\n", + ")" ] }, { - "cell_type": "code", - "execution_count": 26, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/fabio/miniconda3/envs/pydvl_env/lib/python3.9/site-packages/transformers/models/distilbert/modeling_distilbert.py:222: UserWarning: There is a performance drop because we have not yet implemented the batching rule for aten::masked_fill.Tensor. Please file us an issue on GitHub so that we can prioritize its implementation. (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/aten/src/ATen/functorch/BatchedFallback.cpp:84.)\n", - " scores = scores.masked_fill(\n" - ] - } - ], "source": [ - "influences_by_reg_value = ekfac_influence_model.explore_hessian_regularization(\n", - " first_train_batch[0],\n", - " first_train_batch[1],\n", - " regularization_values=[1e-9, 1e-7, 1e-5, 100],\n", - ")" + "The resulting object, `influences_by_reg_value` is a dictionary that associates to each regularization value the influences for each layer of the neural network. This is a lot of data, so we will first organise it in a pandas dataframe and take the average across training examples." ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ @@ -1133,9 +1237,16 @@ " )" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "With this dataframe, we can take contiguous values of the regularization regularizationa and, for each layer, calculate the Pearson and Spearman correlation coefficients across training examples. This will give us an idea of how the influence values change when the regularization value changes." + ] + }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 34, "metadata": {}, "outputs": [], "source": [ @@ -1154,19 +1265,28 @@ "result_df = pd.DataFrame(result_corr).T" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's plot the correlations heatmap. The y-axis reports Spearman and Pearson correlations for each layer, while the x-axis reports pairs of regularization values. High correlations mean that the influence values are stable across regularization values. " + ] + }, { "cell_type": "code", - "execution_count": 78, + "execution_count": 35, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -1174,13 +1294,20 @@ "plt.figure(figsize=(10, 6))\n", "plt.imshow(result_df, cmap=\"coolwarm_r\", aspect=\"auto\")\n", "plt.xticks(range(result_df.shape[1]), result_df.columns, rotation=45)\n", - "plt.yticks(range(result_df.shape[0]), strip_param_names(result_df.index))\n", + "plt.yticks(range(result_df.shape[0]), strip_layer_names(result_df.index))\n", "plt.colorbar(label=\"Correlation Value\")\n", "plt.title(\"Correlation Heatmap\")\n", "plt.xlabel(\"Regularization Values\")\n", "plt.ylabel(\"Layer ID\")\n", "plt.show()" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In our case, we can see that for regularization equals to 1 the correlations become very bad. However, for a large range of parameters before that the influences rankings are very stable. This is a good indication that the model is not too sensitive to the regularization value. We therefore choose 1e-5 as the regularization value for the rest of the notebook." + ] } ], "metadata": { diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index a57978528..132d44949 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -910,7 +910,7 @@ def __init__( ): super().__init__(model, torch.nn.functional.cross_entropy) - self._hessian_regularization = hessian_regularization + self.hessian_regularization = hessian_regularization self.active_layers = self._parse_active_layers() self.progress = progress @@ -921,22 +921,6 @@ def is_fitted(self): except AttributeError: return False - @property - def hessian_regularization(self): - return self._hessian_regularization - - @hessian_regularization.setter - def hessian_regularization(self, value): - if self._hessian_regularization is None: - self._hessian_regularization = value - else: - raise ValueError( - "Hessian regularization can only be set once." - "To change the regularization value but retain the fitted representation, " - "create a new EkfacInfluence instance and pass ekfac_representation after " - "initialization." - ) - def _parse_active_layers(self) -> Dict[str, torch.nn.Module]: """ Find all layers of the model that have parameters that require grad @@ -1233,21 +1217,6 @@ def _solve_hvp(self, rhs: torch.Tensor) -> torch.Tensor: x.detach_() return x - def _influences( - self, - x_test: torch.Tensor, - y_test: torch.Tensor, - x: Optional[torch.Tensor] = None, - y: Optional[torch.Tensor] = None, - mode: InfluenceMode = InfluenceMode.Up, - ) -> torch.Tensor: - if self.hessian_regularization is None: - raise ValueError( - "Hessian regularization must be set for calculating influences." - ) - - return super()._influences(x_test, y_test, x, y, mode=mode) - def influences_by_layer( self, x_test: torch.Tensor, @@ -1261,11 +1230,6 @@ def influences_by_layer( "Instance must be fitted before calling influence methods on it" ) - if self.hessian_regularization is None: - raise ValueError( - "Hessian regularization must be set for calculating influences." - ) - if x is None: if y is not None: @@ -1303,11 +1267,6 @@ def influence_factors_by_layer( "Instance must be fitted before calling influence methods on it" ) - if self.hessian_regularization is None: - raise ValueError( - "Hessian regularization must be set for calculating influence factors." - ) - return self._solve_hvp_by_layer( self._loss_grad(x.to(self.model_device), y.to(self.model_device)), self.ekfac_representation, From e9dd00c1dc4586b7501dc10b376e9ef99b38cd07 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Thu, 4 Jan 2024 00:27:25 +0100 Subject: [PATCH 32/87] docs and tests of by_layer methods --- .../torch/influence_function_model.py | 98 ++++++++++++++++++- tests/influence/torch/test_influence_model.py | 9 ++ 2 files changed, 106 insertions(+), 1 deletion(-) diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index 132d44949..6ec61e74d 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -1176,6 +1176,11 @@ def _solve_hvp_by_layer( ekfac_representation: EkfacRepresentation, hessian_regularization: float, ) -> Dict[str, torch.Tensor]: + """ + Compute the Hessian Vector Product for each layer of the model, using the + provided ekfac representation and hessian regularization. It returns a + dictionary containing the Hessian Vector Product for each layer. + """ hvp_layers = {} start_idx = 0 for layer_id, (_, evecs_a, evecs_g, diag) in ekfac_representation: @@ -1225,6 +1230,26 @@ def influences_by_layer( y: Optional[torch.Tensor] = None, mode: InfluenceMode = InfluenceMode.Up, ) -> Dict[str, torch.Tensor]: + """ + Compute the influence of the data on the test data for each layer of the model. + + Args: + x_test: model input to use in the gradient computations of + $H^{-1}\nabla_{\theta} \ell(y_{\text{test}}, + f_{\theta}(x_{\text{test}}))$ + y_test: label tensor to compute gradients + x: optional model input to use in the gradient computations + $\nabla_{\theta}\ell(y, f_{\theta}(x))$, + resp. $\nabla_{x}\nabla_{\theta}\ell(y, f_{\theta}(x))$, + if None, use $x=x_{\text{test}}$ + y: optional label tensor to compute gradients + mode: enum value of [InfluenceType] + [pydvl.influence.base_influence_model.InfluenceType] + + Returns: + A dictionary containing the influence of the data on the test data for each + layer of the model, with the layer name as key. + """ if not self.is_fitted: raise ValueError( "Instance must be fitted before calling influence methods on it" @@ -1262,6 +1287,21 @@ def influence_factors_by_layer( x: torch.Tensor, y: torch.Tensor, ) -> Dict[str, torch.Tensor]: + """ + Computes the approximation of + + \[H^{-1}\nabla_{\theta} \ell(y, f_{\theta}(x))\] + + for each layer of the model separately. + + Args: + x: model input to use in the gradient computations + y: label tensor to compute gradients + + Returns: + A dictionary containing the influence factors for each layer of the model, + with the layer name as key. + """ if not self.is_fitted: raise ValueError( "Instance must be fitted before calling influence methods on it" @@ -1280,6 +1320,35 @@ def influences_from_factors_by_layer( y: torch.Tensor, mode: InfluenceMode = InfluenceMode.Up, ) -> Dict[str, torch.Tensor]: + """ + Computation of + + \[ \langle z_{\text{test_factors}}, + \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \] + + for the case of up-weighting influence, resp. + + \[ \langle z_{\text{test_factors}}, + \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \] + + for the perturbation type influence case for each layer of the model separately. + The gradients are meant to be per sample of the batch $(x, y)$. + + Args: + z_test_factors: pre-computed tensor, approximating + $H^{-1}\nabla_{\theta} \ell(y_{\text{test}}, + f_{\theta}(x_{\text{test}}))$ + x: model input to use in the gradient computations + $\nabla_{\theta}\ell(y, f_{\theta}(x))$, + resp. $\nabla_{x}\nabla_{\theta}\ell(y, f_{\theta}(x))$ + y: label tensor to compute gradients + mode: enum value of [InfluenceType] + [pydvl.influence.twice_differentiable.InfluenceType] + + Returns: + A dictionary containing the influence of the data on the test data for each + layer of the model, with the layer name as key. + """ if mode == InfluenceMode.Up: total_grad = self._loss_grad( x.to(self.model_device), y.to(self.model_device) @@ -1317,6 +1386,11 @@ def _non_symmetric_values_by_layer( y: torch.Tensor, mode: InfluenceMode = InfluenceMode.Up, ) -> Dict[str, torch.Tensor]: + """ + Similar to _non_symmetric_values, but computes the influence for each layer + separately. Returns a dictionary containing the influence for each layer, + with the layer name as key. + """ if mode == InfluenceMode.Up: if x_test.shape[0] <= x.shape[0]: fac = self.influence_factors_by_layer(x_test, y_test) @@ -1336,7 +1410,11 @@ def _non_symmetric_values_by_layer( def _symmetric_values_by_layer( self, x: torch.Tensor, y: torch.Tensor, mode: InfluenceMode ) -> Dict[str, torch.Tensor]: - + """ + Similar to _symmetric_values, but computes the influence for each layer + separately. Returns a dictionary containing the influence for each layer, + with the layer name as key. + """ grad = self._loss_grad(x, y) fac = self._solve_hvp_by_layer( grad, self.ekfac_representation, self.hessian_regularization @@ -1361,6 +1439,24 @@ def explore_hessian_regularization( y: torch.Tensor, regularization_values: List[float], ) -> Dict[float, Dict[str, torch.Tensor]]: + """ + Efficiently computes the influence for input x and label y for each layer of the + model, for different values of the hessian regularization parameter. This is done + by computing the gradient of the loss function for the input x and label y only once + and then solving the Hessian Vector Product for each regularization value. This is + useful for finding the optimal regularization value and for exploring + how robust the influence values are to changes in the regularization value. + + Args: + x: model input to use in the gradient computations + y: label tensor to compute gradients + regularization_values: list of regularization values to use + + Returns: + A dictionary containing with keys being the regularization values and values + being dictionaries containing the influences for each layer of the model, + with the layer name as key. + """ grad = self._loss_grad(x, y) influences_by_reg_value = {} for reg_value in regularization_values: diff --git a/tests/influence/torch/test_influence_model.py b/tests/influence/torch/test_influence_model.py index b18c30c42..15bdf6441 100644 --- a/tests/influence/torch/test_influence_model.py +++ b/tests/influence/torch/test_influence_model.py @@ -569,6 +569,14 @@ def test_influences_ekfac( x_test, y_test, x_train, y_train, mode=test_case.mode ).numpy() + ekfac_influences_by_layer = ekfac_influence.influences_by_layer( + x_test, y_test, x_train, y_train, mode=test_case.mode + ) + + accumulated_inf_by_layer = np.zeros_like(ekfac_influence_values) + for layer, infl in ekfac_influences_by_layer.items(): + accumulated_inf_by_layer += infl.detach().numpy() + ekfac_self_influence = ekfac_influence.influences( x_train, y_train, mode=test_case.mode ).numpy() @@ -580,5 +588,6 @@ def test_influences_ekfac( ).numpy() assert np.allclose(ekfac_influence_values, influence_from_factors) + assert np.allclose(ekfac_influence_values, accumulated_inf_by_layer) check_influence_correlations(direct_influences, ekfac_influence_values) check_influence_correlations(direct_sym_influences, ekfac_self_influence) From 8842010cca89c2214df6c207d24bacc2a156bcae Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Thu, 4 Jan 2024 11:04:59 +0100 Subject: [PATCH 33/87] rewording notebook --- notebooks/influence_sentiment_analysis.ipynb | 96 +++++++++----------- 1 file changed, 45 insertions(+), 51 deletions(-) diff --git a/notebooks/influence_sentiment_analysis.ipynb b/notebooks/influence_sentiment_analysis.ipynb index c3a97df98..a4d47d0da 100644 --- a/notebooks/influence_sentiment_analysis.ipynb +++ b/notebooks/influence_sentiment_analysis.ipynb @@ -11,19 +11,19 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "This notebooks showcases the use of influence functions for large language models. In particular, we will focus on sentiment analysis using the [IMDB dataset](https://ai.stanford.edu/~amaas/data/sentiment/) and a [BERT](https://arxiv.org/abs/1810.04805) model fine-tuned on it.\n", + "This notebooks showcases the use of influence functions for large language models. In particular, it focuses on sentiment analysis using the [IMDB dataset](https://ai.stanford.edu/~amaas/data/sentiment/) and a fine-tuned [BERT](https://arxiv.org/abs/1810.04805) model.\n", "\n", "Not all the methods for influence function calculation can scale to large models and datasets. In this notebook we will use the [Kronecker-Factored Approximate Curvature](https://arxiv.org/abs/1503.05671) method, which is the only one that can scale to current state-of-the-art language models.\n", "\n", "The notebook is structured as follows:\n", - "- [Setup](#Setup) imports the required libraries and download the dataset and the model.\n", - "- [Sentiment analysis](#Sentiment-analysis) loads the model and the dataset and we analyse a few examples of sentiment analysis on some sentences. This serves to understand the model and the problem we are dealing with.\n", - "- [Model and data preparation](#Model-and-data-preparation) prepares the model and the dataset for the influence function calculation. In particular, here we assign all the linear layers to require gradients and wrap the model to return only the logits (and not the loss or attention masks).\n", + "- [Setup](#Setup) imports the required libraries and downloads the dataset and the model.\n", + "- [Sentiment analysis](#Sentiment-analysis) loads the model and the dataset and goes through a few examples of sentiment analysis.\n", + "- [Model and data preparation](#Model-and-data-preparation) prepares the model and the dataset for influence function calculation. In particular, it assigns all the linear layers to require gradients and wraps the model so that only logits are returned (and not the loss or attention masks).\n", "- [Influence function computation](#Influence-function-computation): shows how to calculate the influence function for a few test and train examples.\n", - "- [Analysis of influence values](#Analysis-of-influence-values): here we analyse the influence values to understand how the model works and how it is affected by corruption in the training data. Here we also corrupt some of the training examples to see how the influence function changes.\n", - "- [Influence functions by layer](#Influence-functions-by-layer): since ekfac is based on a block diagonal approximation of the Fisher information matrix, we can compute the influence function separately for each layer of the neural network. In this section we show how to do that and how to analyse the results.\n", + "- [Analysis of influence values](#Analysis-of-influence-values): analyses the influence values, trying to extract general information about the model and how it is affected by corruption in the training data.\n", + "- [Influence functions by layer](#Influence-functions-by-layer): since ekfac is based on a block diagonal approximation of the Fisher information matrix, we can compute the influence function separately for each layer of the neural network. This section shows how to do that and how to analyse the results.\n", "\n", - "Finally, in the [Appendix](#Appendix) we show how to select the Hessian regularization parameter to obtain the best possible influence function approximation." + "Finally, the [Appendix](#Appendix) shows how to select the Hessian regularization parameter to obtain the best influence function approximation." ] }, { @@ -140,7 +140,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Sentiment analysis is the task of classifying a sentence as having a positive or negative sentiment. For example, the sentence \"I love this movie\" has a positive sentiment, while \"I hate this movie\" has a negative sentiment. In this notebook we will use the IMDB dataset, which contains 50,000 movie reviews, each labelled as positive or negative. The dataset is split into 25,000 reviews for training and 25,000 reviews for testing. The dataset is balanced, meaning that there are the same number of positive and negative reviews in the training and test set." + "Sentiment analysis is the task of classifying a sentence as having a positive or negative sentiment. For example, the sentence \"I love this movie\" has a positive sentiment, while \"I hate this movie\" has a negative sentiment. In this notebook we will use the IMDB dataset, which contains 50,000 movie reviews with corresponding labels. The dataset is split into 25,000 reviews for training and 25,000 reviews for testing. The dataset is balanced, meaning that there are the same number of positive and negative reviews in the training and test set." ] }, { @@ -153,7 +153,7 @@ "output_type": "stream", "text": [ "Found cached dataset imdb (/Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0)\n", - "100%|██████████| 3/3 [00:00<00:00, 310.53it/s]\n" + "100%|██████████| 3/3 [00:00<00:00, 136.16it/s]\n" ] } ], @@ -226,7 +226,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The model we will use is a BERT model fine-tuned on the IMDB dataset. BERT is a large language model that has been pre-trained on a large corpus of text. The model was fine-tuned on the IMDB dataset using by AssemblyAI and is available on the HuggingFace model hub. We will also load its tokenizer, which is used to convert sentences into tokens that can be fed to the model." + "The model is a BERT model fine-tuned on the IMDB dataset. BERT is a large language model that has been pre-trained on a large corpus of text. The model was fine-tuned on the IMDB dataset by AssemblyAI and is available on the HuggingFace model hub. We also load its tokenizer, which is used to convert sentences into numeric tokens." ] }, { @@ -245,7 +245,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Even if the model is trained on movie reviews, it can be used to classify any sentence as positive or negative. Let's try it on a simple example created by us." + "Even if the model is trained on movie reviews, it can be used to classify any sentence as positive or negative. Let's try it on a simple sentence created by us." ] }, { @@ -309,7 +309,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "For calculating probabilities, and for the influence function calculation, we only need the logits. We then use the softmax function to convert the logits into probabilities." + "For calculating probabilities and for the influence functions we only need the logits. Then the softmax function converts the logits into probabilities." ] }, { @@ -331,7 +331,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "model_predictions thus contains the probabilities for each class. In this case, the model is quite confident that the sentence has a positive sentiment, which is correct." + "The model is quite confident that the sentence has a positive sentiment, which is correct." ] }, { @@ -420,13 +420,6 @@ "print(f\"F1 Score: {round(f1_score_value, 3)}\")" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "F1 score is quite good, but not perfect. Anyway, it is good enough for our purposes." - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -529,7 +522,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Importantly, we will need to assign all the linear layers to require gradients, so that we can compute the influence function with respect to them. Keep in mind that the current implementation of Ekfac only supports linear layers, so if any other type of layer in the model requires gradients, the influence function calculation will return a `NotImplementedError`." + "Importantly, we will need to assign all the linear layers to require gradients, so that we can compute the influence function with respect to them. Keep in mind that the current implementation of Ekfac only supports linear layers, so if any other type of layer in the model requires gradients the initialisation of the influence function class will fail." ] }, { @@ -557,7 +550,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Nevertheless, linear layers constitute a large fraction of the parameters of the model, so our analysis still holds a lot of information about the full model." + "Albeit restrictive, linear layers constitute a large fraction of the parameters of most large language models, and so our analysis still holds a lot of information about the full neural network." ] }, { @@ -605,7 +598,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We are now ready to compute the influence function for a few test and train examples. Let's start by selecting a subset of the full training and testing dataset and wrapping them in a `DataLoader` object, so that we can easily batch the examples." + "We are now ready to compute the influence function for a few testing and training examples. Let's start by selecting a subset of the full training and testing dataset and wrapping them in a `DataLoader` object, so that we can easily do batching." ] }, { @@ -654,7 +647,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "For influence computation, we will need to take the model in evaluation mode, so that no dropout or batch normalization is applied. Then, we can fit the Ekfac representation." + "For influence computation we need to take the model in evaluation mode, so that no dropout or batch normalization is applied. Then, we can fit the Ekfac representation." ] }, { @@ -673,7 +666,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "K-FAC blocks - batch progress: 100%|██████████| 15/15 [01:49<00:00, 7.28s/it]\n" + "K-FAC blocks - batch progress: 100%|██████████| 15/15 [01:59<00:00, 7.98s/it]\n" ] } ], @@ -692,9 +685,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "And the approximate Hessian is thus obtained. Considering that the model has almost 30 million parameters requiring gradients, this was very fast! Of course, we should keep in mind that this Hessian is computed using only a very small fraction (~0.4%) of the training data, and for a better approximation we should use a larger subset.\n", + "And the approximate Hessian is thus obtained. Considering that the model has almost 30 million parameters requiring gradients, this was very fast! Of course, this Hessian is computed using only a very small fraction (~0.4%) of the training data, and for a better approximation we should use a larger subset.\n", "\n", - "Before continuing, we need to set the Hessian regularization parameter to an appropriate value. A way to decide which value is better can be found in the [Appendix](#Appendix). Here, we will just set it to 1e-5." + "Before continuing, we need to set the Hessian regularization parameter to an appropriate value. A way to decide which is better can be found in the [Appendix](#Appendix). Here, we will just set it to 1e-5." ] }, { @@ -710,7 +703,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We will calculate the influence of the first batch of training data over the first batch of test data. This because influence functions are very expensive to compute, and to keep the computation time reasonable we will only compute the influence of a few examples." + "We calculate the influence of the first batch of training data over the first batch of test data. This because influence functions are very expensive to compute, and so to keep the runtime of this notebook within a few minutes we need to restrict ourselves a small number of examples." ] }, { @@ -764,7 +757,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now that we have calculated the influences for a few examples, let's analyse some of the extreme values to hopefully understand how the model works and how it is affected by corruption in the training data." + "Now that we have calculated the influences for a few examples, let's analyse some of the extreme values." ] }, { @@ -778,7 +771,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let's plot the influence values as a heatmat to see if there are any patterns." + "Let's plot the influence values as a heatmap for easily spotting patterns." ] }, { @@ -792,7 +785,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABEkAAALGCAYAAAC50896AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABmV0lEQVR4nO3dd5hsVZX38e/vooBKMgEqY86og1kcAwbMijk7oo5ZR18dAzoKqCNmUcEcgDGLCSOKigkGEypBVBQQRKKSJMnt9f6xT0tRdN/bVd19qsP38zznqVv7hL0r9e1avfbaqSokSZIkSZJWuzWTHoAkSZIkSdJSYJBEkiRJkiQJgySSJEmSJEmAQRJJkiRJkiTAIIkkSZIkSRJgkESSJEmSJAkwSCJJkiRJkgQYJJEkSZIkSQIMkkiSJEmSJAEGSSTNIMlmSd6d5PgklySpJNsl2aH7926THuNKk+R+SQ5Jclb3HH9p0mMaluTgJLUA19mte4w7zH9UWiy+TlpJuvfywZMehyRp6TNIIq0Q3S+A8/4C23kL8ELgCGAPYHfglAW6toYkuT7wZeAGwEdpz/en13POzt1rvvOiD1BaxSYZLOoC1cf33a8kSavZFSY9AElL0kOA31XVQwcbk9x8QuNZ6e4LbAy8tKo+OenBrMO/A1degOvsRQsC/WkBriVJkiQtGIMkkmZybeAHkx7EKnLt7vbkiY5iPapqQYIaVXUGcMZCXEuSJElaSE63kVawJNfv0sT36f796SRnJLkwyc+SPGTo+OmaEwHuOT2FZ33zuNeVEr6uVPUkN+/GdmKSi5OcmuSTSW42w7H7dNe5fpJnJzmiexynJvlgks1n6X+brr7K75NckOSvSX6S5DWzHLtXkj8muSjJmUkOSHLHdT3+Wfp9bJIfJDm76/eIJLsk2WjgmB2653v3rul7A8/55Z6vgfMOBj7W3f3YwDnVTd25zPOe5IlJDkty3uDr1E3Z+Xz3eC9Ick6SHyd58mz9Dk/pGqxT09Wt+VpXV+X8JN9PctcZrjPje2L6vZbkGt1r+pfudTgqydNmGdNG3fWmX7Pjkryhax+5BkGSOyfZP8kp3XvyxCQfSHLtoeO+1F3/P2e4xuu7fR8ZaNswyQuSfD3JCd1Y/5rkoCQPnGUsx3fbJkne2Y3lgiS/TPLw7pgrJHl19/6+MMkfkrxghmsNvk7bd/2eneTcJAcmucOIz9Mon92tkrwtyW+T/L17f/y2O/+GI/R5++79elr3/J2Q5L1JrjXDsWP9vJjhOscDu3Z3Bz+fw5+DK6d9vn/ZPcbzkhya5AkzXDNJnppWg+j0blwndq/D47pjpn82XA+4Xi77Gd9njmOf05i69/zF3Wdo86F91+qes/MykEnYvRbvSvKr7n18YfcefHuSq84wln9OD0yyY5Ifdtc8PcnHkmzRHXfbJF9N8rdu/wHpfqYNXe/g7nobpX3ej+veE39IsmuSDefyHHXXukKS5yX5v7SfgecnOTzt83q535OTPCzJd3Lpz6eT037WPW+ufUqSljYzSaTV4XrAT4A/Av8LXA14HPDlJPetqu91x+0DHEz7UnBCdx/g+IUeUJIHAF8Argh8BTgW2AZ4JPDgJPeqql/McOpbgPt353wLuBfwTODGwL2H+rgDcCDt8f6g6+/KwC2B3YDXDxx7u+56V+vO+QJwDeDhwI+SPKKqvj7Hx/ZGYBdatsQngfOABwJvBO6f5H5VdTHted0d2AG4J7Avlz7XxzO7fYCzgJ1otUx+ObDvrKFjXwrsSHu+vgcMfgl6H3AU7bn5C3B14EHA/ya5WVVdLpC0DncAXg4cCnwYuC7wKOA7Sbarqt/O8TpbAD8GLgb2BzYCHgN8NMlUVe07fWCSAJ8HHgz8njaN54rAzsC2I4x9+npPBz4IXAQcAJwI3AT4D+ChSe4ykE3zdOBw4C1JflhVh3fXuA/wKuBoWl2faVcD3gUcAnwbOB24FvBQ4OtJnllVH55hWFfsjr8a7bXeEHgC8Pkk9wOeB9wZ+EY37scA70lyelV9Zobr3Zn23jwI2Jv2uXkkcI/uffnDOTxPc/7sJrky7fW8Ufc4vkILwl6P9v7dn/ZzaX19PoT2Wqc75wTg9sBzgZ2S3K2qjpvh1Dn/vJjFnrSfAcOfz8GxbQF8F7gt8AtaXaE1Xb+fTLJtVf33wCn/Q3sNjgM+C5xNey/ckfb6fYZLfza8eGAc0365vkGPMqaqOizJq4C3Ah8CHttdYw3wCWBLYOeqOmagi2cCjwC+T3svraG9Hi8BHpjkzlV17gxDexhtOudXgfcDd6V9Xq+fZBfgO8APgY8At6Z9Pm6Y5DZVNTXD9T5Le972B/5Be0/tBtwhycOqap11upJMv4fvD/yW9vP6Qtr75D20z8tTBo5/FvABWo2ur9B+xm8J3AZ4GvDedfUnSVomqsrNzW0FbEC1j/Rl2q4/3Q7sOrTv/l3712e51sEztO/Q7dttqP144PhZxrVbd84OA21XBf5G+wXzlkPH34oWVPjFUPs+3XX+BFx3oP0KtC/5BdxpoH1D2peQAp44w7i2GbrGsbRfju85dNy1gT/TgggbzeF12H5gnFsP9fGVbt+r1vcczaGfnbtzdl7P8/534LazHHOjGdo2pH1R+QdwnaF9B8/wHpt+T1xuLMCzu/b3zuXxDlznw8AGA+23BC4Bjh46/ind8T8ANhxo3wI4Zrb38SzPxU1pgZljZ3jc9wHWAl8car9r9zz9DtgE2Kp7n5wPbDt07EaD77mB9s2BI4G/Alea4XNV3ftmo4H2u3ftfwV+CmwxsO+G3eM4fB2v0wuG9u3Utf8eWLOQn13al9wC3jnLe23TObw2mwBndq/B3Yf2vaK7/reG2vdhhJ8X6+l/xvfrDH29fKh9Y+CbwBSw3UD7mcBJwJVnuNY1ZngPHD+Xcc5zTAG+1p3z7K5t1+7+vjNc/3oMfEYH2p/RnfOKofadu/ZLGPgZSwuufHvg/fykofM+0u3baaj94K79d8BVhx7fod2+pwydc7mfBwOv7Xu47M+cDWbqG/g5LRi55fpeOzc3Nze35bs53UZaHU4A3jDYUFUH0r5A3GkC4/l32hfZXavq6KFxHUn7a+Ztk9xyhnNfVwO1MarqEi6dejL4WB5KCxIdUDMUQ62qkwbuPpj2l+73VNX3h447mfbX6K1pX5bX5+nd7Ruq6p8rAnXjfCnty8l/zOE6C+WD1WU5DKuqP8zQdjEtw+AKzO3xTvtxVe0z1PZR2peiUd5j5wMvqaq1A2M6mpaNcIskmwwc+9Tu9r+7cU8ffxYDWUJz9FxaZsSLqurPgzuq6ju0zJKHJtl0oP0Q4DW0bJMP0LK0tgb+s6qOGrrGRUPvuen2s2nP01VpfxGfyYur6qKBc35ICwBelfZl9KyBfX+kPVe3SrLBDNc6lqG/dlfVl2kZATemBWDWZdzP7gXDF6qqi2vmbINhO9EyaT5Tl890eTstkLBjkuvOcO5cf16MJcnVgScDP6uqtwzuq6oLaUGcAE8cOvUftKAPQ+fMu1bPOGOqqqJ9nv4M7Jnk+bT39m9p2UrD4zxh8DM64KPAObQg/Ew+Nfgztlp2yP92d4+sqk8MHb9fd7vdLNd7fVX9bejx7dLdffrMpzRdpswLaVkh/2/oZ85a2s/rAp40dOoltNfvMhbitZMkLQ1Ot5FWh1/O8gvtibTMh75N9/mvSXabYf9Nu9tb0KYtDPrZDMef2N0OzoW/S3f7jRHGc71ZxnOTgfGsb8rN7brb7w7vqKrfJTkJuEGSzbsvyIvtJ7Pt6L5UvoIWDLkucKWhQ64zQj+Xe12q6h9JTuWyr8v6/L6qzpmhffA1Pq/7921pQadDZjj+RyP0CZe+B+6ZmWvQbEn76/JNaX9NnvZmWmr+9BfOT9XM02ZIsi3wMuAetOkVGw8dMtPzfdZMwSxakd8bDI1l2p9p/79v3f170A9r5mkLB9OmlNyWFjCZzaif3e93Y3hlN6Xt67Qgzmw/k2ayrs/UJUl+QAuI3pbLr5g0158X47oj7X1RszwfV+xubzHQ9gnal/Ojk3yW9hwduoA/D8YZE1V1RpIn0p7nvWiZdY+rqr8PX6CbpvJs4PG0TK/NuWydu9l+dsz0ekwXrJ7tvQxtOtdMZnqv/ogWgLrtLOdMuykt+PZ74L/b7L3LuYDLv3Zvp712n+76/3FVnb6eviRJy4hBEml1OGuW9kuYTAHnq3e3z1zPcZvM0HbWDG2XdLeDfznforsd/pK4rvE8ZozxDNu8u/3LLPv/QgtIbEGrRbDYTpmpMa1g5k9oXxR/SKvXcDbty8X1aX9V3mimc2dx1iztl3DZ12U+12HoWpsDf+2yA4adOkKfcOl74GXrOe4y74GqqiRfAO7XNe0500lJ7kL78nkF2nSmA2h/cZ+i/ZV8J2Z+vmd7j1zS9T/T/unn44oz7JvteZl+n2w+y/5pI312q+qc7rHvTqtHMZ1hcEaS99Iyri73V/khc/lMwaWf+UFnzdA203tpXNPPxx2ZPRMILvu++X+0OixPA17ZbZck+TptGfBjJzCmaT+hBZpuAHyvqn41y7mfodUk+SOtVs4ptGko0OqozPazY13v11HfyzDD+7kLnE3XClmX6efpJlxanHcm/3yequod3bWfB/wn7bFWku8DL6uqmYJAkqRlxiCJpIUwRasvMJMtZmib/mX4X6vq14syoku/HM0lG2J6PDtV1QHz7Hf6WlsDM2UAXGvouMVWs7S/hPYl4WnD02TSVr946kwnLTHnAFdLcoUZAiVbjXit6ddj81kyWWaU5CbA22h1OjYHPpzkTl3a/6D/pmXq3KuqDh66xi60IEkfZntetu5u1/e+HPmz200zekZXaPeWtIKpzwdeSwvSrq9A8OBnaiZ9f6YGTff5zqp6yVxO6DJo9qRNa9kSuBstI+MxwLZdUdWL1nGJBR/TgHfRAiRn0AqwPml4CkxXEPsRtIKtDxz87HVTWF4+9shHtxVD2UNJrkArur2+z/H08/TFqnrkXDusqv2A/briuHelPRdPBw5McnOzSiRp+bMmiaSF8Ddgqy4Fe9hMS4v+X3e7vvoH8zHdx4zLq85y7EKMZ7r+xw7DO5LcmJY2ftxgHYkxTU9VGPev4Tfubj8/w757jnnNvh1O+3/scssM0754jmLk90Dacs6fAa5CWy1qD9qKHHvOcPiNaVkvB8+wr8/n+24zLWvKpe/XGevXDBj7s1LNUVX1HtqKS9BWjlmfdX2mrjAwlplWw1oI6/qs/YQWJB7rZ0dVnVZVX6iqx9IyjW5EK4A72Peon/GxxpTkscCzaIVtb0dbgen9XSBw0PTPjgNmCE7eictP21tMM3127kZ7ztb3Xj6GFky/yyz/d61TVZ1VVV+vqmfSCuVejTaVTpK0zBkkkbQQfkLLTHvaYGOSnYF/m+H4j9F+Od01yeWKJyZZk2SHeY7pK7SCjg/rMiOG+xic4/5lWtbH85M8aKaLJdm+W850fT7a3f53kmsOnL8BLeNgDW3VhPk6s7udqVjlXBzf3e4w2Jjk/vRbWHY+pos6viHJPzOZkmzO+rMThu1FK8b4ziQ3Hd6ZZMMkw18630are/CWqvo2LWX/x8CzkwxP3TqelvVym6HrPoPZi1wuhpswVIgzyU60L5vH0qZerctIn90k2yaZKXtluu38OYz5S7SVT57QTd0Z9GJa5sNBgwVaF9isn7WqOo1Wp+IOSV4zU7HcJDdKcoPu3xsludzPxO5L+tW6u4PPyZnANZPMOfAw6pi6+zekFd09k7Ya2Im0bLKrAJ/pAoLTju9udxi65pa0os99ek2Sf9aWSbIxLVgJlxbonVEX4HkPLRPp3TM9x0muNViEOMm9MnPxkumpPXN5P0uSljin20haCO+hBUjel+Q+tMKI29GKPH4VeMjgwVV1ZpJHA18E/i/Jd4CjaFND/qU77+pcvrDlnFXVxd0X1W8Bn0zybNpfwTemFeK7D93PwK7A6COBA4GvJTkE+CXtF95/oc3rvyHtl+l1/hJcVYckeQst5fzIJPvTluF9IO0vxD8C3jru4xpwaDeWF3erWUzXlHjPHAtAvpf2mn2uG+PJ3fgeAHyWlhmx1O1Hm6bwANpzfQCtdsGjaEvj3oz2F/X1qqpjkjydFuQ6Ksk3acuLXpH25fjutL+s3xwgySOAFwCH0abSUFVru4DcL2nTbn7erTYDLbvk/sCPumKdZ9OyrO4G7A88euxnYTTfBN6e5IHAr2hZAY+kFel8+ixFXf9pjM/ujsBbkxxKez5Po2VT7UR7bdb7Waiq87rX5nPA95N8jjbF4va0WjCn0IqILpbvdWPdI8mtaJlzVNX0imEvoAWfXgc8JcmPaLUyrk37WXNH4Am0FYmuRHsPHEsrVHoC7bnasTv2gKr6zUDf3+nO/2ZXoPYi4FdV9ZX1jHnOY+oCNJ8GNgMeNr26U1V9I8nbgf+iBQRf2F37p7Rg4CO7n5U/ogW9HkhbDWe6EGsffkP7vO5PC3LuRMvG+RqXrpqzLq8H/hV4Dm31qu/S6lhtSXv+/g14NZcWEP8icF6S/6MFi0L72XBH2ut50II8KknSRBkkkTRvVXV0kvsCb6QtvXsJ7S/S29O+gD1khnO+0/1V/b9oXx7vDlxM+wX7u8w8DWTUcf0syXa0wogPpE3LOJf2F/PXDh376yT/SqvV8RBaAGGKVhTycFqWwJyWeKyqVyQ5nPZF5d9pX7T/QPsy/fYaWK52Ho/tb0ke1Y1rZ9pffAE+zhxqM3SP9160paEfTPv/4Fe01+sslkGQpCua+gjgVcBTaF/i/gLsSwsCPZz11yUYvN7Hk/yKtvTnvWhfwP9Oe0/uT5taM70q0Edoz/PjB6ccVNWJ3Rf6LwGfTnK3bqnbbyZ5KO098DjaNIqfdP3ckP6CJIfRvji/nvb+DO3z9uqq+ulcLjDiZ/dAWpDpHrQvsJvRXqNvA++otozyXPr8cpeB8aquz81pwZH305aBXbQv5lX1myRPpT3e53FpAOgN3f5zktyTNlXlibQg3ca0oMTvaYVav92d83failL3ov08ejjtZ9IfaMtQT2eiTXsDra7TQ2lf2Degvb/XGSQZcUxvon3Jf/cMwZdX0V67FyT5blV9sQsGPqwb24NoBUz/DHy4axtekWwxPZaWNfYkWgDoz8BuwJuqarZ6TP/UBcgfTlsyeWfaz/5NaAHR47prD9ZkeSXt/Xc72mO/kBboegXwvjkUIZYkLQOZw/8hkiQtK0l2pGURvamqdpn0eCatmwLzPWD3qtptooOR5inJwcA9q2rGdXslSZoPa5JIkpatJNeeoe3qtL+OQ0uPlyRJkubE6TaSpOXsHd00qUNoKfLb0KZWXQ34QFX9ZJKDkyRJ0vJikESStJx9gVY08qG02g0X0gqJfoSFWUVIkiRJq4jTbSRJy1ZVfbaq7lVVW1bVhlW1WVVtX1UfnkvhxtWiqg6uqliPRCtBVe1gPRJJWr8k90jylSQnJ6muWPXg/iR5XZK/JLkgyUFJbjJ0zNWSfCLJOUnOSvKRJJsMHXObJD9McmGSE5O8vIeHt2gMkkiSJEmStPJchbZ64fNn2f9y2iplzwHuTFuF7cAkGw8c8wlgW9py9Q+hrXr2wemdSTajFcs/Abg98DJgtyTPWtBH0iNXt5EkSZIkaQVLUsAjqupL3f0AJwNvr6q3dW2b05aL37mqPp3kFrSl3e9YVT/rjnkA8HVgm6o6Oclzgf8Btq6qi7tj3gQ8vKpu3uuDXCArqiZJ90JfGzh30mORJEmSpBVuU+Dk1TbFtcu02HDS4+hcVFUXjXHeDYCtgYOmG6rq7CSHAdsDn+5uz5oOkHQOAqZomSdf7I75wXSApHMg8IokV62qv40xtolaUUESWoDkpEkPQpIkSZJWiW2AP096EH1JsvHWW25wwSmnrZ1E9+cBmwy17Q7sNsa1tu5uTx1qP3Vg39bAaYM7q+qSJH8dOua4Ga4xvc8gyYSdC3Cd17+aNRtvvL5jtdxNWbNtNfHVXj02/62v9mpx9s1W1R8eVzdf6tXFH+OrwtSFF3LSrm+A1ZfFv+Epp63lhJ9fn8027a/E5znnTnG92x+/CS0oNficj5NFonVYaUESANZsvDFrrmSQZMUzSLKqxF+wV40NNvSzvVqs2dgP9qrhS726+GNcq8Amm4ZNNu3vzT516Qfr3Ko6ZwEueUp3uxXwl4H2rYBfDhyz5eBJSa4AXG3g/FO6cwZtNbBv2XF1G0mSJEmSVpfjaEGM+0w3dCvV3Bk4tGs6FNgiye0Hzrs3LY5w2MAx90hyxYFjdgR+uxzrkYBBEkmSJEmSVpwkmyTZLsl2XdMNuvvX7Yrt7gn8d5KHJbk1sB9txZsvAVTVb4BvAh9Kcqck/wbsBXy6qk7urvlJ4GLgI0m2TfI44EXAO/p5lAtvRU63kSRJkiRpsaytKdb2OJVwbU2Nc9odgO8N3J8OXOwL7Ay8BbgK8EFgC+BHwAOq6sKBc55EC4x8h7aqzeeB/5ze2a2Icz9gb+DnwBnA66rqg+MMeCkwSCJJkiRJ0gpTVQezjipBXTbJa7tttmP+CjxxPf38Grj7eKNcegySSJIkSZI0gimKqR6rUvfZ12pnTRJJkiRJkiTMJJEkSZIkaSRTTDFWlZB59Kd+mEkiSZIkSZKEQRJJkiRJkiTA6TaSJEmSJI1kbRVrq79iqn32tdqZSSJJkiRJkoSZJJIkSZIkjcQlgFcuM0kkSZIkSZIwSCJJkiRJkgQ43UaSJEmSpJFMUax1us2KZCaJJEmSJEkSZpJIkiRJkjQSC7euXGaSSJIkSZIkYSaJJEmSJEkjWVvF2uovu6PPvlY7M0kkSZIkSZIwSCJJkiRJkgQ43UaSJEmSpJFMdVuf/akfZpJIkiRJkiRhJokkSZIkSSNZS7G2x2V5++xrtTOTRJIkSZIkCYMkkiRJkiRJgNNtJEmSJEkaydpqW5/9qR9mkkiSJEmSJGEmiSRJkiRJI3EJ4JXLTBJJkiRJkiTMJJEkSZIkaSRThLWk1/7UDzNJJEmSJEmSMEgiSZIkSZIEON1GkiRJkqSRTFXb+uxP/TCTRJIkSZIkCTNJJEmSJEkaydqeC7f22ddqZyaJJEmSJEkSBkkkSZIkSZIAp9tIkiRJkjQSp9usXGaSSJIkSZIkYSaJJEmSJEkjmaowVf1ld/TZ12pnJokkSZIkSRJmkkiSJEmSNBJrkqxcZpJIkiRJkiRhkESSJEmSJAlwuo0kSZIkSSNZyxrW9phzsLa3nmQmiSRJkiRJEmaSSJIkSZI0kup5CeByCeDemEkiSZIkSZKEQRJJkiRJkiTA6TaSJEmSJI1kLWEt/U2B6bOv1c5MEkmSJEmSJMwkkSRJkiRpJGtrDWurxyWAq7euVj0zSSRJkiRJkliiQZIkz09yfJILkxyW5E6THpMkSZIkSQBThCnW9LhZk6QvSy5IkuRxwDuA3YHbAb8CDkyy5UQHJkmSJEmSVrQlFyQBXgJ8qKo+VlVHA88BzgeePtlhSZIkSZKklWxJFW5NsiFwe2CP6baqmkpyELD9DMdvBGw00LTpog9SkiRJkrSquQTwyrXUMkmuAWwAnDrUfiqw9QzH7wKcPbCdtKijkyRJkiRJK9aSyiQZwx60+iXTNsVAiSRJkiRpEfW/BLBrAPdlqQVJzgDWAlsNtW8FnDJ8cFVdBFw0fT8xBUmSJEmSJI1nSU23qaqLgZ8D95luS7Kmu3/opMYlSZIkSZJWvqWWSQJt+sy+SX4G/AR4MXAV4GOTHJQkSZIkSQBThKkei6n22ddqt+SCJFX1mSTXBF5HK9b6S+ABVTVczFWSJEmSJGnBLLkgCUBV7QXsNelxSJIkSZI0bIo1rO2xesUUFm7ty5KqSSJJkiRJkjQpBkkkSZIkSZJYotNtJEmSJElaqtbWGtZWfzkHa8vpNn0xk0SSJEmSJAkzSSRJkiRJGskUa5iycOuKZCaJJEmSJEkrSJLjk9QM297d/oNn2Pf+oWtcN8nXkpyf5LQkb02y4hMtVvwDlCRJkiRpIa2tsLbSa38juiOwwcD9WwHfBj430PYh4LUD98+f/keSDYCvAacAdwWuBewH/AN41aiDWU4MkkiSJEmStIJU1emD95O8EvgD8P2B5vOr6pRZLnE/4JbAfavqVOCXSV4DvDnJblV18WKMeylwuo0kSZIkScvDpkk2G9g2Wt8JSTYEngx8tOoyy+Q8KckZSY5MskeSKw/s2x44oguQTDsQ2AzYdiEeyFJlJokkSZIkSSNYyxrW9phzsPbSwq0nDe3aHdhtPac/HNgC2Geg7ZPACcDJwG2ANwM3Ax7Z7d8aGAyQMHB/67mMebkySCJJkiRJ0vKwDXDuwP2L5nDOM4BvVNXJ0w1V9cGB/Uck+QvwnSQ3qqo/LMxQlyeDJJIkSZIkjWCq1jBVPS4BfOksmXOr6py5npfkesB9uTRDZDaHdbc3ptUuOQW409AxW3W3s9UxWRGsSSJJkiRJ0sr0NOA02ko167Jdd/uX7vZQ4NZJthw4ZkfgHODohRzgUmMmiSRJkiRJK0ySNbQgyb5VdclA+42AJwJfB86k1SR5J/CDqvp1d9i3aMGQ/03yclodkjcAe1fVXKb4LFsGSSRJkiRJGsEEC7eO4r7AdYGPDrVf3O17MXAV4ETg87QgCABVtTbJQ4D30bJK/g7sC7x2nIEsJwZJJEmSJElaYarqW0BmaD8RuOcczj8BeNAiDG1JM0giSZIkSdIIpoC1dbn4w6L2p35YuFWSJEmSJAkzSSRJkiRJGskUa5jqMeegz75WO59pSZIkSZIkDJJIkiRJkiQBTreRJEmSJGkka2sNa6vHJYB77Gu185mWJEmSJEnCTBJJkiRJkkYyRZiizyWA++trtTOTRJIkSZIkCYMkkiRJkiRJgNNtJEmSJEkaiYVbVy6faUmSJEmSJMwkkSRJkiRpJGtZw9oecw767Gu185mWJEmSJEnCTBJJkiRJkkYyVWGqelwCuMe+VjszSSRJkiRJkjBIIkmSJEmSBDjdRpIkSZKkkUz1XLh1yvyG3vhMS5IkSZIkYSaJJEmSJEkjmao1TFWPmSQ99rXa+UxLkiRJkiRhkESSJEmSJAlwuo0kSZIkSSNZS1hLeu1P/TCTRJIkSZIkCTNJJEmSJEkaiYVbVy6faUmSJEmSJMwkkSRJkiRpJGvpt07I2t56kpkkkiRJkiRJGCSRJEmSJEkCnG4jSZIkSdJILNy6cvlMS5IkSZIkYSaJJEmSJEkjWVtrWNtjdkeffa12PtOSJEmSJEkYJJEkSZIkSQKcbiNJkiRJ0kiKMEV67U/9MJNEkiRJkiQJM0kkSZIkSRqJhVtXLp9pSZIkSZIkzCSRJEmSJGkkUxWmqr86IX32tdqtyCDJRmdswAYbbTDpYWiRXbzF1KSHoD5N+R/DavHVV7910kNQT+7xqZdNegjqySVX/8ekh6AerTl3RX7F0LCa9ACkxeF0G0mSJEmSJFZoJokkSZIkSYtlLWtY22POQZ99rXY+05IkSZIkSZhJIkmSJEnSSCzcunKZSSJJkiRJkoRBEkmSJEmSJMDpNpIkSZIkjWSKNUz1mHPQZ1+rnc+0JEmSJEkSZpJIkiRJkjSStRXW9lhMtc++VjszSSRJkiRJkjCTRJIkSZKkkbgE8MplJokkSZIkSRIGSSRJkiRJkgCn20iSJEmSNJKqNUxVfzkH1WNfq53PtCRJkiRJEmaSSJIkSZI0krWEtfS4BHCPfa12ZpJIkiRJkiRhkESSJEmSJAlwuo0kSZIkSSOZKpiq/qbATFVvXa16ZpJIkiRJkiRhJokkSZIkSSOZ6nkJ4D77Wu18piVJkiRJkjBIIkmSJEmSBDjdRpIkSZKkkUwRpuixcGuPfa12ZpJIkiRJkiRhJokkSZIkSSNZW2Ftj0sA99nXamcmiSRJkiRJK0iS3ZLU0HbMwP6Nk+yd5Mwk5yX5fJKthq5x3SRfS3J+ktOSvDXJik+0WPEPUJIkSZKkhbRMlgA+CrjvwP1LBv79TuDBwGOAs4G9gC8A/waQZAPga8ApwF2BawH7Af8AXjXOYJYLgySSJEmSJK08l1TVKcONSTYHngE8saq+27U9DfhNkrtU1f8B9wNuCdy3qk4FfpnkNcCbk+xWVRf39zD65XQbSZIkSZKWh02TbDawbbSOY2+S5OQkf0zyiSTX7dpvD1wROGj6wKo6BvgTsH3XtD1wRBcgmXYgsBmw7YI9miXITBJJkiRJkkYwRZjqsZjqwBLAJw3t2h3YbYZTDgN2Bn5LmyqzK/DDJLcCtgYurqqzhs45tdtHd3vqDPsZOGZFMkgiSZIkSdLysA1w7sD9i2Y6qKq+MXD310kOA04AHgtcsHjDW/4MkkiSJEmSNIIig9kdvfTXObeqzhn5/KqzkvwOuDHwbWDDJFsMZZNsRSvUSnd7p6HLbDWwb8WyJokkSZIkSStYkk2AGwF/AX5OW6XmPgP7bwZcFzi0azoUuHWSLQcusyNwDnB0H2OeFDNJJEmSJElaQZK8DfgKbYrNtWm1S9YCn6qqs5N8BHhHkr/SAh/vAQ7tVrYB+BYtGPK/SV5Oq0PyBmDvqppxis9KYZBEkiRJkqQRTFXPhVtH72sb4FPA1YHTgR8Bd6mq07v9/w+YAj4PbERbueZ50ydX1dokDwHeR8sq+TuwL/Da8R/F8mCQRJIkSZKkFaSqHr+e/RcCz++22Y45AXjQAg9tyTNIIkmSJEnSCKZqDVPVX4nPPvta7XymJUmSJEmSMJNEkiRJkqSRLIOaJBqTmSSSJEmSJEkYJJEkSZIkSQKcbiNJkiRJ0kimCFP0ON2mx75WOzNJJEmSJEmSMJNEkiRJkqSRWLh15TKTRJIkSZIkCYMkkiRJkiRJgNNtJEmSJEkaidNtVi4zSSRJkiRJkjCTRJIkSZKkkZhJsnKZSSJJkiRJkoSZJJIkSZIkjcRMkpXLTBJJkiRJkiQMkkiSJEmSJAFOt5EkSZIkaSQFTNHfFJjqrSeZSSJJkiRJkoSZJJIkSZIkjcTCrSvXksokSXKPJF9JcnKSSvLwSY9JkiRJkiStDksqSAJcBfgV8PxJD0SSJEmSJK0uS2q6TVV9A/gGQGI6kSRJkiRp6XG6zcq1pIIko0qyEbDRQNOmkxqLJEmSJEla3pZ1kATYBdh10oOQJEmSJK0eZpKsXEutJsmo9gA2H9i2mexwJEmSJEnScrWsM0mq6iLgoun71jGRJEmSJC02M0lWruWeSSJJkiRJkrQgllQmSZJNgBsPNN0gyXbAX6vqT5MZlSRJkiRJWg2WVJAEuAPwvYH77+hu9wV27n00kiRJkiQNqQrV4xSYPvta7ZZUkKSqDgZ89SVJkiRJUu+WVJBEkiRJkqSlboow1ePf9/vsa7WzcKskSZIkSRIGSSRJkiRJkgCn20iSJEmSNJKpClM9FlPts6/VzkwSSZIkSZIkzCSRJEmSJGkkLgG8cplJIkmSJEmShJkkkiRJkiSNxJokK5eZJJIkSZIkSRgkkSRJkiRJApxuI0mSJEnSSCzcunKZSSJJkiRJkoSZJJIkSZIkjaR6LtxqJkl/zCSRJEmSJEnCIIkkSZIkSRLgdBtJkiRJkkZSQFW//akfZpJIkiRJkiRhJokkSZIkSSOZIoT+iqlO9djXamcmiSRJkiRJEmaSSJIkSZI0kqr0uiyvSwD3x0wSSZIkSZIkDJJIkiRJkiQBTreRJEmSJGkkUxXS4xSYKafb9MZMEkmSJEmSJMwkkSRJkiRpJFVt67M/9cNMEkmSJEmSJAySSJIkSZIkAU63kSRJkiRpJFWheiym2mdfq52ZJJIkSZIkSZhJIkmSJEnSSMwkWbnMJJEkSZIkScIgiSRJkiRJEuB0G0mSJEmSRjJVIT1OgZlyuk1vzCSRJEmSJEnCTBJJkiRJkkZS1bY++1M/zCSRJEmSJGkFSbJLkp8mOTfJaUm+lORmQ8ccnKSGtvcPHXPdJF9Lcn53nbcmWdHJFiv6wUmSJEmStNBaJkmfSwCPfMo9gb2Bn9K+978R+FaSW1bV3weO+xDw2oH750//I8kGwNeAU4C7AtcC9gP+Abxq5BEtEwZJJEmSJElaQarqAYP3k+wMnAbcHvjBwK7zq+qUWS5zP+CWwH2r6lTgl0leA7w5yW5VdfHCj3zynG4jSZIkSdLysGmSzQa2jeZ43ubd7V+H2p+U5IwkRybZI8mVB/ZtDxzRBUimHQhsBmw73vCXPjNJJEmSJEkaQVV6nm7zz75OGtq1O7Dbus5NsgbYE/hxVR05sOuTwAnAycBtgDcDNwMe2e3fGhgMkDBwf+s5D36ZMUgiSZIkSdLysA1w7sD9i+Zwzt7ArYC7DTZW1QcH7h6R5C/Ad5LcqKr+MO+RLlMGSSRJkiRJGkF1W5/9dc6tqnPmel6SvYCHAPeoquEslGGHdbc3Bv5AK9h6p6FjtupuZ6tjsuxZk0SSJEmSpBUkzV7AI4B7V9Vxczhtu+72L93tocCtk2w5cMyOwDnA0Qs11qVm0TJJkmxQVWsX6/qSJEmSJGlGewNPBHYCzk0yXUPk7Kq6IMmNuv1fB86k1SR5J/CDqvp1d+y3aMGQ/03yclodkjcAe1fVXKb5LEtjZZIk+VSSLdax/za09ZglSZIkSVpRpgu39rmN6Lm0FW0OpmWGTG+P6/ZfDNyXFgg5Bng78HngoZc+xlpLm6qzlpZV8nFgP+C14z1ry8O4mSQPA+6R5NlV9dXpxq5q7quA/6ZVyJUkSZIkST2q9URVqupE4J5zuM4JwIMWalzLwbg1Sf4VOA74cpKPdesz35JW6OV1tOjSbRZojJIkSZIkLR01gU29GCuTpKqOTXJ34KW0oMj9gasCpwMPrKoDF26IkiRJkiRJi2/swq1VVUm+BDyZS7NGPkGb0yRJkiRJ0so0Xp2QefWnfoy9BHCSFwCHA9cAHgN8BHgF8OMkN1mY4UmSJEmSJPVj3NVtvgu8GzgAuHVVfb6qnkkr6HJd4JdJXrRww5QkSZIkSVpc42aS3Ap4TFU9qar+Nt1YVd8EtgX2B96xAOOTJEmSJGlJqep/Uz/GrUmybVWdPtOOqjobeGqS/ccfliRJkiRJUr/GXd1mxgDJ0DFfGefakiRJkiQtZdVz4dZei8SucnMKkiT593EuXlX7jXPefF28xRRrNp6aRNfqkz8nVpeYY7ha3PXrL5n0ENSTNRv6uV4t1pw39oKKkiT1aq7/Y+0zQ9v0bzbDX1UHf+OZSJBEkiRJkiRpVHMNktxg6P4WwL7A2cB7gN927TcHXghsCjx1AcYnSZIkSdLSUmlbn/2pF3MKklTVCYP3k+wGnA7cr+oydXaPSPJ54FvA/wOetkDjlCRJkiRJAiDJtYAtgWOr6u8Ldd1xlwB+OPDFoQAJAFU1BXwB2Gke45IkSZIkaUlyCeDJSbJTkmOAk4BfAHfu2q+R5PAkD5/P9ccNkoQ2tWY2t8SympIkSZIkaYEkeSgtKeMMYHcG4g5VdQbwZ+Y5o2XcIMmXgOcmeUmSK083JrlykpcCzwa+PJ+BSZIkSZK0JNUENgG8FvhBVd0N2HuG/YcCt51PB+Oux/YiWjHXtwF7JPlL134t4IrAj4EXz2dgkiRJkiRJA24FvGQd+0+l1SkZ21hBkqo6G7hnkp2ABwLX63Z9E/g68JWZ6pVIkiRJkiSN6XzgKuvYf0PgzPl0MG4mCQBV9WWcViNJkiRJWkWqQvW4LG+ffS1x3wOemmTP4R1JtgaeCXx1Ph2MW5NEkiRJkiSpT68GtgF+SquFWsD9k7wBOIJWyHX3+XQwp0ySJMcBU8DNq+of3f31TaepqrrRfAYnSZIkSdKSZIGJ3lXVb5PcDXgX8HpaUORl3e6DgedX1fHz6WOu022+T3sLTA3dlyRJkiRJ6kVVHQXcN8lVgRvTZsj8sapOX4jrzylIUlU7r+u+JEmSJElSX6rqb7RpNwtqXoVbJUmSJElabSzcOhlJ/n0ux1XVfuP2YZBEkiRJkiQtB/usY99gSRCDJJIkSZIk9aLot0qnFUGn3WCGtg2A6wPPA64LPHU+HRgkkSRJkiRJS15VnTDLrj8C303yNeAFwPPH7WPNuCdKkiRJkrQ6ZQKb5uCrwOPmcwGDJJIkSZIkaSW4EbDRfC4w1nSbJJsCW1TViQNt1wae0w3o81X1k/kMTJIkSZIkaVqSe8yyawvgHsB/Al+aTx/j1iT5IK1gyl0AkmwG/B+wDTAFvCjJA6rq4PkMTpIkSZKkJcfCrZNyMDM/GwHWAp8DXjifDsYNktwN+MDA/ScD1wbuChwFfAf4b9oDkCRJkiRJmq97zdBWwN+AE6rqnPl2MG6Q5BrAnwfuPwz4UVX9H0CS/YBd5zk2SZIkSZKWHjNJJqKqvr/YfYxbuPUsYGuAJFcC7g58a2D/JcCV5zUySZIkSZKkHo2bSXII8LwkxwAPADYGvjyw/6ZcNtNEkiRJkiRpzpIcx+h5NFVVNxq3z3GDJK+gZY58vrv/9qo6CiDJBsBjgG+OOyhJkiRJkpasStv67G91+j49TzYaK0hSVccmuRlwS+Dsqjp+YPeVgRcAv5r/8CRJkiRJ0mpUVTv33ee4mSRU1T+YIRBSVedy2ak3kiRJkiStGFVt67M/9WPsIEmSzYDn0Zbg2RJ4dlX9JMnVgJ2BA6rq2AUZpSRJkiRJEpDkisDNgc2ZYUGaqvrBuNceK0iSZBva3KB/AX7fDW6TbjB/TfJs4HrAi8YdmCRJkiRJS5JLAE9EkjXAHrSEjXWtqLvBuH2MuwTwW4FNge2AewLDVWS+BNx33EFJkiRJkiQNeRXwMuDjwL/TYhGvBJ4D/JpWEuT+8+lg3CDJ/YB3V9XRzBzT+iMty0SSJEmSJGkh7Ax8tqqey6Ur6v68qj4E3JkWn7j3fDoYN0hyJeD0dezfdMzrSpIkSZK0tE0vAdznJoBtgO92/76ou90YoKoupmWYPGU+HYwbJDkauMc69j8cOHzMa0uSJEmSJA07k0vroZ4HnAPccOiYq86ng3FXt9kT2DfJr4HPdW1rktwY2BXYHnjUfAYmSZIkSdJSlGpbn/0JaMkYdxy4/z3gxUkOpyWB/CetLsnYxgqSVNXHk1wPeAPwP13zN2lFU6aAV1XVl+YzMEmSJEmSpAEfBHZOslFVXQS8GvhBtwX4G/CE+XQwbiYJVfU/Sf6XljFyY1rU5g/AF6rqj/MZlCRJkiRJ0qCqOgA4YOD+0UluBOwArAUOqaq/zqePsYMk3YD+BLxzPteQJEmSJGlZKWZe53Ux+xNJUlWXeTaq6mzgywvVx7iFWyVJkiRJkvr05yTvSnLXxepgTpkkSaYYPXZVVTWvTBVJkiRJkpacvpfldQngad8Hng68IMmfgc8Cn62qnyxUB3MNYrwOE3wkSZIkSdKEVNUTklwJeAjwOOC5wP9LcjzwGVrA5Jfz6WNOQZKq2m0+nUiSJEmStGJYk2RiquoC4HPA55JcBXgYLWDy/4BXJPl9Vd183Otbk0SSJEmSJC07VfX3qvoU8GTgZcB5wE3mc82xgyRJrpnkbUmOTnJ+tx3dtW01n0FJkiRJkiTNJsmVkzw+yReA04B3AacCb5zPdccqrJpkW+A7wJbAYbRUF4CbAi8BnpLkPlV15HwGJ0mSJEnSkuN0m4lIsjHwYNr0mgcBVwaOB94NfKaqDp9vH+OuPrM3sAFw56r66eCOJHcCvg68B7jX/IYnSZIkSZIEwOm0wMjJwAdpgZHDFrKDcYMkdwLeOBwgAaiqnyR5F7DLvEYmSZIkSdJSZCbJpOxDC4z8aLE6GDdIchpw4Tr2X9gdI0mSJEmSNG9V9cLF7mPcwq17As9NsvXwjiTXpq1VvOf4w5IkSZIkSerXuJkka2hL6xyb5IvAsV37TYCHd/fXJHnJwDlVVe8cd6CSJEmSJC0Jlbb12Z96MW6Q5G0D/37SDPtvM3QMtFlUBkkkSZIkSdKSNG6Q5AYLOgpJkiRJkpaJVNv67E/9GCtIUlUnLPRAJEmSJEmSJmncTBJJkiRJkqTeJbkLcC9gS+C9VfX7JFcGbg78rqrOG/faYwdJkjwZeDpwQ+CqwHAlmaqqzce9viRJkiRJS1J1W5/9iSQbAp8GdqLFIAr4CvB7YAr4Fq0W6v+M28dYQZIkbwb+C/gz8DPg7HEHIEmSJEmSNAevBx4CPBf4HvDb6R1VdWGSz9ECKP0GSYBnAl8FHlFVU+N2LkmSJEmSNEdPAN5XVR9McvUZ9v8GeMx8Olgzj3O/vtABkiS7JPlpknOTnJbkS0lutpB9SJIkSZK0GiR5fpLjk1yY5LAkd5r0mOZpS+CIdexfC1x5Ph2MGyT5KnC3+XQ8i3sCewN3AXYErgh8K8lVFqEvSZIkSZJGFi5dBriXbZwxJo8D3gHsDtwO+BVwYJItF/Cp6NuJtOKss/k34Nj5dDBukOSFwPWS7JXkdkmumeRqw9uoF62qB1TVPlV1VFX9CtgZuC5w+zHHKUmSJEnSavQS4ENV9bGqOhp4DnA+bQGW5eqTwLOTbD/QVgBJngk8FthvPh2MW5Pk78AhwMtoBVNms8GY1582vTrOX2famWQjYKOBpk3n2Z8kSZIkSUvVpsll8kouqqqLhg/qVoG5PbDHdFtVTSU5CNh++Phl5H9oM09+QKs/UsA7uySNbYCv01a3Gdu4QZK9aMVb/w84jEVY3SbJGmBP4MdVdeQsh+0C7LrQfUuSJEmSNKtK2/rsrzlpaM/uwG4znHENWtLCqUPtp7Lu6SpLWlVdnOQBwJOAR9Me40bAr4H/Bv63qua1YPK4QZLHdZ3vPJ/O12Nv4Fasu/bJHrQ5VtM25fJvGkmSJEmSVoJtgHMH7l8ui2Sl64IgH++2BTdukOQftCySRZFkL9rax/eoqlmDHl1a0UUD5y3WkCRJkiRJaqrb+uyvObeqzpnDGWfQVnrZaqh9K+CUhRtYv6an1VTVr2fZf2vgpKr627h9jFu49dPAQ8ftdDZp9gIeAdy7qo5b6D4kSZIkSVrJqupi4OfAfabbupIW9wEOndS4FsA7gQ+uY/8HgLfNp4NxM0k+A7wnydeAjwJ/okWpLqOqfjHidfcGngjsBJybZOuu/eyqumDMsUqSJEmStNq8A9g3yc+AnwAvBq4CfGySg5qnewPvW8f+r9BW8RnbuEGSH3a32wEPmGF/aAlBo65uM71SzsFD7U8D9hnxWpIkSZIkLbzJTbeZ+ylVn0lyTeB1wNbAL4EHVNVwMdfl5Jq0qUSzORPYcj4djBskedp8Op1NVZ/lgSVJkiRJWrmqai/a6rQrxV+A265j/+2B0+fTwVhBkqradz6dSpIkSZK0XKXa1md/AuBLwPOTfKOqDhjckWQnWkLHuqbjrNe4mSSSJEmSJEl92g24L/DFJL8CjuzabwX8K/AbYNf5dDB2kCTJxsCjgNsBm3P5lXKqqp4xj7FJkiRJkrT0LIOaJCtRVZ2d5C7Ay4FHAo/udv0BeD3w1qr6+3z6GCtIkuR6wPeA6wNn0YIkfwW2oBVrPQM4bz4DkyRJkiRJGtQFQXZlnhkjsxnO/pirt9ICI3cBbkpbzeZxwCbAK4ALgPsvxAAlSZIkSZL6MO50m3sD762qnyS5WteWqroIeGuSWwB7Ag9egDFKkiRJkrR0ON1mYrp4w9OAGwJXpSVtDKqqus+41x83k+TKwPHdv8+hvWSbD+w/FLjbuIOSJEmSJEkalOQpwBHAC4Eb02IaGdrGjXMA42eS/AnYBqCqLknyZ9rUmy90+28JXDifgUmSJEmStBS5BPDE7AYcDjywqs5YjA7GDZJ8F9gJ2L27vw+wS5Kr0qI2TwH2m/foJEmSJEmSmmsDb1usAAmMHyR5E3DHJBt1dUjeSBvso4G1wCeBly7MECVJkiRJkvg1LfawaMYKklTVn2hTbqbvXwj8R7dJkiRJkrRyVdrWZ38CeAnwuSTfqKpDFqODsYIkSa5UVRes55jrVdUJ4w1LkiRJkiTpMl4BnA38MMnRtOSNtUPHVFXtNG4H4063+XWSnavqxzPtTPJc4M3AZuMOTJIkSZKkJcklgCflNrRn40/AJrRFY4bN69kaN0hyIfD9JHsCr+7qkpDkX4CPAPcFvjifgUmSJEmSJE2rqusvdh/jrh98O+CtwIuAw5PcOcl/AEcCtweeXFWPWqAxSpIkSZK0ZEwvAdznpn6MFSSpqn9U1S7A3YANgEOADwAHA9tW1ScXbISSJEmSJElAkg2SPD7JB5J8Mcmtu/bNkzwyyVbzuf64mSTTbghcA7gYCLBhdytJkiRJkrRgkmwB/Bj4JPAE4GHANbvd5wHvps14GdtYQZIk10iyP/AJ4DDgRsBTgDsBRyV58nwGJUmSJEnSklUT2ATwJmBb4P60pI1/JmlU1Vpgf+BB8+lg3EySo4H7Ac+uqgdV1clV9QngVrSpN/slsXCrJEmSJElaKA8H3lNV32bm0NHvgOvPp4NxV7c5Enh6VR0/2FhVfwEekuRpwDvmMzBJkiRJkpakvoupmkkybXPguHXsvyLjxzlg3JOr6t7r2f+xJN8ab0iSJEmSJEmX8wfaaruzuR9t5svY5lW4Ncl1kjwhyYuSbNO1bZDkasAp87m2JEmSJEnSgA8DT0/yOC6tR1JJNkryP8ADaCvvjm2sTJIkAd4OvKC7RgFHACcBmwDHA68F9pzP4CRJkiRJWnL6LqbqdJtp76IVbv0UcFbX9kng6rTYxAeq6iPz6WDcTJKX0ZbVeRuwI5etKHs28AXgUfMZmCRJkiRJ0rRqngncA9gP+AbwS+CDwA5V9dz59jFuQZNnAvtV1auSXH2G/b8GHjj+sCRJkiRJWqLMJJmoqvoR8KPFuPa4mST/QlvqdzZ/BzYb89qSJEmSJEm9GzeT5DRaoGQ2twf+NOa1JUmSJElastLzEsC9Lje8hCU5jvXn1VRV3WjcPsYNknwBeE6SfYCzpwcCkOR+wM7AW8YdlCRJkiRJ0pDvc/kgyQbA9YB/A44EDp9PB+MGSXYF7kUrkPJD2iBfkeT1wPbdoN44n4FJkiRJkiRNq6qdZ9uX5F+BA4FPzKePsWqSdCvY3IWWLXId4ELgnsAWwO7A3avq/PkMTJIkSZIkaS6q6lfAB4A3z+c642aSUFUXAG/oNkmSJEmSpEk6FbjlfC4wdpBEkiRJkqRVySWAl5wkVweeAZw0n+sYJJEkSZIkSUteku/OsmsL4ObAhsBT5tOHQRJJkiRJkrQcrOHyeTUFHAccBHy0qo6ZTwcGSSRJkiRJGkGqbX32J6iqHRa7j7FWt5EkSZIkSVppxsokSfJa4AtVdeQs+7cFHlVVr5vP4CRJkiRJWpLM7lh0Sf59nPOqar9x+xx3us1uwLHAjEES4FbAroBBEkmSJEmSNI59xjingN6DJOtzNeDiRbq2JEmSJEmT4xLAfblB3x3OOUiS5B7ADgNNj0xy4xkO3QJ4HHDEvEYmSZIkSZJWsxcB/1tVhwMkuS5welVdsFgdjpJJci/aFBpocaxHdttMjgZeOI9xSZIkSZKk1e3FwM+Aw7v7xwFPAT65WB2OEiR5C7AXEOA04DnA54eOKeD8qrpwYYYnSZIkSdLS4hLAvTkVuOHA/Sx2h3MOknTpLBcAJLkBLcXl/MUamCRJkiRJWtW+Brw2yf2As7q2lyZ5/DrOqaraadwOxyrcWlUnDLcluTLweGAj4OszHSNJkiRJ0rJn4da+vIg2k+VewLa0Z+JfaIvFzGZez9ZYQZIkHwHuXFW36u5vCPwfbelfgLOT3Hu6uIokSZIkSdIoqurvwKum7yeZAl5cVYtWk2TNmOfdC/jCwP0n0gIkT+puT+HSIq+SJEmSJEnzdS/g24vZwViZJMDWwPED9x8O/KyqPgWQ5EPAy+Y1MkmSJEmSliALt05GVX1/sfsYN5Pk78AWAEmuAOwAHDiw/1xg8/kMTJIkSZIkaVqaZyf5SZIzkqydYbtkPn2Mm0nyC+CZSb4HPAzYFPjKwP4b0ZbqkSRJkiRpZbFw66S8BXgJ8Evg48DfFrqDcYMkr6ZljvyMtk7x/lX1k4H9jwB+PM+xSZIkSZIkTXsq8PmqeuxidTDuEsA/S3Jz4K7AWYPzgpJsAbwXWPS5QpIkSZIk9c5Mkkm5EnDQYnYwbiYJVXU68OUZ2s8C3jWPMUmSJEmSJA37DnBH4IOL1cG4hVtJskGSxyf5QJIvJrl11755kkcm2WrhhilJkiRJkla55wF3SfKqJFdfjA7GyiTpptR8E7gTcB5wFeA93e7zgHcD+wGvmv8QJUmSJElaOlwCeGJ+S0v2eD3w+iQXAmuHjqmqGnu13XGn27wJ2Ba4P3A4cNrAaNYm2R94EJMKkqTbJK0cfqZXjTUXjJ3kKGmp8pd7SdLC+DyL/L/KuEGShwPvqapvz5Li8jtg53EHJUmSJEnSkmXh1omoqp0Xu49x/1y3OXDcOvZfkXkUhZUkSZIkSerbuIGMPwC3W8f++wFHj3ltSZIkSZIkkqwr9jCjqvrFuP3NOUiS5B7Ab7qlfz8MvDnJwbQleAAqyUbAa4EHAM8ad1CSJEmSJC1ZTrfp08+Y+zOQ7tgNxu1slEyS7wFPAT4JvItWuPVTwFnd/k8CV++u+YGq+si4g5IkSZIkSQKe1mdnowRJ/rm2RFUV8Mwk+wKPBm5Cq2/yB+CzVfWDBR2lJEmSJElLhEsA96eq9u2zv3kVV62qHwE/WqCxSJIkSZIkTcyoq9us4viVJEmSJElayUYNknw8ydo5bpcsyoglSZIkSZqkmsCmXow63eYg4HeLMRBJkiRJkqRJGjVIsm9VfXJRRiJJkiRJ0jJg4daVa9TpNpIkSZIkaYVIcv0kH0lyXJILkvwhye5JNhw6pmbY7jJ0rcckOSbJhUmOSPKg/h/R/MxrdRtJkiRJkladvuuELG5fN6clUDwbOBa4FfAh4CrAfw0de1/gqIH7Z07/I8ldgU8BuwBfBZ4IfCnJ7arqyEUb/QIzSCJJkiRJ0ipVVd8EvjnQ9MckNwOey+WDJGdW1SmzXOpFwDer6q3d/dck2RF4AfCchRzzYprzdJuqWmM9EkmSJEmSJmbTJJsNbBstUj+bA3+dof2AJKcl+VGShw3t25622MugA7v2ZcOaJJIkSZIkjWJySwCfBJw9sO2y0A8tyY2BFwIfGGg+D3gp8BjgwcCPaFNpBgMlWwOnDl3u1K592XC6jSRJkiRJy8M2wLkD9y+a7cAkbwJesZ7r3aKqjhk45zq0qTefq6oPTbdX1RnAOwbO+2mSawMvAw6Y+/CXPoMkkiRJkiSNIN3WZ3+dc6vqnDme9nZgn/Uc88d/9tGCHt8DDgGeNYfrHwbsOHD/FGCroWO26tqXDYMkkiRJkiStMFV1OnD6XI7tMki+B/wceFpVTc3htO2AvwzcPxS4D7DnQNuOXfuyYZBEkiRJkqRVqguQHAycQFvN5ppJy12ZXskmyVOBi4HDu9MeCTwd+I+BS70L+H6SlwJfAx4P3IG5ZaUsGQZJJEmSJEkaxWWLqfbT3+LZEbhxt500tG9wVtFrgOsBlwDHAI+rqv3/OcSqQ5I8EXgD8Ebg98DDq+rIRRz7gjNIIkmSJEnSKlVV+7Ce2iVVtS+w7xyu9TngcwsysAkxSCJJkiRJ0ghSbeuzP/VjzaQHIEmSJEmStBSYSSJJkiRJ0ihWVk0SDTCTRJIkSZIkCYMkkiRJkiRJgNNtJEmSJEkanVNgViQzSSRJkiRJkjCTRJIkSZKkkbgE8MplJokkSZIkSRIGSSRJkiRJkgCn20iSJEmSNJqi38KtTrfpjZkkkiRJkiRJmEkiSZIkSdJILNy6cplJIkmSJEmShJkkkiRJkiSNxpokK5aZJJIkSZIkSRgkkSRJkiRJApxuI0mSJEnSSCzcunKZSSJJkiRJkoSZJJIkSZIkjcbCrSuWmSSSJEmSJEkYJJEkSZIkSQKcbiNJkiRJ0micbrNimUkiSZIkSZKEmSSSJEmSJI3EJYBXLjNJJEmSJEmSMJNEkiRJkqTRWJNkxTKTRJIkSZIkCYMkkiRJkiRJgNNtJEmSJEkaSapI9TcHps++VjszSSRJkiRJkjCTRJIkSZKk0Vi4dcUyk0SSJEmSJAmDJJIkSZIkSYDTbSRJkiRJGkmqbX32p34sqUySJM9N8usk53TboUkeOOlxSZIkSZKklW+pZZKcBLwS+D0Q4KnAl5PctqqOmujIJEmSJEkCC7euYEsqSFJVXxlqenWS5wJ3AQySSJIkSZKkRbOkgiSDkmwAPAa4CnDoLMdsBGw00LRpD0OTJEmSJK1i1iRZuZZUTRKAJLdOch5wEfB+4BFVdfQsh+8CnD2wndTPKCVJkiRJ0kqz5IIkwG+B7YA7A+8D9k1yy1mO3QPYfGDbpo8BSpIkSZKklWfJTbepqouBY7u7P09yR+BFwLNnOPYiWsYJAEl6GaMkSZIkaRWzcOuKtRQzSYat4bJ1RyRJkiRJkhbcksokSbIH8A3gT7QirE8EdgDuP8FhSZIkSZL0TxZuXbmWVJAE2BLYD7gWrRDrr4H7V9W3JzoqSZIkSZK04i2pIElVPWPSY5AkSZIkSavTkgqSSJIkSZK05Fm4dcVaDoVbJUmSJEmSFp2ZJJIkSZIkjchiqiuTmSSSJEmSJEmYSSJJkiRJ0miq2tZnf+qFmSSSJEmSJEkYJJEkSZIkSQKcbiNJkiRJ0khS/RZutUhsf8wkkSRJkiRJwkwSSZIkSZJGU93WZ3/qhZkkkiRJkiRJGCSRJEmSJEkCnG4jSZIkSdJIMtW2PvtTP8wkkSRJkiRJwkwSSZIkSZJGY+HWFctMEkmSJEmSJAySSJIkSZIkAU63kSRJkiRpJKm29dmf+mEmiSRJkiRJEmaSSJIkSZI0mqq29dmfemEmiSRJkiRJq1iS45PU0PbKoWNuk+SHSS5McmKSl89wncckOaY75ogkD+rvUSwMM0kkSZIkSRrBCq1J8lrgQwP3z/1n/8lmwLeAg4DnALcGPprkrKr6YHfMXYFPAbsAXwWeCHwpye2q6sheHsECMEgiSZIkSZLOrapTZtn3JGBD4OlVdTFwVJLtgJcAH+yOeRHwzap6a3f/NUl2BF5AC6wsC063kSRJkiRpedg0yWYD20YLeO1XJjkzyeFJXpZkMKlie+AHXYBk2oHAzZJcdeCYg4aueWDXvmyYSSJJkiRJ0iiq2/rsrzlpaM/uwG4L0MO7gV8AfwXuCuwBXIuWKQKwNXDc0DmnDuz7W3d76gzHbL0A4+uNQRJJkiRJkpaHbRioFQJcNNuBSd4EvGI917tFVR1TVe8YaPt1kouBDyTZpapm7WMlMkgiSZIkSdIIJli49dyqOmeOp70d2Gc9x/xxlvbDaPGC6wO/BU4Btho6Zvr+KQO3Mx0zW52TJckgiSRJkiRJK0xVnQ6cPubp2wFTwGnd/UOB/0lyxar6R9e2I/DbqvrbwDH3AfYcuM6OXfuyYeFWSZIkSZJWqSTbJ3lxkn9NcsMkTwLeCXx8IADySeBi4CNJtk3yONpqNoPTdN4FPCDJS5PcPMluwB2Avfp7NPNnJokkSZIkSaOoaluf/S2ei4DH0wrAbkQr0PpOBgIgVXV2kvsBewM/B84AXldVHxw45pAkTwTeALwR+D3w8Ko6cjEHv9AMkkiSJEmStEpV1S+Au8zhuF8Dd1/PMZ8DPrdAQ5sIgySSJEmSJI1ggoVbtcisSSJJkiRJkoSZJJIkSZIkjaa6rc/+1AszSSRJkiRJkjBIIkmSJEmSBDjdRpIkSZKkkVi4deUyk0SSJEmSJAkzSSRJkiRJGs1Uta3P/tQLM0kkSZIkSZIwSCJJkiRJkgQ43UaSJEmSpNFUt/XZn3phJokkSZIkSRJmkkiSJEmSNJLQ8xLA/XW16plJIkmSJEmShJkkkiRJkiSNpqptffanXphJIkmSJEmShEESSZIkSZIkwOk2kiRJkiSNJNVz4VZn2/TGTBJJkiRJkiTMJJEkSZIkaTTVbX32p16YSSJJkiRJkoRBEkmSJEmSJMDpNpIkSZIkjSRVpPqbA9NnX6udmSSSJEmSJEms0EyStzzgE1x50w0mPQwtsjf8/sGTHoJ6dKPNz5z0ENST0+961qSHoJ5ccOANJj0E9eSUn2896SGoR5dc56JJD0E9qAsunvQQJmuq2/rsT70wk0SSJEmSJIkVmkkiSZIkSdJisSbJymUmiSRJkiRJEgZJJEmSJEmSAKfbSJIkSZI0muq2PvtTL8wkkSRJkiRJwkwSSZIkSZJGU9W2PvtTL8wkkSRJkiRJwiCJJEmSJEkS4HQbSZIkSZJGkmpbn/2pH2aSSJIkSZIkYSaJJEmSJEmjsXDrimUmiSRJkiRJEmaSSJIkSZI0kky1rc/+1A8zSSRJkiRJkjBIIkmSJEmSBDjdRpIkSZKk0Vi4dcUyk0SSJEmSJAkzSSRJkiRJGk11W5/9qRdmkkiSJEmSJGGQRJIkSZIkCXC6jSRJkiRJI0kV6bGYap99rXZmkkiSJEmSJGEmiSRJkiRJo3EJ4BXLTBJJkiRJkiTMJJEkSZIkaTQFTPXcn3phJokkSZIkSRIGSSRJkiRJkgCn20iSJEmSNBKXAF65zCSRJEmSJEnCTBJJkiRJkkZT9LwEcH9drXZmkkiSJEmSJGGQRJIkSZIkCXC6jSRJkiRJo6nqebqN8236YiaJJEmSJEkSZpJIkiRJkjSaKSA996demEkiSZIkSZKEQRJJkiRJkiTA6TaSJEmSJI0kVaTHYqp99rXamUkiSZIkSZKEmSSSJEmSJI3GJYBXLDNJJEmSJElapZLskKRm2e7YHXP9WfbfZehaj0lyTJILkxyR5EGTeVTjM5NEkiRJkqRRrKxMkkOAaw21vR64D/Czofb7AkcN3D9z+h9J7gp8CtgF+CrwROBLSW5XVUcu9KAXi0ESSZIkSZJWqaq6GDhl+n6SKwI7Ae+pulx05syqOoWZvQj4ZlW9tbv/miQ7Ai8AnrPAw140TreRJEmSJGl52DTJZgPbRovQx8OAqwMfm2HfAUlOS/KjJA8b2rc9cNBQ24Fd+7JhkESSJEmSpFFMT7fpc2tOAs4e2HZZhEf3DODAqjppoO084KXAY4AHAz+iTaUZDJRsDZw6dK1Tu/Zlw+k2kiRJkiQtD9sA5w7cv2i2A5O8CXjFeq53i6o6ZuCcbYD7A48dPKiqzgDeMdD00yTXBl4GHDC3oS8PBkkkSZIkSRrFFJCe+2vOrapz5njW24F91nPMH4fuP41WjHUugY/DgB0H7p8CbDV0zFYM1DtZDgySSJIkSZK0wlTV6cDpcz0+SWhBkv2q6h9zOGU74C8D9w+lrYiz50Dbjl37smGQRJIkSZIk3Ru4AfDh4R1JngpcDBzeNT0SeDrwHwOHvQv4fpKXAl8DHg/cAXjWIo55wRkkkSRJkiRpBKkil1sdd3H768EzgEMGa5QMeQ1wPeAS4BjgcVW1//TOqjokyROBNwBvBH4PPLyqjlzcYS8sgySSJEmSJK1yVfXEdezbF9h3Dtf4HPC5hRxX3wySSJIkSZI0issuy9tPf+rFmkkPQJIkSZIkaSkwk0SSJEmSpFFMFaTH7I4pM0n6YiaJJEmSJEkSSzhIkuSVSSrJnpMeiyRJkiRJWvmW5HSbJHcEng38etJjkSRJkiTpMizcumItuUySJJsAnwCeCfxtwsORJEmSJEmrxJILkgB7A1+rqoPWd2CSjZJsNr0Bmy7+8CRJkiRJq1tdmk3Sx4aZJH1ZUtNtkjweuB1wxzmesguw6+KNSJIkSZIkrRZLJpMkyb8A7wKeVFUXzvG0PYDNB7ZtFml4kiRJkiRphVtKmSS3B7YEfpFkum0D4B5JXgBsVFVrB0+oqouAi6bvD5wnSZIkSdLisHDrirWUgiTfAW491PYx4BjgzcMBEkmSJEmSpIW0ZIIkVXUucORgW5K/A2dW1ZEznyVJkiRJUs+mei6mOmUmSV+WTE0SSZIkSZKkSVoymSQzqaodJj0GSZIkSZIuo6ba1md/6oWZJJIkSZIkSRgkkSRJkiRJApb4dBtJkiRJkpYclwBescwkkSRJkiRJwkwSSZIkSZJG4xLAK5aZJJIkSZIkSRgkkSRJkiRJApxuI0mSJEnSaCzcumKZSSJJkiRJkoSZJJIkSZIkjaboOZOkv65WOzNJJEmSJEmSMJNEkiRJkqTRWJNkxTKTRJIkSZIkCYMkkiRJkiRJgNNtJEmSJEkazdQUMNVzf+qDmSSSJEmSJEmYSSJJkiRJ0mgs3LpimUkiSZIkSZKEQRJJkiRJkiTA6TaSJEmSJI3G6TYrlpkkkiRJkiRJmEkiSZIkSdJopgroMbtjykySvphJIkmSJEmShJkkkiRJkiSNpGqKqqle+1M/zCSRJEmSJEnCIIkkSZIkSRLgdBtJkiRJkkZT1W8xVZcA7o2ZJJIkSZIkSZhJIkmSJEnSaKrnJYDNJOmNmSSSJEmSJEkYJJEkSZIkSQKcbiNJkiRJ0mimpiBT/fVXPfa1yplJIkmSJEmShJkkkiRJkiSNxsKtK5aZJJIkSZIkSZhJIkmSJEnSSGpqiuqxJklZk6Q3ZpJIkiRJkiRhkESSJEmSJAlwuo0kSZIkSaOxcOuKZSaJJEmSJEkSZpJIkiRJkjSaqYKYSbISmUkiSZIkSZKEQRJJkiRJkiTA6TaSJEmSJI2mCpjquT/1wUwSSZIkSZIkzCSRJEmSJGkkNVVUj4Vby0yS3phJIkmSJEmShEESSZIkSZIkwOk2kiRJkiSNpqbot3Brj32tcmaSSJIkSZIkYSaJJEmSJEkjsXDrymUmiSRJkiRJq1iSVyc5JMn5Sc6a5ZjrJvlad8xpSd6a5ApDx+yQ5BdJLkpybJKdZ7jO85Mcn+TCJIcludPiPKrxGCSRJEmSJGkUNdX/trg2BD4HvG+mnUk2AL7WHXdX4KnAzsDrBo65QXfM94DtgD2BDye5/8AxjwPeAewO3A74FXBgki0X+PGMzSCJJEmSJEmrWFXtWlXvBI6Y5ZD7AbcEnlxVv6yqbwCvAZ6fZMPumOcAx1XVS6vqN1W1F7A/8P8GrvMS4ENV9bGqOro753zg6YvwsMayImuSnH/e2kkPQT1Y+/eLJj0E9egfV7h40kNQTy6pf0x6COrJJf4cXzWmLrxw0kNQj6Yu8LO9Gqz21/kS/gE9lgm5hH/+frRpksFdF1VVHy/G9sARVXXqQNuBtMyTbYHDu2MOGjrvQFpGCV0w5fbAHtM7q2oqyUHduUvCSguSbArw9Lv9btLjUC9+M+kBqEc/n/QAJC28R0x6AJKkBbApcM6kB9Gji4FTfsTXt55A3+cBJw217Q7s1kPfWwOnDrWdOrBvXcdsluRKwFWBDWY55uYLN9T5WWlBkpOBbYBzJz2Qnm1K+7Csxse+2vharx6+1quHr/Xq4uu9evharx6r+bXelPYdbNWoqgu72hsbrvfgfsyaRZLkTcAr1nP+LarqmIUd0vK2ooIk1dZF+vOkx9G3gXSrc6tqNUVxVx1f69XD13r18LVeXXy9Vw9f69Vjlb/Wq+3xAi1QAiyHeYRvB/ZZzzF/nOO1TgGGV6HZamDf9O1WMxxzTlVdkGQtsHaWY05hiVhRQRJJkiRJkgRVdTpw+gJd7lDg1Um2rKrTurYdaYGyoweOedDQeTt27VTVxUl+DtwH+BJAkjXd/b0WaJzzZpBEkiRJkqRVLMl1gasB1wU2SLJdt+vYqjoP+BYtGPK/SV5Oqz/yBmDvgcKx7wdekOQtwEeBewOPBR480NU7gH2T/Az4CfBi4CrAxxbv0Y3GIMnKcBGtYM/qLjG9Ovharx6+1quHr/Xq4uu9evharx6+1loJXgc8deD+4d3tvYCDq2ptkofQVrM5FPg7sC/w2ukTquq4JA8G3gm8iFar5z+q6sCBYz6T5Jpdf1sDvwQeMLRqzkSllfGQJEmSJEla3dZMegCSJEmSJElLgUESSZIkSZIkDJJIkiRJkiQBBkkkSZIkSZIAgyTLWpKNkrw5yclJLkhyWJIdJz0uLbwkmyTZPck3k/w1SSXZedLj0sJKcsckeyU5Ksnfk/wpyWeT3HTSY9PCSrJtks8l+WOS85OckeQHSR466bFp8SV5dfdz/MhJj0ULK8kO3Ws703aXSY9PCy/J7ZIc0P1+dn6SI5P856THJWl8LgG8vO0DPBrYE/g9sDPw9ST3qqofTW5YWgTXoC2v9SfgV8AOEx2NFssrgH8DPgf8mrYs2guAXyS5S1X5hWrluB6wKW3pvJOBKwOPAg5I8uyq+uAkB6fFk2Qb4FW0pRO1cr0b+OlQ27GTGIgWT5L7AV+hLZX6euA84EbANpMcl6T5cQngZSrJnYDDgJdV1du6to2BI4HTququkxyfFlaSjYCrVtUpSe5A+8XraVW1z2RHpoWU5K7Az6rq4oG2mwBHAPtX1ZMnNjgtuiQbAD8HNq6qm096PFocST4NXBPYALhGVd1qwkPSAkqyA/A94DFVtf9kR6PFlGQz4HfAIcCjq2pqwkOStECcbrN8PRpYC/zzr41VdSHwEWD7JP8yqYFp4VXVRVV1yqTHocVVVYcMBki6tt8DRwG3mMyo1JeqWgucCGwx4aFokSS5B+3/7xdPeCjqQZJNk5i1vXI9EdgKeHVVTSW5ShK/W0krgB/k5eu2wO+q6pyh9p90t9v1OxxJiyFJaL+EnTHpsWjhdb9UXyPJjZL8P+CBwHcmPS4tvC5T6D3Ah6vqiEmPR4vuY8A5wIVJvtdlgWpluS/tNb5Okt/Sptqck+R9XXa3pGXK6PbydS3gLzO0T7ddu8exSFo8TwKuQ6tJo5Xn7cCzu39PAV+g1aHRyvMcWi2a+056IFpUFwOfB75OC27fEvgv4IdJ7lpVh09ycFpQN6F9l/oyLZN7F1rNuBfSMgKfMKmBSZofgyTL15WAi2Zov3Bgv6RlLMnNgb2BQ2kFPrXy7AnsTwtsP5ZWp2LDSQ5ICy/J1YHXAa+vqtMnPR4tnqo6hFajYtoBSfanFePeA3jARAamxbAJrej2+6tqejWbLyTZEHh2ktd2U2YlLTNOt1m+LgA2mqF944H9kpapJFsDXwPOphWEWzvhIWkRVNUxVXVQVe1XVQ+h/dL9lW6alVaONwB/pU230SpTVcfSsg3u1U270sow/bv2p4baP9ndbt/jWCQtIIMky9dfaFNuhk23ndzjWCQtoCSbA9+gpes+oKr8PK8e+wN3BG466YFoYXQrVD2LtiTstZNcP8n1aX/UuGJ3/2qTHKN6cSItS+wqkx6IFsz0/82nDrWf1t1etcexSFpABkmWr18CN+2WHxt054H9kpaZrtjbV2hfkh9SVUdPeEjq1/RUyc0nOgotpOvQft96N3DcwHZn2uf8OKw5tBrckDYl+rxJD0QL5ufd7XWG2qfrAjq1TlqmDJIsX/vT5q4/a7ohyUbA04DDqurESQ1M0ni6NOzP0FJ0H1NVh054SFokSbacoe2KwL/TUrgNjq0cRwKPmGE7CvhT9++PTGx0WlBJrjlD278CDwO+VVVT/Y9Ki+Sz3e0zhtr/A7gEOLjX0UhaMBZuXaaq6rAknwP26H7ZPhZ4KnB9Lv/DWitAkhfQpl9M/4XioUm26f79nqo6eyID00J6O+0X6a8AV0vy5MGdVfXxiYxKi+EDXSbgD4A/A1vTVjK6OfDSqvKvzStEVZ0BfGm4PcmLu/2X26dl7TNJLqAVbz2NtrrNs4DzgVdOcmBaWFV1eJKPAk9PcgXg+7TVbR4D7OFUWWn5SlVNegwaU5eW/3rgybR5j78GXlNVB050YFoUSY6nLR85kxtU1fH9jUaLIcnBwD1n219VFvNcIZI8nhbQvjVwdeBcWur2e6rqgEmOTf3oPu/XqKpbTXosWjhJ/pMW8LwxsBltysV3gN27Aq5aQboMwFfRMrmvDZwA7F1Ve05yXJLmxyCJJEmSJEkS1iSRJEmSJEkCDJJIkiRJkiQBBkkkSZIkSZIAgySSJEmSJEmAQRJJkiRJkiTAIIkkSZIkSRJgkESSJEmSJAkwSCJJkiRJkgQYJJEkSZIkSQIMkkiSloAk+yQ5fsxzd0tSCzwkdZIcn2SfnvusJLvN4Thfe0mStKAMkkiSZtV9WZ3LtsOkxypJkiTN1xUmPQBJ0pL2lKH7/w7sOEP7b+bZzzMZP3D/BuBN8+xfS8uVgEsmPQhJkrT6GCSRJM2qqj4+eD/JXYAdh9uHJblyVZ0/Qj//GHOIVNUl+IV6RamqCyc9BkmStDo53UaSNC9JDk5yZJLbJ/lBkvOBN3b7dkrytSQnJ7koyR+SvCbJBkPXuExNkiTX76bx/FeSZ3XnXZTkp0nuOHTu5epSdOfuleTh3dguSnJUkgfMMP4dkvwsyYVdP88epdZFkjsn+WaSs5Ocn+T7Sf5tYP8tklyQZL+h8+6WZG2SNw+0zfX5mn7Ob9P1d36SY5M8utt/zySHdf3+Nsl9Z3rOktw8yWeTnJPkzCTvSrLxHB7zFkn2THJiN85jk7wiyZqh4x6f5OdJzu36OCLJi+Zw/cvVJOmer58Ovk4znPe07tynD7W/qmt/0Pr6liRJq5uZJJKkhXB14BvAp4GPA6d27TsD5wHv6G7vDbwO2Ax42Ryu+0RgU+ADQAEvB76Q5IZzyD65G/BI4L3AucB/Ap9Pct2qOhMgyW2BbwJ/AXYFNgBeC5w+h7GR5N60x/1zYHdgCnga8N0kd6+qn1TVb5K8Bnhrkv2r6oAkVwH2AY7p+pu2M3N/vq4KfJX2nH8OeC7w6SRPAvYE3g98sjtv/yT/UlXnDl3js8DxwC7AXbrn6Kq0aVWzPeYrA98HrkN7Xf4E3BXYA7gW8OLuuB2BTwHfAV7RnX4L4N+Ad812/Vn6vDXwLdrrshvt95fdufR9BkBVfSzJI4F3JPl2VZ3Ynbsr8JGq+voo/UqSpNXHIIkkaSFsDTynqj4w1P7Eqrpg4P77k7wfeF6S/66qi9Zz3esCN6mqvwEk+S3wZeD+tADButwCuGVV/aE793vAr4AnAHt1x+wOrAX+rapO7o77LHOosZIktEDE94AHVlV17R8AjqLVSrlfd/g7gJ2ADyb5cdfv9YDth56DUZ6va3fHf6rr99u0oMsngbtW1WFd+2+AA4FH0QIzg46rqp26f++d5Jyur7dV1a9neegvAW4E3Laqft+1fSDJycDLkry9qk4EHgycA9y/qtbOcq25eh0Q4O5V9afucX0eOGKGY59Je/4/kuQhwL7AKd24JUmS1snpNpKkhXAR8LHhxsEv/Ek2TXIN4IfAlYGbz+G6n5kOkHR+2N3ecA7nHjQdIOnG8mval/YbduPZALgv8KXpAEl33LG07JD12Q64CS0ocfUk1+ge31Vo2RP3mJ5+UlVTtCyRTbprPw/Yo6p+NnjBEZ+v82hZJNPn/hY4C/jNdICkM/3vmZ6zvYfuv6e7Xde0lMd0Y/rb9GPuxnkQLRPnHt1xZ9Geix3Xca316l6n+9Nepz9Nt1fVdPDnMqrqFOD5Xb8/pL1OT6+qc+YzDkmStDqYSSJJWgh/rqqLhxuTbEvLqLg3bcrIoM3ncN0/Dd6pqr+1BA6uOuq5nb8NnLslbRWVY2c4bqa2YTfpbvddxzGbd31SVX/o6my8FTgSeP3wwSM+XydNZ68MOBs4cbChqs5ex3P2+6H7f6BNGbr+jI+muQlwG2afkrRld/te4LHAN5L8mTZd5rNV9c11XHsm16S9TsNjBfgtMwR0qurTSZ5My2b5YFV9Z8Q+JUnSKmWQRJK0EC4YbkiyBa12xTm0uht/AC4Ebge8mbllM842TSOLfO5cTI//ZcAvZznmvKH709Nvrk2r43LKPwc1+vM12+Obz+OeS7HaNcC3gbfMsv93AFV1WpLtaFkgD+y2pyXZr6qeOod+xpbk6sAduru3TLKmy+aRJElaJ4MkkqTFsgMtEPDIqvrBdGOSG0xsRJd1Gi0IceMZ9s3UNmx6Ks85VXXQ+g5O8hzaFJBX0wqlfoBWp2TaDvT/fN0EOG7g/o1pQZDj13HOH4BN5vKYu+yirwBf6aYevRd4dpLXd9Oa5uJ0WhDuJjPsu9ks5+xNK/i7C62g7ItpdWEkSZLWyZokkqTFMp3R8M8MhiQb0upxTFxXTPQg4OFJrj3dnuTGtKyH9fk5LWDwX0k2Gd6Z5JoD/74BbZrN56vqjcB/AQ9LMriKzCSer+cP3X9hd7uumiyfBbZPcv/hHd3SwFfo/n31wX1dJsd0MdiN5jrA7nU6kPY6XXegr1vQslSGx/Bo4HHAK6vqTbS6LW9IctO59ilJklYvM0kkSYvlEFo9jn2TvJs2leMpLNx0l4WwG20KzI+TvI9WePQFtJoh263rxKqaSvIftIDCUUk+BvyZtjTuvWjTZh7arYLzUVo2xHO7cz+Q5FHAu5Ic1BWOncTzdYMkB9CWQd4eeDLwyar61TrOeSvwMOCrSfahBYuuAtwaeDStnskZwIeTXA34LnASbTWfF9KmJq139aAhuwIPAH6Y5L20319eSFvF5jbTByXZEngfbcWh6RWMXkB7PfZJcjen3UiSpHUxk0SStCiq6kzgIcBfaMVI/4tWy+LlkxzXoKr6OS1r5G+0QqrPoNUD+Q5tKs76zj+YFlz4Ge3L+Htoq9icAryzO+yFtKk0z6mqwWKnz6D9P/yh7lqTeL4eR1uZ6E20Iqd7deOaVVWdD9yTFizZAXgX8EradJhdacVjAT5Oew6fR5tm81TgM7TlkkcKVHQrE92fNvXmdcDTu76+OHTo+2hZKk+bLmrbPa/Por1O/zVKv5IkafXJ5QvjS5K0uiX5ErBtVc1UB2PZ61bZ2RW4ZlWdMeHhSJIkLRlmkkiSVrUkVxq6fxPasrIHT2RAkiRJmhhrkkiSVrs/drU1/kirm/Fc4GJmX+JWkiRJK5RBEknSavdN4AnA1rT6HIcCr6qq3090VJIkSeqdNUkkSZIkSZKwJokkSZIkSRJgkESSJEmSJAkwSCJJkiRJkgQYJJEkSZIkSQIMkkiSJEmSJAEGSSRJkiRJkgCDJJIkSZIkSYBBEkmSJEmSJAD+P3iXLaC3DnjQAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -804,7 +797,7 @@ } ], "source": [ - "plt.imshow(ekfac_train_influences.numpy().astype(int), vmin=-1000, vmax=500)\n", + "plt.imshow(ekfac_train_influences.numpy().astype(int), vmin=-1000, vmax=1000)\n", "plt.colorbar(label=\"Influence value \")\n", "plt.title(\"Influence of training examples on test examples\")\n", "plt.xlabel(\"Training examples idx\")\n", @@ -816,7 +809,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Most of the test and training examples have similar influence, close to zero. However, there is one test and one training example that stand out. In particular, their influence is a very large negative values. Let's see what these examples are." + "Most of the test and training examples have similar influence, close to zero. However, there is one test and one training samples that stand out. In particular, their cross influence is very large and negative. Let's examine them more closely." ] }, { @@ -873,7 +866,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We can see that, despite being positive, this review is quite hard to classify. Its language is overall negative, mostly related to the facts narrated rather than the movie itself. Notice also how several terms are related to war and invasion." + "We can see that, despite being positive, this review is quite hard to classify. Its language is overall negative, mostly associated to the facts narrated rather than the movie itself. Notice how several terms are related to war and invasion." ] }, { @@ -928,7 +921,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "This review is also quite hard to classify. This time it is negative, but it contains several positive terms. The parallel with the previous review is quite interesting, since both reviews talk about an invasion. " + "This review is also quite hard to classify. This time it has a negative sentiment towards the movie, but it also contains several words with positive connotation. The parallel with the previous review is quite interesting, since both reviews talk about an invasion. " ] }, { @@ -937,7 +930,8 @@ "source": [ "As it is often the case when analysing influence functions, it is hard to understand why these examples have such a large influence. We have seen some interesting patterns, mostly related to similarities in the language and words used, but it is hard to say with certainty if these are the reasons for the large influence.\n", "\n", - "A [recent paper](https://arxiv.org/abs/2308.03296) has explored these patterns in high detail, even for much larger language models than bert (up to ~50 billion parameters!). What has been found is that while smaller models tend to rely a lot on word-to-word correspondencies, larger models are more capable to extract higher level concepts, drawing connections between words from the whole sentence.\n", + "A [recent paper](https://arxiv.org/abs/2308.03296) has explored this topic in high detail, even for much larger language models than BERT (up to ~50 billion parameters!). Among the most interesting findings is that smaller models tend to rely a lot on word-to-word correspondencies, while larger models are more capable of extracting higher level concepts, drawing connections between words across multiple phrases.\n", + "\n", "For more info, you can visit our [blog on influence functions for large language models](https://transferlab.ai/pills/2023/llm-influences-with-ekfac/)" ] }, @@ -952,7 +946,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The limited computational resources available to us do not allow us to compute the influence function for all the training examples. However, we can still get an idea of how the influence function changes when we corrupt the training examples. In the next cell we will flip the label of all the training examples and compute the influence function for the same test examples as before." + "In this sections we want to get an idea of how influence functions change when training examples are corrupted. In the next cell we will flip the label of all the training examples and compute the influences on the same test batch as before." ] }, { @@ -983,7 +977,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -995,7 +989,7 @@ } ], "source": [ - "plt.imshow(corrupted_ekfac_train_influences.numpy().astype(int), vmin=-1000, vmax=500)\n", + "plt.imshow(corrupted_ekfac_train_influences.numpy().astype(int), vmin=-1000, vmax=1000)\n", "plt.colorbar(label=\"Influence value \")\n", "plt.title(\"Influence of corrupted training examples\")\n", "plt.xlabel(\"Training examples idx\")\n", @@ -1007,7 +1001,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Overall, when corrupted the influences turn from positive to negative and vice versa, as expected. More interestingly, some influences that were close to zero before corruption now have a large magnitude, while others keep having a small magnitude." + "Overall, when corrupted the influences tend to become negative, as expected. Nevertheless, there are cases where values go from slightly negative to positive, mostly isolated to the second and last test samples. Single values can be quite noisy, so it is difficult to generalise this result, but it would be interesting to see how common these cases are in the full test dataset." ] }, { @@ -1021,7 +1015,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Since ekfac is based on a block diagonal approximation of the Fisher information matrix, we can compute the influence function separately for each layer of the neural network. In this section we show how to do that and we briefly analyse the results." + "Since ekfac is based on a block diagonal approximation of the Fisher information matrix, we can compute the influence functions separately for each layer of the neural network. In this section we show how to do that and we briefly analyse the results." ] }, { @@ -1042,7 +1036,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The method `influences_by_layer` returns a dictionary containing the influence function values for each layer of the neural network as a tensor. To recover the full influence values as returned by `influences`, we need can sum the values in the dictionary as follows." + "The method `influences_by_layer` returns a dictionary containing the influence function values for each layer of the neural network as a tensor. To recover the full influence values as returned by the `influences` (as done in the previous section), we need to sum each layer's values." ] }, { @@ -1060,7 +1054,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "And if we plot the influence values as a heatmap, as done in section [Negative influence training examples](#Negative-influence-training-examples), we can see that the results are the same." + "And if we plot the result as a heatmap we can see that the results are the same as in [Negative influence training examples](#Negative-influence-training-examples)" ] }, { @@ -1074,7 +1068,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABEkAAALGCAYAAAC50896AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABbcklEQVR4nO3dd5xkZZX/8c93UECyooDIYkQxLmsEIyrJHFZXRV1BV9FVV9eM/hRQV8yigi64KrCKATCACUXFyKIgShIVBAXJKklgkO7z++Pe1qLonumq7r7VXf15v173VVPPvXWfU1UzMH3mPOdJVSFJkiRJkrTcrRh1AJIkSZIkSYuBSRJJkiRJkiRMkkiSJEmSJAEmSSRJkiRJkgCTJJIkSZIkSYBJEkmSJEmSJMAkiSRJkiRJEmCSRJIkSZIkCTBJIkmSJEmSBJgkkSQNKMkGST6U5NwkNySpJNsk2b799d6jjnGxS/IfSc5Icm37mb1y1DHNRft74dxRxyFJkjRXNxt1AJKkhZekAKoq83C7dwN7AF8B/heYAC4CNpqHe4+9JM8EPgicDOwHrAT+b5QxSZIkqWGSRJI0qMcDv66qJ/QOJtl6RPEsNY+feqyqC0YaiSRJkm7E5TaSpEFtDlw46iCWsM0BTJBIkiQtPiZJJGmZSnKHth/Gwe2vP5vksiTXJTkxyeP7rj+uXbYT4BHtayvJcauZZ8Z+FUn2bu+x/TTntm5jOy/J9UkuTnJYkrtNc+3B7X3ukGSPJKe27+PiJAcl2XCG+bdo+6v8pu0P8qckP0ny5hmu3T/Jb5OsTPLHJEclecCq3n//ewUe2T6f+vyq55pqP+fNkvxPkj8kmUiyW881/5Lk+0muaGM+NcmeSdaaZs5z22O9JB9oP8trk/w8yZPba26W5E3tZ3BdkrOTvGw272k173fDJK9N8p0k57ff4aXtZ7Zd37W3THJNO/e0S8KSHN1+PvfvG39QkiOSXNTOcV6SA5NsPs09jmvvsWaStyT5VftdHtyeX7PtF/OzJH9uYzo3yZeT7DDXz0SSJC1+LreRJN0e+AnwW5oeI7cCngF8OckOVfXd9rqDgeOAvYDftc8Bzp3vgJLsAnwBuDlwNHAWsAXwVOBxSR5ZVT+b5qXvBnZuX/NNmoTEC4G7AI/qm+P+wDE07/f77XzrAPcA9gbe1nPtfdv73ap9zReAWwNPBn6Y5ClV9bXVvK3j2sfdaD7zfWa47lY0PUqubueZBC5u43gHsCdwGXBYe81jgHcAOyfZqaqu77vfzYFvtff9MrAm8CzgyCQ7Af8OPAj4Ok1/lKcDH05yaVV9bjXvaVXuDvwXzWf7VeDPwJbAE4HHJHlCVX0DoKr+nOSzwO7ADm28f5PkH9r3eVJVndgz/nzgoDbuo4DzgK2AfwOekGTbqvr9NLEdCTygfc9fAi5pxw+m+WxOAw4FrqWp/HkosAtw7NCfhiRJWhqqysPDw8NjzA+gmv/k32jsDlPjwF5953Zux782w72Om2Z8+/bc3n3j5wLnzhDX3u1rtu8ZuyXND9SXAffou/5eNImBn/WNH9ze5/fAlj3jN6P5Ib2AB/aMrwmc047vOk1cW/Td4yzgOuARfddtDvyBZvnRWrP8Lo7r/y76vyeaH9Bv1nduu573uFlffEe35944zWdf7fm1esYf1o7/CfgpsFHPuTsB1wMnD/D76ybfMbAhcOvpPlvgAuCXfeP3b2M6YhW/T17YM3bXNs6zgNv1Xf9omobCX5zuswdO6Y+tjXcSOBFYY5oYNh72z5+Hh4eHh4fH0jlcbiNJ+h3w9t6BqjqG5ofxB44gnn+l2Slnr6o6oy+u04CPAf+U5B7TvPat1VM5UFU3AJ9sn/a+lyfQJImOqqrD+m9SVef3PH0ccGfgw1X1vb7rLqCpXtmM5gfz+XA98Jo29l7Pbx/fXlUX9cRwA/Bqmh/w/22Ge76yqlb2vOYHNEmiWwKvr6rLe879FvgRcK8kawz7Jqrqiqq6bJrx84EjgK2TbNkzfiJNguJJSTabGm9jeAFwFfCZnlu9hKZK5hVV9Ye+Ob5NU1nyhCTrTxPem6eJbWop2Uqaz7I/7j+u4u1KkqQx4XIbSdLPq2pimvHzaKoXujY15z8m2Xua83dtH+8OnNF37kRu6rz28ZY9Y9u2j18fIJ7bzxDPVj3xrG7JzWycW1WXTDN+3/bxO/0nqurXSc4H7phkw6q6ouf05VV19jT3uwC4I3DSNOf+QPN3hM3aXw8lyUOAV9B8hpvQVPD0uh1NMm7KR4BP0CSE3tGOPZam+uSjVXV1z7VT38sjZugLswmwBs3vl/73+JP+i6vqyiRH0yTQfp7kSOAHwAlVdc2q3qckSRofJkkkSZfPMH4Do2nwvXH7+MLVXLfeNGOXTzM2VZHRWxWxUfs4mwTAVDxPHyKeYVw0w/hU89mZdha6kKbnx0ZAb5Lkimmvbj+XvoTKjc7RVGoMJclTaCpGrqPpMXI28BeaKo3tgUcA/c1mPwu8D3hhkndW1STwovbcgX3XTn0vr11NKNN9LzN9xs8AXg/syt97xlyX5Aia6p6LVzOXJEla4kySSJIW2iQ3rSCYstE0Y1M/tP9jVZ2yIBH9PZlyu1lcOxXPk6rqqIUJ50ZqhvGpODajSTj0u23fdaP2NpqlQ/evql/2nkhyIE2S5Eaq6tp2p5n/BHZKcjpNw9YTquoXfZdPvc8Nq+rKQQKrqmk/46q6lqb/yd5ts9iH0zTafQ7N8qyHDTKPJElaeuxJIklaaH8GNk0yXVXC/acZ+7/2cSF/IJ2a4zEDXDvqH5BPbh+37z+R5C40S1LO6e0vMmJ3Ac6YJkGygma3mJl8lCZRtAdNL5I1uGkVCSzw91JV51XVp2maGJ8FPDTJxqt5mSRJWuJMkkiSFtpPaCoXd+8dTLIb8JBprv8kTaXHXklu0jg2yYok288xpqNpdmR5YpJnTTPHFj1Pv0xTufHSJI+d7mZJtkuyzhxjWp1PtI//L8lteuZeA3gvzf/TP77AMQziXGCrJJtPDSQJTaXGdE13Aaiq3wDfBh4PvJjm98Jnp7l0f+CvwAeS3LX/ZJI1k8w6gZLkNknuPc2pdWmW7NxAUxkjSZLGmMttJEkL7cM0CZKPJnk0TSPVbWgab36F5ofhv6mqPyZ5GvBF4P+SfBs4naa64B/a120MrD1sQFV1fZKnA98EDkuyB01lwto0DVgfTfv/yKr6a5KnAscAX03yY+DnwDVtPA+g2Tb3tu3YgqiqHyd5N/A64LS2T8ZfaKph7gX8EHjPQs0/hA8A/w2c3DZB/StNUuweNEmqJ6zitR8BdgA2pdlV6Nr+C6rqzCTPp0kenZ7kG8CvafqobElTYXIpsPUs471dG+upNFsEnwdsQPP7czPgQ1V11SzvJUmSliiTJJKkBVVVZyTZgWa3kifQ/Iv8D2iSHU+lL0nSvubbSe4DvIZmucPDaP4V/wKa3V2OnIe4TkyyDfAGmkTDg2m2mT0LeEvftack+UfgVW28u9P0WrmQZhnMXsBNtrudb1X1+iQnAy+j2Sr55jRVLv8PeF9VLZpKh6o6MMlK4JXA84Brab733YF/ZtVJkqNoPs9bM/1Sm6k5PpXkFzRbID8S2IkmcXQBTdPYzw0Q8rk03+P27b1uDfwJ+BXN75HpqlkkSdKYyQy9yyRJkkYiyZ1oklU/qqpR94KRJEnLiD1JJEnSYvMaIDR9RyRJkjpjJYkkSRq5JFsCuwJb0SzJOQW4b1VNjjQwSZK0rNiTRJIkLQZ3AvalaX77LeAlJkgkSVLXXG4jSZJGrqqOq6pU1bpVtXNV/XbUMUmStJQleXiSo5NckKSSPLnvfJK8NcmFSa5NcmySrfquuVWSTye5MsnlST6eZL2+a+6T5AdJrktyXpLXdfD2FoxJEkmSJEmSxs+6wC+Al85w/nXAfwAvBh5Es0PcMUnW7rnm08A9gR1pdvh7OHDQ1MkkGwDfBH4H3A94LbB3khfN6zvpkD1JJEmSJEkaY0kKeEpVfal9HuAC4H1V9d52bEPgYmC3qvpskrsDZwAPqKoT22t2Ab4GbFFVFyR5CfBfwGZVdX17zTuBJ1fV1p2+yXkyVj1J2i96c+CqUcciSZIkSWNufeCCWmb/8t5WWqw56jhaK6tq5RCvuyOwGXDs1EBVXZHkBGA74LPt4+VTCZLWscAkTeXJF9trvj+VIGkdA7w+yS2r6s9DxDZSY5UkoUmQnD/qICRJkiRpmdgC+MOog+hKkrU322SNay+6ZGIU018NrNc3tg+w9xD32qx9vLhv/OKec5sBl/SerKobkvyp75pzprnH1DmTJCN2FcDt3vYmVqy99uqu1VI3mVFHoA75bS8fG/7Kb3u5uOJuy+ofHpc3v+rlxf+MLwuT113H+Xu9HZZfFf+aF10ywe9OugMbrN9di88rr5rk9vc7dz2apFTvZz5MFYlWYdySJACsWHttVtzCJMnYM0myrMS/YC8ba6zpn+3lYsXa/sFeNvyqlxf/M65lYL31w3rrd/ebffLvf7Cuqqor5+GWF7WPmwIX9oxvCvy855pNel+U5GbArXpef1H7ml6b9pxbctzdRpIkSZKk5eUcmiTGo6cG2p1qHgQc3w4dD2yU5H49r3sUTR7hhJ5rHp7k5j3X7Aj8ain2IwGTJJIkSZIkjZ0k6yXZJsk27dAd2+dbts129wP+X5InJrk3cCjNjjdfAqiqXwLfAD6W5IFJHgLsD3y2qi5o73kYcD3w8ST3TPIM4BXA+7t5l/NvLJfbSJIkSZK0UCZqkokOlxJO1OQwL7s/8N2e51OJi0OA3YB3A+sCBwEbAT8Edqmq63pe82yaxMi3aXa1ORL4j6mT7Y44OwEHACcBlwFvraqDhgl4MTBJIkmSJEnSmKmq41hFl6C2muQt7THTNX8Cdl3NPKcADxsuysXHJIkkSZIkSQOYpJjssCt1l3Mtd/YkkSRJkiRJwkoSSZIkSZIGMskkQ3UJmcN86oaVJJIkSZIkSZgkkSRJkiRJAlxuI0mSJEnSQCaqmKjumql2OddyZyWJJEmSJEkSVpJIkiRJkjQQtwAeX1aSSJIkSZIkYZJEkiRJkiQJcLmNJEmSJEkDmaSYcLnNWLKSRJIkSZIkCStJJEmSJEkaiI1bx5eVJJIkSZIkSVhJIkmSJEnSQCaqmKjuqju6nGu5s5JEkiRJkiQJkySSJEmSJEmAy20kSZIkSRrIZHt0OZ+6YSWJJEmSJEkSVpJIkiRJkjSQCYqJDrfl7XKu5c5KEkmSJEmSJEySSJIkSZIkAS63kSRJkiRpIBPVHF3Op25YSSJJkiRJkoSVJJIkSZIkDcQtgMeXlSSSJEmSJElYSSJJkiRJ0kAmCROk0/nUDStJJEmSJEmSMEkiSZIkSZIEuNxGkiRJkqSBTFZzdDmfumEliSRJkiRJElaSSJIkSZI0kImOG7d2OddyZyWJJEmSJEkSJkkkSZIkSZIAl9tIkiRJkjQQl9uMLytJJEmSJEmSsJJEkiRJkqSBTFaYrO6qO7qca7mzkkSSJEmSJAkrSSRJkiRJGog9ScaXlSSSJEmSJEmYJJEkSZIkSQJcbiNJkiRJ0kAmWMFEhzUHE53NJCtJJEmSJEmSsJJEkiRJkqSBVMdbAJdbAHfGShJJkiRJkiRMkkiSJEmSJAEut5EkSZIkaSAThAm6WwLT5VzLnZUkkiRJkiRJWEkiSZIkSdJAJmoFE9XhFsDV2VTLnpUkkiRJkiRJLNIkSZKXJjk3yXVJTkjywFHHJEmSJEkSwCRhkhUdHvYk6cqiS5IkeQbwfmAf4L7AL4Bjkmwy0sAkSZIkSdJYW3RJEuBVwMeq6pNVdQbwYuAa4PmjDUuSJEmSJI2zRdW4NcmawP2AfafGqmoyybHAdtNcvxawVs/Q+gsepCRJkiRpWXML4PG12CpJbg2sAVzcN34xsNk01+8JXNFznL+g0UmSJEmSpLG1qCpJhrAvTf+SKetjokSSJEmStIC63wLYPYC7stiSJJcBE8CmfeObAhf1X1xVK4GVU88TS5AkSZIkSdJwFtVym6q6HjgJePTUWJIV7fPjRxWXJEmSJEkaf4utkgSa5TOHJDkR+AnwSmBd4JOjDEqSJEmSJIBJwmSHzVS7nGu5W3RJkqr6XJLbAG+ladb6c2CXqupv5ipJkiRJkjRvFl2SBKCq9gf2H3UckiRJkiT1m2QFEx12r5jExq1dWVQ9SSRJkiRJkkbFJIkkSZIkSRKLdLmNJEmSJEmL1UStYKK6qzmYKJfbdMVKEkmSJEmSJKwkkSRJkiRpIJOsYNLGrWPJShJJkiRJksZIknOT1DTHAe3546Y5999999gyyVeTXJPkkiTvSTL2hRZj/wYlSZIkSZpPExUmKp3ON6AHAGv0PL8X8C3g8J6xjwFv6Xl+zdQvkqwBfBW4CHgwcFvgUOCvwBsHDWYpMUkiSZIkSdIYqapLe58neQNwNvC9nuFrquqiGW6xE3APYIequhj4eZI3A+9KsndVXb8QcS8GLreRJEmSJGlpWD/JBj3HWqt7QZI1gecAn6i60TY5z05yWZLTkuybZJ2ec9sBp7YJkinHABsA95yPN7JYWUkiSZIkSdIAJljBRIc1BxN/b9x6ft+pfYC9V/PyJwMbAQf3jB0G/A64ALgP8C7gbsBT2/ObAb0JEnqebzabmJcqkySSJEmSJC0NWwBX9TxfOYvXvAD4elVdMDVQVQf1nD81yYXAt5PcuarOnp9QlyaTJJIkSZIkDWCyVjBZHW4B/PdVMldV1ZWzfV2S2wM78PcKkZmc0D7ehaZ3yUXAA/uu2bR9nKmPyViwJ4kkSZIkSeNpd+ASmp1qVmWb9vHC9vF44N5JNum5ZkfgSuCM+QxwsbGSRJIkSZKkMZNkBU2S5JCquqFn/M7ArsDXgD/S9CT5APD9qjqlveybNMmQ/03yOpo+JG8HDqiq2SzxWbJMkkiSJEmSNIARNm4dxA7AlsAn+savb8+9ElgXOA84kiYJAkBVTSR5PPBRmqqSvwCHAG8ZJpClxCSJJEmSJEljpqq+CWSa8fOAR8zi9b8DHrsAoS1qJkkkSZIkSRrAJDBRN8k/LOh86oaNWyVJkiRJkrCSRJIkSZKkgUyygskOaw66nGu585OWJEmSJEnCJIkkSZIkSRLgchtJkiRJkgYyUSuYqA63AO5wruXOT1qSJEmSJAkrSSRJkiRJGsgkYZIutwDubq7lzkoSSZIkSZIkTJJIkiRJkiQBLreRJEmSJGkgNm4dX37SkiRJkiRJWEkiSZIkSdJAJljBRIc1B13Otdz5SUuSJEmSJGEliSRJkiRJA5msMFkdbgHc4VzLnZUkkiRJkiRJmCSRJEmSJEkCXG4jSZIkSdJAJjtu3DppfUNn/KQlSZIkSZKwkkSSJEmSpIFM1gomq8NKkg7nWu78pCVJkiRJkjBJIkmSJEmSBLjcRpIkSZKkgUwQJkin86kbVpJIkiRJkiRhJYkkSZIkSQOxcev48pOWJEmSJEnCShJJkiRJkgYyQbd9QiY6m0lWkkiSJEmSJGGSRJIkSZIkCXC5jSRJkiRJA7Fx6/jyk5YkSZIkScJKEkmSJEmSBjJRK5josLqjy7mWOz9pSZIkSZIkTJJIkiRJkiQBLreRJEmSJGkgRZgknc6nblhJIkmSJEmShJUkkiRJkiQNxMat48tPWpIkSZIkCStJJEmSJEkayGSFyequT0iXcy13Y5kkWeuyNVhjrTVGHYYW2PUbTY46BHVp0v8xLBdfedN7Rh2COvLwz7x21CGoIzds/NdRh6AOrbhqLH/EUL8adQDSwnC5jSRJkiRJEmNaSSJJkiRJ0kKZYAUTHdYcdDnXcucnLUmSJEmShJUkkiRJkiQNxMat48tKEkmSJEmSJEySSJIkSZIkAS63kSRJkiRpIJOsYLLDmoMu51ru/KQlSZIkSZKwkkSSJEmSpIFMVJjosJlql3Mtd1aSSJIkSZIkYSWJJEmSJEkDcQvg8WUliSRJkiRJEiZJJEmSJEmSAJfbSJIkSZI0kKoVTFZ3NQfV4VzLnZ+0JEmSJEkSVpJIkiRJkjSQCcIEHW4B3OFcy52VJJIkSZIkSZgkkSRJkiRJAlxuI0mSJEnSQCYLJqu7JTCT1dlUy56VJJIkSZIkSVhJIkmSJEnSQCY73gK4y7mWOz9pSZIkSZIkTJJIkiRJkiQBLreRJEmSJGkgk4RJOmzc2uFcy52VJJIkSZIkSVhJIkmSJEnSQCYqTHS4BXCXcy13VpJIkiRJkjRGkuydpPqOM3vOr53kgCR/THJ1kiOTbNp3jy2TfDXJNUkuSfKeJGNfaDH2b1CSJEmSpPm0RLYAPh3Yoef5DT2//gDwOODpwBXA/sAXgIcAJFkD+CpwEfBg4LbAocBfgTcOE8xSYZJEkiRJkqTxc0NVXdQ/mGRD4AXArlX1nXZsd+CXSbatqv8DdgLuAexQVRcDP0/yZuBdSfauquu7exvdcrmNJEmSJElLw/pJNug51lrFtVsluSDJb5N8OsmW7fj9gJsDx05dWFVnAr8HtmuHtgNObRMkU44BNgDuOW/vZhGykkSSJEmSpAFMEiY7bKbaswXw+X2n9gH2nuYlJwC7Ab+iWSqzF/CDJPcCNgOur6rL+15zcXuO9vHiac7Tc81YMkkiSZIkSdLSsAVwVc/zldNdVFVf73l6SpITgN8B/wJcu3DhLX0mSSRJkiRJGkCR3uqOTuZrXVVVVw78+qrLk/wauAvwLWDNJBv1VZNsStOolfbxgX232bTn3NiyJ4kkSZIkSWMsyXrAnYELgZNodql5dM/5uwFbAse3Q8cD906ySc9tdgSuBM7oIuZRsZJEkiRJkqQxkuS9wNE0S2w2p+ldMgF8pqquSPJx4P1J/kST+PgwcHy7sw3AN2mSIf+b5HU0fUjeDhxQVdMu8RkXJkkkSZIkSRrAZHXcuHXwubYAPgNsDFwK/BDYtqoubc//JzAJHAmsRbNzzb9PvbiqJpI8HvgoTVXJX4BDgLcM/y6WBpMkkiRJkiSNkap65mrOXwe8tD1muuZ3wGPnObRFzySJJEmSJEkDmKwVTFZ3LT67nGu585OWJEmSJEnCShJJkiRJkgayBHqSaEhWkkiSJEmSJGGSRJIkSZIkCXC5jSRJkiRJA5kkTNLhcpsO51rurCSRJEmSJEnCShJJkiRJkgZi49bxZSWJJEmSJEkSJkkkSZIkSZIAl9tIkiRJkjQQl9uMLytJJEmSJEmSsJJEkiRJkqSBWEkyvqwkkSRJkiRJwkoSSZIkSZIGYiXJ+LKSRJIkSZIkCZMkkiRJkiRJgMttJEmSJEkaSAGTdLcEpjqbSVaSSJIkSZIkYSWJJEmSJEkDsXHr+FpUlSRJHp7k6CQXJKkkTx51TJIkSZIkaXlYVEkSYF3gF8BLRx2IJEmSJElaXhbVcpuq+jrwdYDEciJJkiRJ0uLjcpvxtaiSJINKshawVs/Q+qOKRZIkSZIkLW1LOkkC7AnsNeogJEmSJEnLh5Uk42ux9SQZ1L7Ahj3HFqMNR5IkSZIkLVVLupKkqlYCK6ee28dEkiRJkrTQrCQZX0u9kkSSJEmSJGleLKpKkiTrAXfpGbpjkm2AP1XV70cTlSRJkiRJWg4WVZIEuD/w3Z7n728fDwF26zwaSZIkSZL6VIXqcAlMl3Mtd4sqSVJVxwF++5IkSZIkqXOLKkkiSZIkSdJiN0mY7PDf97uca7mzcaskSZIkSRImSSRJkiRJkgCX20iSJEmSNJDJCpMdNlPtcq7lzkoSSZIkSZIkrCSRJEmSJGkgbgE8vqwkkSRJkiRJwkoSSZIkSZIGYk+S8WUliSRJkiRJEiZJJEmSJEmSAJfbSJIkSZI0EBu3ji8rSSRJkiRJkrCSRJIkSZKkgVTHjVutJOmOlSSSJEmSJEmYJJEkSZIkSQJcbiNJkiRJ0kAKqOp2PnXDShJJkiRJkiSsJJEkSZIkaSCThNBdM9XJDuda7qwkkSRJkiRJwkoSSZIkSZIGUpVOt+V1C+DuWEkiSZIkSZKESRJJkiRJkiTA5TaSJEmSJA1kskI6XAIz6XKbzlhJIkmSJEmShJUkkiRJkiQNpKo5upxP3bCSRJIkSZIkCZMkkiRJkiRJgMttJEmSJEkaSFWoDpupdjnXcmcliSRJkiRJElaSSJIkSZI0ECtJxpeVJJIkSZIkSZgkkSRJkiRJAlxuI0mSJEnSQCYrpMMlMJMut+mMlSSSJEmSJElYSSJJkiRJ0kCqmqPL+dQNK0kkSZIkSRojSfZM8tMkVyW5JMmXktyt75rjklTf8d9912yZ5KtJrmnv854kY11sMdZvTpIkSZKk+dZUknS5BfDAL3kEcADwU5qf+98BfDPJParqLz3XfQx4S8/za6Z+kWQN4KvARcCDgdsChwJ/Bd44cERLhEkSSZIkSZLGSFXt0vs8yW7AJcD9gO/3nLqmqi6a4TY7AfcAdqiqi4GfJ3kz8K4ke1fV9fMf+ei53EaSJEmSpKVh/SQb9BxrzfJ1G7aPf+obf3aSy5KclmTfJOv0nNsOOLVNkEw5BtgAuOdw4S9+VpJIkiRJkjSAqnS83OZvc53fd2ofYO9VvTbJCmA/4EdVdVrPqcOA3wEXAPcB3gXcDXhqe34zoDdBQs/zzWYd/BJjkkSSJEmSpKVhC+CqnucrZ/GaA4B7AQ/tHayqg3qenprkQuDbSe5cVWfPOdIlyiSJJEmSJEkDqPbocr7WVVV15Wxfl2R/4PHAw6uqvwql3wnt412As2katj6w75pN28eZ+pgsefYkkSRJkiRpjKSxP/AU4FFVdc4sXrZN+3hh+3g8cO8km/RcsyNwJXDGfMW62CxYJUmSNapqYqHuL0mSJEmSpnUAsCvwJOCqJFM9RK6oqmuT3Lk9/zXgjzQ9ST4AfL+qTmmv/SZNMuR/k7yOpg/J24EDqmo2y3yWpKEqSZJ8JslGqzh/H5r9mCVJkiRJGitTjVu7PAb0EpodbY6jqQyZOp7Rnr8e2IEmEXIm8D7gSOAJf3+PNUGzVGeCpqrkU8ChwFuG+9SWhmErSZ4IPDzJHlX1lanBtmvuG4H/R9MhV5IkSZIkdahWk1WpqvOAR8ziPr8DHjtfcS0Fw/Yk+UfgHODLST7Z7s98D5pGL2+lyS7dZ55ilCRJkiRp8agRHOrEUJUkVXVWkocBr6ZJiuwM3BK4FHhMVR0zfyFKkiRJkiQtvKEbt1ZVJfkS8Bz+XjXyaZo1TZIkSZIkjafh+oTMaT51Y+gtgJO8DDgZuDXwdODjwOuBHyXZan7CkyRJkiRJ6sawu9t8B/gQcBRw76o6sqpeSNPQZUvg50leMX9hSpIkSZIkLaxhK0nuBTy9qp5dVX+eGqyqbwD3BI4A3j8P8UmSJEmStKhUdX+oG8P2JLlnVV063YmqugJ4XpIjhg9LkiRJkiSpW8PubjNtgqTvmqOHubckSZIkSYtZddy4tdMmscvcrJIkSf51mJtX1aHDvG6urt9okhVrT45ianXJ/04sL7HGcLl48NdeNeoQ1JEVa/rnerlYcfXQGypKktSp2f4f6+Bpxqb+ZtP/o2rv33hGkiSRJEmSJEka1GyTJHfse74RcAhwBfBh4Fft+NbAy4H1gefNQ3ySJEmSJC0ulebocj51YlZJkqr6Xe/zJHsDlwI7Vd2oz+6pSY4Evgn8J7D7PMUpSZIkSZIEQJLbApsAZ1XVX+brvsNuAfxk4It9CRIAqmoS+ALwpDnEJUmSJEnSouQWwKOT5ElJzgTOB34GPKgdv3WSk5M8eS73HzZJEpqlNTO5B7bVlCRJkiRJ8yTJE2iKMi4D9qEn71BVlwF/YI4rWoZNknwJeEmSVyVZZ2owyTpJXg3sAXx5LoFJkiRJkrQo1QgOAbwF+H5VPRQ4YJrzxwP/NJcJht2P7RU0zVzfC+yb5MJ2/LbAzYEfAa+cS2CSJEmSJEk97gW8ahXnL6bpUzK0oZIkVXUF8IgkTwIeA9y+PfUN4GvA0dP1K5EkSZIkSRrSNcC6qzh/J+CPc5lg2EoSAKrqy7isRpIkSZK0jFSF6nBb3i7nWuS+CzwvyX79J5JsBrwQ+MpcJhi2J4kkSZIkSVKX3gRsAfyUphdqATsneTtwKk0j133mMsGsKkmSnANMAltX1V/b56tbTlNVdee5BCdJkiRJ0qJkg4nOVdWvkjwU+CDwNpqkyGvb08cBL62qc+cyx2yX23yP5rfAZN9zSZIkSZKkTlTV6cAOSW4J3IVmhcxvq+rS+bj/rJIkVbXbqp5LkiRJkiR1par+TLPsZl7NqXGrJEmSJEnLjY1bRyPJv87muqo6dNg5TJJIkiRJkqSl4OBVnOttCWKSRJIkSZKkThTddum0I+iUO04ztgZwB+DfgS2B581lApMkkiRJkiRp0auq381w6rfAd5J8FXgZ8NJh51gx7AslSZIkSVqeMoJDs/AV4BlzuYFJEkmSJEmSNA7uDKw1lxsMtdwmyfrARlV1Xs/Y5sCL24COrKqfzCUwSZIkSZKkKUkePsOpjYCHA/8BfGkucwzbk+QgmoYp2wIk2QD4P2ALYBJ4RZJdquq4uQQnSZIkSdKiY+PWUTmO6T+NABPA4cDL5zLBsEmShwIH9jx/DrA58GDgdODbwP+jeQOSJEmSJElz9chpxgr4M/C7qrpyrhMMmyS5NfCHnudPBH5YVf8HkORQYK85xiZJkiRJ0uJjJclIVNX3FnqOYRu3Xg5sBpDkFsDDgG/2nL8BWGdOkUmSJEmSJHVo2EqSHwP/nuRMYBdgbeDLPefvyo0rTSRJkiRJkmYtyTkMXkdTVXXnYeccNknyeprKkSPb5++rqtMBkqwBPB34xrBBSZIkSZK0aFWao8v5lqfv0fFio6GSJFV1VpK7AfcArqiqc3tOrwO8DPjF3MOTJEmSJEnLUVXt1vWcw1aSUFV/ZZpESFVdxY2X3kiSJEmSNDaqmqPL+dSNoZMkSTYA/p1mC55NgD2q6idJbgXsBhxVVWfNS5SSJEmSJElAkpsDWwMbMs2GNFX1/WHvPVSSJMkWNGuD/gH4TRvcem0wf0qyB3B74BXDBiZJkiRJ0qLkFsAjkWQFsC9NwcaqdtRdY9g5ht0C+D3A+sA2wCOA/i4yXwJ2GDYoSZIkSZKkPm8EXgt8CvhXmlzEG4AXA6fQtATZeS4TDJsk2Qn4UFWdwfQ5rd/SVJlIkiRJkiTNh92Az1fVS/j7jronVdXHgAfR5CceNZcJhk2S3AK4dBXn1x/yvpIkSZIkLW5TWwB3eQhgC+A77a9Xto9rA1TV9TQVJs+dywTDJknOAB6+ivNPBk4e8t6SJEmSJEn9/sjf+6FeDVwJ3KnvmlvOZYJhd7fZDzgkySnA4e3YiiR3AfYCtgP+eS6BSZIkSZK0GKWao8v5BDTFGA/oef5d4JVJTqYpAvkPmr4kQxsqSVJVn0pye+DtwH+1w9+gaZoyCbyxqr40l8AkSZIkSZJ6HATslmStqloJvAn4fnsE+DPwrLlMMGwlCVX1X0n+l6Zi5C40WZuzgS9U1W/nEpQkSZIkSVKvqjoKOKrn+RlJ7gxsD0wAP66qP81ljqGTJG1Avwc+MJd7SJIkSZK0pBTT7/O6kPOJJKmqG30aVXUF8OX5mmPYxq2SJEmSJEld+kOSDyZ58EJNMKtKkiSTDJ67qqqaU6WKJEmSJEmLTtfb8roF8JTvAc8HXpbkD8Dngc9X1U/ma4LZJjHeigU+kiRJkiRpRKrqWUluATweeAbwEuA/k5wLfI4mYfLzucwxqyRJVe09l0kkSZIkSRob9iQZmaq6FjgcODzJusATaRIm/wm8PslvqmrrYe9vTxJJkiRJkrTkVNVfquozwHOA1wJXA1vN5Z5DJ0mS3CbJe5OckeSa9jijHdt0LkFJkiRJkiTNJMk6SZ6Z5AvAJcAHgYuBd8zlvkM1Vk1yT+DbwCbACTSlLgB3BV4FPDfJo6vqtLkEJ0mSJEnSouNym5FIsjbwOJrlNY8F1gHOBT4EfK6qTp7rHMPuPnMAsAbwoKr6ae+JJA8EvgZ8GHjk3MKTJEmSJEkC4FKaxMgFwEE0iZET5nOCYZMkDwTe0Z8gAaiqnyT5ILDnnCKTJEmSJGkxspJkVA6mSYz8cKEmGDZJcglw3SrOX9deI0mSJEmSNGdV9fKFnmPYxq37AS9Jsln/iSSb0+xVvN/wYUmSJEmSJHVr2EqSFTRb65yV5IvAWe34VsCT2+crkryq5zVVVR8YNlBJkiRJkhaFSnN0OZ86MWyS5L09v372NOfv03cNNKuoTJJIkiRJkqRFadgkyR3nNQpJkiRJkpaIVHN0OZ+6MVSSpKp+N9+BSJIkSZIkjdKwlSSSJEmSJEmdS7It8EhgE+AjVfWbJOsAWwO/rqqrh7330EmSJM8Bng/cCbgl0N9Jpqpqw2HvL0mSJEnSolTt0eV8IsmawGeBJ9HkIAo4GvgNMAl8k6YX6n8NO8dQSZIk7wJeA/wBOBG4YtgAJEmSJEmSZuFtwOOBlwDfBX41daKqrktyOE0CpdskCfBC4CvAU6pqctjJJUmSJEmSZulZwEer6qAkG09z/pfA0+cywYo5vPZr850gSbJnkp8muSrJJUm+lORu8zmHJEmSJEnLQZKXJjk3yXVJTkjywFHHNEebAKeu4vwEsM5cJhg2SfIV4KFzmXgGjwAOALYFdgRuDnwzyboLMJckSZIkSQMLf98GuJNjmBiTZwDvB/YB7gv8AjgmySbz+FF07Tya5qwzeQhw1lwmGDZJ8nLg9kn2T3LfJLdJcqv+Y9CbVtUuVXVwVZ1eVb8AdgO2BO43ZJySJEmSJC1HrwI+VlWfrKozgBcD19BswLJUHQbskWS7nrECSPJC4F+AQ+cywbA9Sf4C/Bh4LU3DlJmsMeT9p0ztjvOn6U4mWQtYq2do/TnOJ0mSJEnSYrV+cqO6kpVVtbL/onYXmPsB+06NVdVkkmOB7fqvX0L+i2blyfdp+o8U8IG2SGML4Gs0u9sMbdgkyf40zVv/DziBBdjdJskKYD/gR1V12gyX7QnsNd9zS5IkSZI0o0pzdDlf4/y+M/sAe0/zilvTFC1c3Dd+MaterrKoVdX1SXYBng08jeY9rgWcAvw/4H+rak4bJg+bJHlGO/luc5l8NQ4A7sWqe5/sS7PGasr63PQ3jSRJkiRJ42AL4Kqe5zepIhl3bRLkU+0x74ZNkvyVpopkQSTZn2bv44dX1YxJj7asaGXP6xYqJEmSJEmSGtUeXc7XuKqqrpzFKy6j2ell077xTYGL5i+wbk0tq6mqU2Y4f2/g/Kr687BzDNu49bPAE4addCZp7A88BXhUVZ0z33NIkiRJkjTOqup64CTg0VNjbUuLRwPHjyquefAB4KBVnD8QeO9cJhi2kuRzwIeTfBX4BPB7mizVjVTVzwa87wHArsCTgKuSbNaOX1FV1w4ZqyRJkiRJy837gUOSnAj8BHglsC7wyVEGNUePAj66ivNH0+ziM7RhkyQ/aB+3AXaZ5nxoCoIG3d1maqec4/rGdwcOHvBekiRJkiTNv9Ett5n9S6o+l+Q2wFuBzYCfA7tUVX8z16XkNjRLiWbyR2CTuUwwbJJk97lMOpOqLtsDS5IkSZI0vqpqf5rdacfFhcA/reL8/YBL5zLBUEmSqjpkLpNKkiRJkrRUpZqjy/kEwJeAlyb5elUd1XsiyZNoCjpWtRxntYatJJEkSZIkSerS3sAOwBeT/AI4rR2/F/CPwC+BveYywdBJkiRrA/8M3BfYkJvulFNV9YI5xCZJkiRJ0uKzBHqSjKOquiLJtsDrgKcCT2tPnQ28DXhPVf1lLnMMlSRJcnvgu8AdgMtpkiR/AjaiadZ6GXD1XAKTJEmSJEnq1SZB9mKOFSMz6a/+mK330CRGtgXuSrObzTOA9YDXA9cCO89HgJIkSZIkSV0YdrnNo4CPVNVPktyqHUtVrQTek+TuwH7A4+YhRkmSJEmSFg+X24xMm2/YHbgTcEuaoo1eVVWPHvb+w1aSrAOc2/76SpqvbMOe88cDDx02KEmSJEmSpF5JngucCrwcuAtNTiN9x7B5DmD4SpLfA1sAVNUNSf5As/TmC+35ewDXzSUwSZIkSZIWI7cAHpm9gZOBx1TVZQsxwbBJku8ATwL2aZ8fDOyZ5JY0WZvnAofOOTpJkiRJkqTG5sB7FypBAsMnSd4JPCDJWm0fknfQBPs0YAI4DHj1/IQoSZIkSZLEKTS5hwUzVJKkqn5Ps+Rm6vl1wL+1hyRJkiRJ46vSHF3OJ4BXAYcn+XpV/XghJhgqSZLkFlV17WquuX1V/W64sCRJkiRJkm7k9cAVwA+SnEFTvDHRd01V1ZOGnWDY5TanJNmtqn403ckkLwHeBWwwbGCSJEmSJC1KbgE8Kveh+TR+D6xHs2lMvzl9WsMmSa4DvpdkP+BNbV8SkvwD8HFgB+CLcwlMkiRJkiRpSlXdYaHnGHb/4PsC7wFeAZyc5EFJ/g04Dbgf8Jyq+ud5ilGSJEmSpEVjagvgLg91Y6gkSVX9tar2BB4KrAH8GDgQOA64Z1UdNm8RSpIkSZIkAUnWSPLMJAcm+WKSe7fjGyZ5apJN53L/YStJptwJuDVwPRBgzfZRkiRJkiRp3iTZCPgRcBjwLOCJwG3a01cDH6JZ8TK0oZIkSW6d5Ajg08AJwJ2B5wIPBE5P8py5BCVJkiRJ0qJVIzgE8E7gnsDONEUbfyvSqKoJ4AjgsXOZYNhKkjOAnYA9quqxVXVBVX0auBfN0ptDk9i4VZIkSZIkzZcnAx+uqm8xfero18Ad5jLBsLvbnAY8v6rO7R2sqguBxyfZHXj/XAKTJEmSJGlR6rqZqpUkUzYEzlnF+ZszfJ4Dhn1xVT1qNec/meSbw4UkSZIkSZJ0E2fT7LY7k51oVr4MbU6NW5PcLsmzkrwiyRbt2BpJbgVcNJd7S5IkSZIk9fgf4PlJnsHf+5FUkrWS/BewC83Ou0MbqpIkSYD3AS9r71HAqcD5wHrAucBbgP3mEpwkSZIkSYtO181UXW4z5YM0jVs/A1zejh0GbEyTmziwqj4+lwmGrSR5Lc22Ou8FduTGHWWvAL4A/PNcApMkSZIkSZpSjRcCDwcOBb4O/Bw4CNi+ql4y1zmGbWjyQuDQqnpjko2nOX8K8Jjhw5IkSZIkaZGykmSkquqHwA8X4t7DVpL8A81WvzP5C7DBkPeWJEmSJEnq3LCVJJfQJEpmcj/g90PeW5IkSZKkRSsdbwHc6XbDi1iSc1h9XU1V1Z2HnWPYJMkXgBcnORi4YioQgCQ7AbsB7x42KEmSJEmSpD7f46ZJkjWA2wMPAU4DTp7LBMMmSfYCHknTIOUHNEG+PsnbgO3aoN4xl8AkSZIkSZKmVNVuM51L8o/AMcCn5zLHUD1J2h1stqWpFrkdcB3wCGAjYB/gYVV1zVwCkyRJkiRJmo2q+gVwIPCuudxn2EoSqupa4O3tIUmSJEmSNEoXA/eYyw2GTpJIkiRJkrQsuQXwopNkY+AFwPlzuY9JEkmSJEmStOgl+c4MpzYCtgbWBJ47lzlMkkiSJEmSpKVgBTetqyngHOBY4BNVdeZcJjBJIkmSJEnSAFLN0eV8gqrafqHnGGp3G0mSJEmSpHEzVCVJkrcAX6iq02Y4f0/gn6vqrXMJTpIkSZKkRcnqjgWX5F+HeV1VHTrsnMMut9kbOAuYNkkC3AvYCzBJIkmSJEmShnHwEK8poPMkyercCrh+ge4tSZIkSdLouAVwV+7Y9YSzTpIkeTiwfc/QU5PcZZpLNwKeAZw6p8gkSZIkSdJy9grgf6vqZIAkWwKXVtW1CzXhIJUkj6RZQgNNHuup7TGdM4CXzyEuSZIkSZK0vL0SOBE4uX1+DvBc4LCFmnCQJMm7gf2BAJcALwaO7LumgGuq6rr5CU+SJEmSpMXFLYA7czFwp57nWegJZ50kactZrgVIckeaEpdrFiowSZIkSZK0rH0VeEuSnYDL27FXJ3nmKl5TVfWkYSccqnFrVf2ufyzJOsAzgbWAr013jSRJkiRJS56NW7vyCpqVLI8E7knzSfwDzWYxM5nTpzVUkiTJx4EHVdW92udrAv9Hs/UvwBVJHjXVXEWSJEmSJGkQVfUX4I1Tz5NMAq+sqgXrSbJiyNc9EvhCz/NdaRIkz24fL+LvTV4lSZIkSZLm6pHAtxZygqEqSYDNgHN7nj8ZOLGqPgOQ5GPAa+cUmSRJkiRJi5CNW0ejqr630HMMW0nyF2AjgCQ3A7YHjuk5fxWw4VwCkyRJkiRJmpLGHkl+kuSyJBPTHDfMZY5hK0l+BrwwyXeBJwLrA0f3nL8zzVY9kiRJkiSNFxu3jsq7gVcBPwc+Bfx5vicYNknyJprKkRNp9ik+oqp+0nP+KcCP5hibJEmSJEnSlOcBR1bVvyzUBMNuAXxikq2BBwOX964LSrIR8BFgwdcKSZIkSZLUOStJRuUWwLELOcGwlSRU1aXAl6cZvxz44BxikiRJkiRJ6vdt4AHAQQs1wbCNW0myRpJnJjkwyReT3Lsd3zDJU5NsOn9hSpIkSZKkZe7fgW2TvDHJxgsxwVCVJO2Smm8ADwSuBtYFPtyevhr4EHAo8Ma5hyhJkiRJ0uLhFsAj8yuaYo+3AW9Lch0w0XdNVdXQu+0Ou9zmncA9gZ2Bk4FLeqKZSHIE8FhGlSRJe0gaH/6ZXjZWXDt0kaOkxcq/3EuS5seRLPD/VYZNkjwZ+HBVfWuGEpdfA7sNG5QkSZIkSYuWjVtHoqp2W+g5hv3nug2Bc1Zx/ubMoSmsJEmSJElS14ZNZJwN3HcV53cCzhjy3pIkSZIkSSRZVe5hWlX1s2Hnm3WSJMnDgV+2W//+D/CuJMfRbMEDUEnWAt4C7AK8aNigJEmSJElatFxu06UTmf0nkPbaNYadbJBKku8CzwUOAz5I07j1M8Dl7fnDgI3bex5YVR8fNihJkiRJkiRg9y4nGyRJ8re9JaqqgBcmOQR4GrAVTX+Ts4HPV9X35zVKSZIkSZIWCbcA7k5VHdLlfHNqrlpVPwR+OE+xSJIkSZIkjcygu9ss4/yVJEmSJEkaZ4MmST6VZGKWxw0LErEkSZIkSaNUIzjUiUGX2xwL/HohApEkSZIkSRqlQZMkh1TVYQsSiSRJkiRJS4CNW8fXoMttJEmSJEnSmEhyhyQfT3JOkmuTnJ1knyRr9l1T0xzb9t3r6UnOTHJdklOTPLb7dzQ3c9rdRpIkSZKkZafrPiELO9fWNAUUewBnAfcCPgasC7ym79odgNN7nv9x6hdJHgx8BtgT+AqwK/ClJPetqtMWLPp5ZpJEkiRJkqRlqqq+AXyjZ+i3Se4GvISbJkn+WFUXzXCrVwDfqKr3tM/fnGRH4GXAi+cz5oU06+U2VbXCfiSSJEmSJI3M+kk26DnWWqB5NgT+NM34UUkuSfLDJE/sO7cdzWYvvY5px5cMe5JIkiRJkjSI0W0BfD5wRc+x53y/tSR3AV4OHNgzfDXwauDpwOOAH9IspelNlGwGXNx3u4vb8SXD5TaSJEmSJC0NWwBX9TxfOdOFSd4JvH4197t7VZ3Z85rb0Sy9ObyqPjY1XlWXAe/ved1Pk2wOvBY4avbhL34mSSRJkiRJGkDao8v5WldV1ZWzfNn7gINXc81v/zZHk/T4LvBj4EWzuP8JwI49zy8CNu27ZtN2fMkwSSJJkiRJ0pipqkuBS2dzbVtB8l3gJGD3qpqcxcu2AS7seX488Ghgv56xHdvxJcMkiSRJkiRJy1SbIDkO+B3Nbja3SZralamdbJI8D7geOLl92VOB5wP/1nOrDwLfS/Jq4KvAM4H7M7uqlEXDJIkkSZIkSYO4cTPVbuZbODsCd2mP8/vO9a4qejNwe+AG4EzgGVV1xN9CrPpxkl2BtwPvAH4DPLmqTlvA2OedSRJJkiRJkpapqjqY1fQuqapDgENmca/DgcPnJbARMUkiSZIkSdIAUs3R5XzqxopRByBJkiRJkrQYWEkiSZIkSdIgxqsniXpYSSJJkiRJkoRJEkmSJEmSJMDlNpIkSZIkDc4lMGPJShJJkiRJkiSsJJEkSZIkaSBuATy+rCSRJEmSJEnCJIkkSZIkSRLgchtJkiRJkgZTdNu41eU2nbGSRJIkSZIkCStJJEmSJEkaiI1bx5eVJJIkSZIkSVhJIkmSJEnSYOxJMrasJJEkSZIkScIkiSRJkiRJEuByG0mSJEmSBmLj1vFlJYkkSZIkSRJWkkiSJEmSNBgbt44tK0kkSZIkSZIwSSJJkiRJkgS43EaSJEmSpMG43GZsWUkiSZIkSZKElSSSJEmSJA3ELYDHl5UkkiRJkiRJWEkiSZIkSdJg7EkytqwkkSRJkiRJwiSJJEmSJEkS4HIbSZIkSZIGkipS3a2B6XKu5c5KEkmSJEmSJKwkkSRJkiRpMDZuHVtWkkiSJEmSJGGSRJIkSZIkCXC5jSRJkiRJA0k1R5fzqRuLqpIkyUuSnJLkyvY4PsljRh2XJEmSJEkaf4utkuR84A3Ab4AAzwO+nOSfqur0kUYmSZIkSRLYuHWMLaokSVUd3Tf0piQvAbYFTJJIkiRJkqQFs6iSJL2SrAE8HVgXOH6Ga9YC1uoZWr+D0CRJkiRJy5g9ScbXoupJApDk3kmuBlYC/w08parOmOHyPYEreo7zu4lSkiRJkiSNm0WXJAF+BWwDPAj4KHBIknvMcO2+wIY9xxZdBChJkiRJksbPoltuU1XXA2e1T09K8gDgFcAe01y7kqbiBIAkncQoSZIkSVrGbNw6thZjJUm/Fdy474gkSZIkSdK8W1SVJEn2Bb4O/J6mCeuuwPbAziMMS5IkSZKkv7Fx6/haVEkSYBPgUOC2NI1YTwF2rqpvjTQqSZIkSZI09hZVkqSqXjDqGCRJkiRJ0vK0qJIkkiRJkiQtejZuHVtLoXGrJEmSJEnSgrOSRJIkSZKkAdlMdTxZSSJJkiRJkoSVJJIkSZIkDaaqObqcT52wkkSSJEmSJAmTJJIkSZIkSYDLbSRJkiRJGkiq28atNontjpUkkiRJkiRJWEkiSZIkSdJgqj26nE+dsJJEkiRJkiQJkySSJEmSJEmAy20kSZIkSRpIJpujy/nUDStJJEmSJEmSsJJEkiRJkqTB2Lh1bFlJIkmSJEmShEkSSZIkSZIkwOU2kiRJkiQNJNUcXc6nblhJIkmSJEmShJUkkiRJkiQNpqo5upxPnbCSRJIkSZKkZSzJuUmq73hD3zX3SfKDJNclOS/J66a5z9OTnNlec2qSx3b3LuaHlSSSJEmSJA1gTHuSvAX4WM/zq/42f7IB8E3gWODFwL2BTyS5vKoOaq95MPAZYE/gK8CuwJeS3LeqTuvkHcwDkySSJEmSJOmqqrpohnPPBtYEnl9V1wOnJ9kGeBVwUHvNK4BvVNV72udvTrIj8DKaxMqS4HIbSZIkSZKWhvWTbNBzrDWP935Dkj8mOTnJa5P0FlVsB3y/TZBMOQa4W5Jb9lxzbN89j2nHlwwrSSRJkiRJGkS1R5fzNc7vO7MPsPc8zPAh4GfAn4AHA/sCt6WpFAHYDDin7zUX95z7c/t48TTXbDYP8XXGJIkkSZIkSUvDFvT0CgFWznRhkncCr1/N/e5eVWdW1ft7xk5Jcj1wYJI9q2rGOcaRSRJJkiRJkgYwwsatV1XVlbN82fuAg1dzzW9nGD+BJl9wB+BXwEXApn3XTD2/qOdxumtm6nOyKJkkkSRJkiRpzFTVpcClQ758G2ASuKR9fjzwX0luXlV/bcd2BH5VVX/uuebRwH4999mxHV8ybNwqSZIkSdIylWS7JK9M8o9J7pTk2cAHgE/1JEAOA64HPp7knkmeQbObTe8ynQ8CuyR5dZKtk+wN3B/Yv7t3M3dWkkiSJEmSNIiq5uhyvoWzEngmTQPYtWgatH6AngRIVV2RZCfgAOAk4DLgrVV1UM81P06yK/B24B3Ab4AnV9VpCxn8fDNJIkmSJEnSMlVVPwO2ncV1pwAPW801hwOHz1NoI2GSRJIkSZKkAYywcasWmD1JJEmSJEmSsJJEkiRJkqTBVHt0OZ86YSWJJEmSJEkSJkkkSZIkSZIAl9tIkiRJkjQQG7eOLytJJEmSJEmSsJJEkiRJkqTBTFZzdDmfOmEliSRJkiRJEiZJJEmSJEmSAJfbSJIkSZI0mGqPLudTJ6wkkSRJkiRJwkoSSZIkSZIGEjreAri7qZY9K0kkSZIkSZKwkkSSJEmSpMFUNUeX86kTVpJIkiRJkiRhkkSSJEmSJAlwuY0kSZIkSQNJddy41dU2nbGSRJIkSZIkCStJJEmSJEkaTLVHl/OpE1aSSJIkSZIkYZJEkiRJkiQJcLmNJEmSJEkDSRWp7tbAdDnXcmcliSRJkiRJEmNaSfLuXT7NOuuvMeowtMDe/pvHjToEdejOG/5x1CGoI5c++PJRh6COXHvMHUcdgjpy0UmbjToEdeiG260cdQjqQF17/ahDGK3J9uhyPnXCShJJkiRJkiTGtJJEkiRJkqSFYk+S8WUliSRJkiRJEiZJJEmSJEmSAJfbSJIkSZI0mGqPLudTJ6wkkSRJkiRJwkoSSZIkSZIGU9UcXc6nTlhJIkmSJEmShEkSSZIkSZIkwOU2kiRJkiQNJNUcXc6nblhJIkmSJEmShJUkkiRJkiQNxsatY8tKEkmSJEmSJKwkkSRJkiRpIJlsji7nUzesJJEkSZIkScIkiSRJkiRJEuByG0mSJEmSBmPj1rFlJYkkSZIkSRJWkkiSJEmSNJhqjy7nUyesJJEkSZIkScIkiSRJkiRJEuByG0mSJEmSBpIq0mEz1S7nWu6sJJEkSZIkScJKEkmSJEmSBuMWwGPLShJJkiRJkiSsJJEkSZIkaTAFTHY8nzphJYkkSZIkSRImSSRJkiRJkgCX20iSJEmSNBC3AB5fVpJIkiRJkiRhJYkkSZIkSYMpOt4CuLupljsrSSRJkiRJkjBJIkmSJEmSBLjcRpIkSZKkwVR1vNzG9TZdsZJEkiRJkiQJK0kkSZIkSRrMJJCO51MnrCSRJEmSJEnCJIkkSZIkSRLgchtJkiRJkgaSKtJhM9Uu51rurCSRJEmSJEnCShJJkiRJkgbjFsBjy0oSSZIkSZKWqSTbJ6kZjge019xhhvPb9t3r6UnOTHJdklOTPHY072p4VpJIkiRJkjSI8aok+TFw276xtwGPBk7sG98BOL3n+R+nfpHkwcBngD2BrwC7Al9Kct+qOm2+g14oJkkkSZIkSVqmqup64KKp50luDjwJ+HDVTbIzf6yqi5jeK4BvVNV72udvTrIj8DLgxfMc9oJxuY0kSZIkSUvD+kk26DnWWoA5nghsDHxymnNHJbkkyQ+TPLHv3HbAsX1jx7TjS4ZJEkmSJEmSBjG13KbLo3E+cEXPsecCvLsXAMdU1fk9Y1cDrwaeDjwO+CHNUpreRMlmwMV997q4HV8yXG4jSZIkSdLSsAVwVc/zlTNdmOSdwOtXc7+7V9WZPa/ZAtgZ+Jfei6rqMuD9PUM/TbI58FrgqNmFvjSYJJEkSZIkaRCTQDqer3FVVV05y1e9Dzh4Ndf8tu/57jTNWGeT+DgB2LHn+UXApn3XbEpPv5OlwCSJJEmSJEljpqouBS6d7fVJQpMkObSq/jqLl2wDXNjz/HiaHXH26xnbsR1fMkySSJIkSZKkRwF3BP6n/0SS5wHXAye3Q08Fng/8W89lHwS+l+TVwFeBZwL3B160gDHPO5MkkiRJkiQNIFXkJrvjLux8HXgB8OPeHiV93gzcHrgBOBN4RlUdMXWyqn6cZFfg7cA7gN8AT66q0xY27PllkkSSJEmSpGWuqnZdxblDgENmcY/DgcPnM66umSSRJEmSJGkQN96Wt5v51IkVow5AkiRJkiRpMbCSRJIkSZKkQUwWpMPqjkkrSbpiJYkkSZIkSRKLOEmS5A1JKsl+o45FkiRJkiSNv0W53CbJA4A9gFNGHYskSZIkSTdi49axtegqSZKsB3waeCHw5xGHI0mSJEmSlolFlyQBDgC+WlXHru7CJGsl2WDqANZf+PAkSZIkSctb/b2apIsDK0m6sqiW2yR5JnBf4AGzfMmewF4LF5EkSZIkSVouFk0lSZJ/AD4IPLuqrpvly/YFNuw5tlig8CRJkiRJ0phbTJUk9wM2AX6WZGpsDeDhSV4GrFVVE70vqKqVwMqp5z2vkyRJkiRpYdi4dWwtpiTJt4F79419EjgTeFd/gkSSJEmSJGk+LZokSVVdBZzWO5bkL8Afq+q06V8lSZIkSVLHJjtupjppJUlXFk1PEkmSJEmSpFFaNJUk06mq7UcdgyRJkiRJN1KTzdHlfOqElSSSJEmSJEmYJJEkSZIkSQIW+XIbSZIkSZIWHbcAHltWkkiSJEmSJGEliSRJkiRJg3EL4LFlJYkkSZIkSRImSSRJkiRJkgCX20iSJEmSNBgbt44tK0kkSZIkSZKwkkSSJEmSpMEUHVeSdDfVcmcliSRJkiRJElaSSJIkSZI0GHuSjC0rSSRJkiRJkjBJIkmSJEmSBLjcRpIkSZKkwUxOApMdz6cuWEkiSZIkSZKElSSSJEmSJA3Gxq1jy0oSSZIkSZIkTJJIkiRJkiQBLreRJEmSJGkwLrcZW1aSSJIkSZIkYSWJJEmSJEmDmSygw+qOSStJumIliSRJkiRJElaSSJIkSZI0kKpJqiY7nU/dsJJEkiRJkiQJkySSJEmSJEmAy20kSZIkSRpMVbfNVN0CuDNWkkiSJEmSJGEliSRJkiRJg6mOtwC2kqQzVpJIkiRJkiRhkkSSJEmSJAlwuY0kSZIkSYOZnIRMdjdfdTjXMmcliSRJkiRJElaSSJIkSZI0GBu3ji0rSSRJkiRJkrCSRJIkSZKkgdTkJNVhT5KyJ0lnrCSRJEmSJEnCJIkkSZIkSRLgchtJkiRJkgZj49axZSWJJEmSJEkSVpJIkiRJkjSYyYJYSTKOrCSRJEmSJEnCJIkkSZIkSRLgchtJkiRJkgZTBUx2PJ+6YCWJJEmSJEkSVpJIkiRJkjSQmiyqw8atZSVJZ6wkkSRJkiRJwiSJJEmSJEkS4HIbSZIkSZIGU5N027i1w7mWOStJJEmSJEmSsJJEkiRJkqSB2Lh1fFlJIkmSJEnSMpbkTUl+nOSaJJfPcM2WSb7aXnNJkvckuVnfNdsn+VmSlUnOSrLbNPd5aZJzk1yX5IQkD1yYdzUckySSJEmSJA2iJrs/FtaawOHAR6c7mWQN4KvtdQ8GngfsBry155o7ttd8F9gG2A/4nyQ791zzDOD9wD7AfYFfAMck2WSe38/QTJJIkiRJkrSMVdVeVfUB4NQZLtkJuAfwnKr6eVV9HXgz8NIka7bXvBg4p6peXVW/rKr9gSOA/+y5z6uAj1XVJ6vqjPY11wDPX4C3NZSx7ElyzdUTow5BHZj4y8pRh6AO/fVm1486BHXkhvrrqENQR27wv+PLxuR11406BHVo8lr/bC8Hy/17voG/QodtQm7gb38/Wj9J76mVVdXFl7EdcGpVXdwzdgxN5ck9gZPba47te90xNBUltMmU+wH7Tp2sqskkx7avXRTGLUmyPsDzH/rrUcehTvxy1AGoQyeNOgBJ8+8pow5AkjQP1geuHHUQHboeuOiHfG2zEcx9NXB+39g+wN4dzL0ZcHHf2MU951Z1zQZJbgHcElhjhmu2nr9Q52bckiQXAFsAV406kI6tT/OHZTm+9+XG73r58LtePvyulxe/7+XD73r5WM7f9fo0P4MtG1V1Xdt7Y83VXtyNGatIkrwTeP1qXn/3qjpzfkNa2sYqSVLNvkh/GHUcXespt7qqqpZTFnfZ8btePvyulw+/6+XF73v58LtePpb5d73c3i/QJEqApbCO8H3Awau55rezvNdFQP8uNJv2nJt63HSaa66sqmuTTAATM1xzEYvEWCVJJEmSJEkSVNWlwKXzdLvjgTcl2aSqLmnHdqRJlJ3Rc81j+163YztOVV2f5CTg0cCXAJKsaJ/vP09xzplJEkmSJEmSlrEkWwK3ArYE1kiyTXvqrKq6GvgmTTLkf5O8jqb/yNuBA3oax/438LIk7wY+ATwK+BfgcT1TvR84JMmJwE+AVwLrAp9cuHc3GJMk42ElTcOe5d1iennwu14+/K6XD7/r5cXve/nwu14+/K41Dt4KPK/n+cnt4yOB46pqIsnjaXazOR74C3AI8JapF1TVOUkeB3wAeAVNr55/q6pjeq75XJLbtPNtBvwc2KVv15yRStPGQ5IkSZIkaXlbMeoAJEmSJEmSFgOTJJIkSZIkSZgkkSRJkiRJAkySSJIkSZIkASZJlrQkayV5V5ILklyb5IQkO446Ls2/JOsl2SfJN5L8KUkl2W3UcWl+JXlAkv2TnJ7kL0l+n+TzSe466tg0v5LcM8nhSX6b5JoklyX5fpInjDo2Lbwkb2r/O37aqGPR/EqyffvdTndsO+r4NP+S3DfJUe3fz65JclqS/xh1XJKG5xbAS9vBwNOA/YDfALsBX0vyyKr64ejC0gK4Nc32Wr8HfgFsP9JotFBeDzwEOBw4hWZbtJcBP0uybVX5A9X4uD2wPs3WeRcA6wD/DByVZI+qOmiUwWnhJNkCeCPN1okaXx8Cfto3dtYoAtHCSbITcDTNVqlvA64G7gxsMcq4JM2NWwAvUUkeCJwAvLaq3tuOrQ2cBlxSVQ8eZXyaX0nWAm5ZVRcluT/NX7x2r6qDRxuZ5lOSBwMnVtX1PWNbAacCR1TVc0YWnBZckjWAk4C1q2rrUcejhZHks8BtgDWAW1fVvUYckuZRku2B7wJPr6ojRhuNFlKSDYBfAz8GnlZVkyMOSdI8cbnN0vU0YAL42782VtV1wMeB7ZL8w6gC0/yrqpVVddGo49DCqqof9yZI2rHfAKcDdx9NVOpKVU0A5wEbjTgULZAkD6f5//crRxyKOpBk/SRWbY+vXYFNgTdV1WSSdZP4s5U0BvyDvHT9E/Drqrqyb/wn7eM23YYjaSEkCc1fwi4bdSyaf+1fqm+d5M5J/hN4DPDtUcel+ddWCn0Y+J+qOnXU8WjBfRK4ErguyXfbKlCNlx1ovuPbJfkVzVKbK5N8tK3ulrREmd1eum4LXDjN+NTY5h3GImnhPBu4HU1PGo2f9wF7tL+eBL5A04dG4+fFNL1odhh1IFpQ1wNHAl+jSW7fA3gN8IMkD66qk0cZnObVVjQ/S32ZppJ7T5qecS+nqQh81qgCkzQ3JkmWrlsAK6cZv67nvKQlLMnWwAHA8TQNPjV+9gOOoEls/wtNn4o1RxmQ5l+SjYG3Am+rqktHHY8WTlX9mKZHxZSjkhxB04x7X2CXkQSmhbAeTdPt/66qqd1svpBkTWCPJG9pl8xKWmJcbrN0XQusNc342j3nJS1RSTYDvgpcQdMQbmLEIWkBVNWZVXVsVR1aVY+n+Uv30e0yK42PtwN/olluo2Wmqs6iqTZ4ZLvsSuNh6u/an+kbP6x93K7DWCTNI5MkS9eFNEtu+k2NXdBhLJLmUZINga/TlOvuUlX+eV4+jgAeANx11IFofrQ7VL2IZkvYzZPcIckdaP5R4+bt81uNMkZ14jyaKrF1Rx2I5s3U/5sv7hu/pH28ZYexSJpHJkmWrp8Dd223H+v1oJ7zkpaYttnb0TQ/JD++qs4YcUjq1tRSyQ1HGoXm0+1o/r71IeCcnuNBNH/Oz8GeQ8vBnWiWRF896kA0b05qH2/XNz7VF9ClddISZZJk6TqCZu36i6YGkqwF7A6cUFXnjSowScNpy7A/R1Oi+/SqOn7EIWmBJNlkmrGbA/9KU8Jtcmx8nAY8ZZrjdOD37a8/PrLoNK+S3GaasX8Engh8s6omu49KC+Tz7eML+sb/DbgBOK7TaCTNGxu3LlFVdUKSw4F9279snwU8D7gDN/2PtcZAkpfRLL+Y+heKJyTZov31h6vqipEEpvn0Ppq/SB8N3CrJc3pPVtWnRhKVFsKBbSXg94E/AJvR7GS0NfDqqvJfm8dEVV0GfKl/PMkr2/M3Oacl7XNJrqVp3noJze42LwKuAd4wysA0v6rq5CSfAJ6f5GbA92h2t3k6sK9LZaWlK1U16hg0pLYs/23Ac2jWPZ4CvLmqjhlpYFoQSc6l2T5yOnesqnO7i0YLIclxwCNmOl9VNvMcE0meSZPQvjewMXAVTen2h6vqqFHGpm60f95vXVX3GnUsmj9J/oMm4XkXYAOaJRffBvZpG7hqjLQVgG+kqeTeHPgdcEBV7TfKuCTNjUkSSZIkSZIk7EkiSZIkSZIEmCSRJEmSJEkCTJJIkiRJkiQBJkkkSZIkSZIAkySSJEmSJEmASRJJkiRJkiTAJIkkSZIkSRJgkkSSJEmSJAkwSSJJkiRJkgSYJJEkLQJJDk5y7pCv3TtJzXNIaiU5N8nBHc9ZSfaexXV+95IkaV6ZJJEkzaj9YXU2x/ajjlWSJEmaq5uNOgBJ0qL23L7n/wrsOM34L+c4zwsZPnH/duCdc5xfi8stgBtGHYQkSVp+TJJIkmZUVZ/qfZ5kW2DH/vF+SdapqmsGmOevQ4ZIVd2AP1CPlaq6btQxSJKk5cnlNpKkOUlyXJLTktwvyfeTXAO8oz33pCRfTXJBkpVJzk7y5iRr9N3jRj1JktyhXcbzmiQval+3MslPkzyg77U36UvRvnb/JE9uY1uZ5PQku0wT//ZJTkxyXTvPHoP0ukjyoCTfSHJFkmuSfC/JQ3rO3z3JtUkO7XvdQ5NMJHlXz9hsP6+pz/w+7XzXJDkrydPa849IckI776+S7DDdZ5Zk6ySfT3Jlkj8m+WCStWfxnjdKsl+S89o4z0ry+iQr+q57ZpKTklzVznFqklfM4v436UnSfl4/7f2epnnd7u1rn983/sZ2/LGrm1uSJC1vVpJIkubDxsDXgc8CnwIubsd3A64G3t8+Pgp4K7AB8NpZ3HdXYH3gQKCA1wFfSHKnWVSfPBR4KvAR4CrgP4Ajk2xZVX8ESPJPwDeAC4G9gDWAtwCXziI2kjyK5n2fBOwDTAK7A99J8rCq+klV/TLJm4H3JDmiqo5Ksi5wMHBmO9+U3Zj953VL4Cs0n/nhwEuAzyZ5NrAf8N/AYe3rjkjyD1V1Vd89Pg+cC+wJbNt+RrekWVY103teB/gecDua7+X3wIOBfYHbAq9sr9sR+AzwbeD17cvvDjwE+OBM959hznsD36T5Xvam+fvLPvz99xkAVfXJJE8F3p/kW1V1XvvavYCPV9XXBplXkiQtPyZJJEnzYTPgxVV1YN/4rlV1bc/z/07y38C/J/l/VbVyNffdEtiqqv4MkORXwJeBnWkSBKtyd+AeVXV2+9rvAr8AngXs316zDzABPKSqLmiv+zyz6LGSJDSJiO8Cj6mqascPBE6n6ZWyU3v5+4EnAQcl+VE77+2B7fo+g0E+r83b6z/TzvstmqTLYcCDq+qEdvyXwDHAP9MkZnqdU1VPan99QJIr27neW1WnzPDWXwXcGfinqvpNO3ZgkguA1yZ5X1WdBzwOuBLYuaomZrjXbL0VCPCwqvp9+76OBE6d5toX0nz+H0/yeOAQ4KI2bkmSpFVyuY0kaT6sBD7ZP9j7A3+S9ZPcGvgBsA6w9Szu+7mpBEnrB+3jnWbx2mOnEiRtLKfQ/NB+pzaeNYAdgC9NJUja686iqQ5ZnW2ArWiSEhsnuXX7/talqZ54+NTyk6qapKkSWa+9978D+1bVib03HPDzupqmimTqtb8CLgd+OZUgaU39errP7IC+5x9uH1e1LOXpbUx/nnrPbZzH0lTiPLy97nKaz2LHVdxrtdrvaWea7+n3U+NVNZX8uZGqugh4aTvvD2i+p+dX1ZVziUOSJC0PVpJIkubDH6rq+v7BJPekqah4FM2SkV4bzuK+v+99UlV/bgo4uOWgr239uee1m9DsonLWNNdNN9Zvq/bxkFVcs2E7J1V1dttn4z3AacDb+i8e8PM6f6p6pccVwHm9A1V1xSo+s9/0PT+bZsnQHaZ9N42tgPsw85KkTdrHjwD/Anw9yR9olst8vqq+sYp7T+c2NN9Tf6wAv2KahE5VfTbJc2iqWQ6qqm8POKckSVqmTJJIkubDtf0DSTai6V1xJU3fjbOB64D7Au9idtWMMy3TyAK/djam4n8t8PMZrrm67/nU8pvNafq4XPS3oAb/vGZ6f3N537NpVrsC+Bbw7hnO/xqgqi5Jsg1NFchj2mP3JIdW1fNmMc/QkmwM3L99eo8kK9pqHkmSpFUySSJJWijb0yQCnlpV358aTHLHkUV0Y5fQJCHuMs256cb6TS3lubKqjl3dxUleTLME5E00jVIPpOlTMmV7uv+8tgLO6Xl+F5okyLmreM3ZwHqzec9tddHRwNHt0qOPAHskeVu7rGk2LqVJwm01zbm7zfCaA2ga/u5J01D2lTR9YSRJklbJniSSpIUyVdHwtwqGJGvS9OMYubaZ6LHAk5NsPjWe5C40VQ+rcxJNwuA1SdbrP5nkNj2/viPNMpsjq+odwGuAJybp3UVmFJ/XS/uev7x9XFVPls8D2yXZuf9EuzXwzdpfb9x7rq3kmGoGu9ZsA2y/p2Novqcte+a6O02VSn8MTwOeAbyhqt5J07fl7UnuOts5JUnS8mUliSRpofyYph/HIUk+RLOU47nM33KX+bA3zRKYHyX5KE3j0ZfR9AzZZlUvrKrJJP9Gk1A4PckngT/QbI37SJplM09od8H5BE01xEva1x6Y5J+BDyY5tm0cO4rP645JjqLZBnk74DnAYVX1i1W85j3AE4GvJDmYJlm0LnBv4Gk0/UwuA/4nya2A7wDn0+zm83KapUmr3T2oz17ALsAPknyE5u8vL6fZxeY+Uxcl2QT4KM2OQ1M7GL2M5vs4OMlDXXYjSZJWxUoSSdKCqKo/Ao8HLqRpRvoaml4WrxtlXL2q6iSaqpE/0zRSfQFNP5Bv0yzFWd3rj6NJLpxI88P4h2l2sbkI+EB72ctpltK8uKp6m52+gOb/wx9r7zWKz+sZNDsTvZOmyen+bVwzqqprgEfQJEu2Bz4IvIFmOcxeNM1jAT5F8xn+O80ym+cBn6PZLnmgREW7M9HONEtv3go8v53ri32XfpSmSmX3qaa27ef6Iprv6TWDzCtJkpaf3LQxviRJy1uSLwH3rKrp+mAsee0uO3sBt6mqy0YcjiRJ0qJhJYkkaVlLcou+51vRbCt73EgCkiRJ0sjYk0SStNz9tu2t8VuavhkvAa5n5i1uJUmSNKZMkkiSlrtvAM8CNqPpz3E88Maq+s1Io5IkSVLn7EkiSZIkSZKEPUkkSZIkSZIAkySSJEmSJEmASRJJkiRJkiTAJIkkSZIkSRJgkkSSJEmSJAkwSSJJkiRJkgSYJJEkSZIkSQJMkkiSJEmSJAHw/wGdkLsyay8l7AAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -1086,7 +1080,7 @@ } ], "source": [ - "plt.imshow(influences.numpy().astype(int), vmin=-1000, vmax=500)\n", + "plt.imshow(influences.numpy().astype(int), vmin=-1000, vmax=1000)\n", "plt.colorbar(label=\"Influence value \")\n", "plt.title(\"Influence from layers\")\n", "plt.xlabel(\"Training examples idx\")\n", @@ -1146,7 +1140,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The plot above shows the influences for test idx 0 and all train idx apart idx=3 (excluded for clarity since it has a very large influence). We can see that the influence values keep their sign across layers, but in almost all casesthey tend to decrease when approaching the output layer. This is not always the case, and in fact other test examples show different patterns. Understanding why this happens is an interesting research direction." + "The plot above shows the influences for test idx 0 and all train idx apart idx=3 (excluded for clarity since it has a very large absolute value). We can see that the scores tend to keep their sign across layers, but in almost all cases tend to decrease when approaching the output layer. This is not always the case, and in fact other test examples show different patterns. Understanding why this happens is an interesting research direction." ] }, { @@ -1160,7 +1154,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Ekfac is a powerful approximate method for computing the influence function of models that use a cross-entropy loss. In this notebook we have shown how to use it for a sentiment analysis with BERT on the IMDB dataset. However, this method can be applied to much larger models and problems, e.g. to analyse the influence of entire sentences generated by GPT, Llama or Claude. For more info, you can visit our [blog on influence functions for large language models](https://transferlab.ai/pills/2023/llm-influences-with-ekfac/)" + "Ekfac is a powerful approximate method for computing the influence function of models that use a cross-entropy loss. In this notebook we applied it to sentiment analysis with BERT on the IMDB dataset. However, this method can be applied to much larger models and problems, e.g. to analyse the influence of entire sentences generated by GPT, Llama or Claude. For more info, you can visit our [paper pill on influence functions for large language models](https://transferlab.ai/pills/2023/llm-influences-with-ekfac/)" ] }, { @@ -1174,7 +1168,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "The Hessian regularization value impacts a lot the quality of the influence function approximation. In general, the value should be chosen as small as possible so that the influence values are finite. However, even when finite the influence values can be very large, which can lead to numerical instabilities. In this section we show how to efficiently analyse the impact of the Hessian regularization value in the ekfac representation. " + "The Hessian regularization value impacts a lot the quality of the influence function approximation. In general, the value should be chosen as small as possible so that the results are finite. In practice, even when finite the influence values can be too large and lead to numerical instabilities. In this section we show how to efficiently analyse the impact of the Hessian regularization value with the ekfac method." ] }, { @@ -1241,7 +1235,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "With this dataframe, we can take contiguous values of the regularization regularizationa and, for each layer, calculate the Pearson and Spearman correlation coefficients across training examples. This will give us an idea of how the influence values change when the regularization value changes." + "With this dataframe, we can take contiguous values of regularization and, for each layer, calculate the Pearson and Spearman correlation coefficients. This will give us an idea of how the influence values change with the regularization value." ] }, { @@ -1269,7 +1263,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let's plot the correlations heatmap. The y-axis reports Spearman and Pearson correlations for each layer, while the x-axis reports pairs of regularization values. High correlations mean that the influence values are stable across regularization values. " + "Let's plot the correlations heatmap. The y-axis reports Spearman and Pearson correlations for each layer, while the x-axis reports pairs of regularization values. High correlations mean that influences are stable across regularization values. " ] }, { @@ -1306,7 +1300,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In our case, we can see that for regularization equals to 1 the correlations become very bad. However, for a large range of parameters before that the influences rankings are very stable. This is a good indication that the model is not too sensitive to the regularization value. We therefore choose 1e-5 as the regularization value for the rest of the notebook." + "In our case, we can see that for regularization = 1 the spearman correlation becomes very bad. However, for a large range of regularization values smaller than 1 the sample rankings are stable. This is a good indicator that the model is not too sensitive to the regularization value. We therefore chose the value 1e-5 for our analysis." ] } ], From 58fed09ce4e3f152453187eb85a909194a257f54 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Thu, 4 Jan 2024 15:45:27 +0100 Subject: [PATCH 34/87] changing interface for diat update and update readme --- README.md | 3 ++- docs/influence/influence_function_model.md | 4 ++-- notebooks/influence_wine.ipynb | 2 +- .../influence/torch/influence_function_model.py | 13 ++++++++++--- tests/influence/torch/test_influence_model.py | 2 +- 5 files changed, 16 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index ee0cc5d3d..948ffc842 100644 --- a/README.md +++ b/README.md @@ -318,7 +318,8 @@ We currently implement the following papers: - Schioppa, Andrea, Polina Zablotskaia, David Vilar, and Artem Sokolov. [Scaling Up Influence Functions](http://arxiv.org/abs/2112.03052). In Proceedings of the AAAI-22. arXiv, 2021. - +- James Martens, Roger Grosse, [Optimizing Neural Networks with Kronecker-factored Approximate Curvature](https://arxiv.org/abs/1503.05671), International Conference on Machine Learning (ICML), 2015. +- George, Thomas, César Laurent, Xavier Bouthillier, Nicolas Ballas, Pascal Vincent, [Fast Approximate Natural Gradient Descent in a Kronecker-factored Eigenbasis](https://arxiv.org/abs/1806.03884), Advances in Neural Information Processing Systems 31,2018. # License diff --git a/docs/influence/influence_function_model.md b/docs/influence/influence_function_model.md index 169bca12c..a126efdc5 100644 --- a/docs/influence/influence_function_model.md +++ b/docs/influence/influence_function_model.md @@ -115,14 +115,14 @@ if_model = EkfacInfluence( ``` Upon initialization, the K-FAC method will parse the model and extract which layers require grad and which do not. Then it will only calculate the influence scores for the layers that require grad. The current implementation of the K-FAC method is only available for linear layers, and therefore if the model contains non-linear layers that require gradient the K-FAC method will raise a NotImplementedLayerRepresentationException. -A further improvement of the K-FAC method is the Eigenvalue Corrected K-FAC (EKFAC) method [@george2018fast], which allows to further re-fit the eigenvalues of the Hessian, thus providing a more accurate approximation. On top of the K-FAC method, the EKFAC method is implemented by simply calling the update_diag method from [EkfacInfluence](pydvl/influence/torch/influence_function_model.py). The following code snippet shows how to use the EKFAC method to calculate the influence function of a model. +A further improvement of the K-FAC method is the Eigenvalue Corrected K-FAC (EKFAC) method [@george2018fast], which allows to further re-fit the eigenvalues of the Hessian, thus providing a more accurate approximation. On top of the K-FAC method, the EKFAC method is implemented by setting `update_diagonal=True` when initialising [EkfacInfluence](pydvl/influence/torch/influence_function_model.py). The following code snippet shows how to use the EKFAC method to calculate the influence function of a model. ```python from pydvl.influence.torch import EkfacInfluence if_model = EkfacInfluence( model, + update_diagonal=True, hessian_regularization=0.0, ) if_model.fit(train_loader) -if_model.update_diag(train_loader) ``` \ No newline at end of file diff --git a/notebooks/influence_wine.ipynb b/notebooks/influence_wine.ipynb index 4894f4ce2..a0f46fcae 100644 --- a/notebooks/influence_wine.ipynb +++ b/notebooks/influence_wine.ipynb @@ -824,10 +824,10 @@ "source": [ "ekfac_influence_model = EkfacInfluence(\n", " nn_model,\n", + " update_diagonal=True,\n", " hessian_regularization=0.1,\n", ")\n", "ekfac_influence_model = ekfac_influence_model.fit(training_data_loader)\n", - "ekfac_influence_model = ekfac_influence_model.update_diag(training_data_loader)\n", "ekfac_train_influences = ekfac_influence_model.influences(\n", " *test_data, *training_data, mode=\"up\"\n", ")\n", diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index 6ec61e74d..97dda0da5 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -896,6 +896,10 @@ class EkfacInfluence(TorchInfluenceFunctionModel): Args: model: Instance of [torch.nn.Module][torch.nn.Module]. + update_diagonal: If True, the diagonal values in the ekfac representation are + refitted from the training data after calculating the KFAC blocks. + This provides a more accurate approximation of the Hessian, but it is + computationally more expensive. hessian_regularization: Regularization of the hessian. progress: If True, display progress bars. """ @@ -905,12 +909,14 @@ class EkfacInfluence(TorchInfluenceFunctionModel): def __init__( self, model: nn.Module, + update_diagonal: bool = False, hessian_regularization: Optional[float] = None, progress: bool = False, ): super().__init__(model, torch.nn.functional.cross_entropy) self.hessian_regularization = hessian_regularization + self.update_diagonal = update_diagonal self.active_layers = self._parse_active_layers() self.progress = progress @@ -1061,6 +1067,8 @@ def fit(self, data: DataLoader) -> EkfacInfluence: layers_evect_g.values(), layers_diags.values(), ) + if self.update_diagonal: + self._update_diag(data) return self @staticmethod @@ -1119,7 +1127,7 @@ def grad_hook(m, m_grad, m_out): ) return input_hook, grad_hook - def update_diag( + def _update_diag( self, data: DataLoader, ) -> EkfacInfluence: @@ -1130,8 +1138,7 @@ def update_diag( """ if not self.is_fitted: raise ValueError( - "EkfacInfluence must be fitted before calling update_diag on it. " - "Please call fit first." + "EkfacInfluence must be fitted before updating the diagonal. " ) diags = {} last_x_kfe: Dict[str, torch.Tensor] = {} diff --git a/tests/influence/torch/test_influence_model.py b/tests/influence/torch/test_influence_model.py index 15bdf6441..9472ad398 100644 --- a/tests/influence/torch/test_influence_model.py +++ b/tests/influence/torch/test_influence_model.py @@ -548,6 +548,7 @@ def test_influences_ekfac( ekfac_influence = EkfacInfluence( model, + update_diagonal=True, hessian_regularization=test_case.hessian_reg, ) @@ -564,7 +565,6 @@ def test_influences_ekfac( ekfac_influence.fit(train_dataloader) elif isinstance(loss, nn.CrossEntropyLoss): ekfac_influence = ekfac_influence.fit(train_dataloader) - ekfac_influence = ekfac_influence.update_diag(train_dataloader) ekfac_influence_values = ekfac_influence.influences( x_test, y_test, x_train, y_train, mode=test_case.mode ).numpy() From 697ba26a4db506d47b13e0d880c1904eb5ece247 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Thu, 4 Jan 2024 15:48:37 +0100 Subject: [PATCH 35/87] change interface of diag update and update readme --- README.md | 3 +- docs/influence/influence_function_model.md | 4 +- notebooks/influence_wine.ipynb | 2 +- .../torch/influence_function_model.py | 328 ++++++++++++++++-- tests/influence/torch/test_influence_model.py | 11 +- 5 files changed, 321 insertions(+), 27 deletions(-) diff --git a/README.md b/README.md index ee0cc5d3d..948ffc842 100644 --- a/README.md +++ b/README.md @@ -318,7 +318,8 @@ We currently implement the following papers: - Schioppa, Andrea, Polina Zablotskaia, David Vilar, and Artem Sokolov. [Scaling Up Influence Functions](http://arxiv.org/abs/2112.03052). In Proceedings of the AAAI-22. arXiv, 2021. - +- James Martens, Roger Grosse, [Optimizing Neural Networks with Kronecker-factored Approximate Curvature](https://arxiv.org/abs/1503.05671), International Conference on Machine Learning (ICML), 2015. +- George, Thomas, César Laurent, Xavier Bouthillier, Nicolas Ballas, Pascal Vincent, [Fast Approximate Natural Gradient Descent in a Kronecker-factored Eigenbasis](https://arxiv.org/abs/1806.03884), Advances in Neural Information Processing Systems 31,2018. # License diff --git a/docs/influence/influence_function_model.md b/docs/influence/influence_function_model.md index 169bca12c..a126efdc5 100644 --- a/docs/influence/influence_function_model.md +++ b/docs/influence/influence_function_model.md @@ -115,14 +115,14 @@ if_model = EkfacInfluence( ``` Upon initialization, the K-FAC method will parse the model and extract which layers require grad and which do not. Then it will only calculate the influence scores for the layers that require grad. The current implementation of the K-FAC method is only available for linear layers, and therefore if the model contains non-linear layers that require gradient the K-FAC method will raise a NotImplementedLayerRepresentationException. -A further improvement of the K-FAC method is the Eigenvalue Corrected K-FAC (EKFAC) method [@george2018fast], which allows to further re-fit the eigenvalues of the Hessian, thus providing a more accurate approximation. On top of the K-FAC method, the EKFAC method is implemented by simply calling the update_diag method from [EkfacInfluence](pydvl/influence/torch/influence_function_model.py). The following code snippet shows how to use the EKFAC method to calculate the influence function of a model. +A further improvement of the K-FAC method is the Eigenvalue Corrected K-FAC (EKFAC) method [@george2018fast], which allows to further re-fit the eigenvalues of the Hessian, thus providing a more accurate approximation. On top of the K-FAC method, the EKFAC method is implemented by setting `update_diagonal=True` when initialising [EkfacInfluence](pydvl/influence/torch/influence_function_model.py). The following code snippet shows how to use the EKFAC method to calculate the influence function of a model. ```python from pydvl.influence.torch import EkfacInfluence if_model = EkfacInfluence( model, + update_diagonal=True, hessian_regularization=0.0, ) if_model.fit(train_loader) -if_model.update_diag(train_loader) ``` \ No newline at end of file diff --git a/notebooks/influence_wine.ipynb b/notebooks/influence_wine.ipynb index 4894f4ce2..a0f46fcae 100644 --- a/notebooks/influence_wine.ipynb +++ b/notebooks/influence_wine.ipynb @@ -824,10 +824,10 @@ "source": [ "ekfac_influence_model = EkfacInfluence(\n", " nn_model,\n", + " update_diagonal=True,\n", " hessian_regularization=0.1,\n", ")\n", "ekfac_influence_model = ekfac_influence_model.fit(training_data_loader)\n", - "ekfac_influence_model = ekfac_influence_model.update_diag(training_data_loader)\n", "ekfac_train_influences = ekfac_influence_model.influences(\n", " *test_data, *training_data, mode=\"up\"\n", ")\n", diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index 2072323f2..97dda0da5 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -8,11 +8,11 @@ import logging from abc import ABC, abstractmethod -from typing import Callable, Dict, Optional, Tuple +from typing import Callable, Dict, List, Optional, Tuple import torch from torch import nn as nn -from torch.utils.data import DataLoader, TensorDataset +from torch.utils.data import DataLoader from tqdm.auto import tqdm from pydvl.utils.progress import log_duration @@ -92,7 +92,7 @@ def _loss_grad(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: return flatten_dimensions(grads.values(), shape=shape) @log_duration - def _flat_loss_mixed_grad(self, x: torch.Tensor, y: torch.Tensor): + def _flat_loss_mixed_grad(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor: mixed_grads = create_per_sample_mixed_derivative_function( self.model, self.loss )(self.model_params, x, y) @@ -192,7 +192,7 @@ def _non_symmetric_values( x: torch.Tensor, y: torch.Tensor, mode: InfluenceMode = InfluenceMode.Up, - ): + ) -> torch.Tensor: if mode == InfluenceMode.Up: if x_test.shape[0] <= x.shape[0]: factor = self.influence_factors(x_test, y_test) @@ -896,7 +896,12 @@ class EkfacInfluence(TorchInfluenceFunctionModel): Args: model: Instance of [torch.nn.Module][torch.nn.Module]. + update_diagonal: If True, the diagonal values in the ekfac representation are + refitted from the training data after calculating the KFAC blocks. + This provides a more accurate approximation of the Hessian, but it is + computationally more expensive. hessian_regularization: Regularization of the hessian. + progress: If True, display progress bars. """ ekfac_representation: EkfacRepresentation @@ -904,12 +909,16 @@ class EkfacInfluence(TorchInfluenceFunctionModel): def __init__( self, model: nn.Module, - hessian_regularization: float = 0.0, + update_diagonal: bool = False, + hessian_regularization: Optional[float] = None, + progress: bool = False, ): super().__init__(model, torch.nn.functional.cross_entropy) self.hessian_regularization = hessian_regularization + self.update_diagonal = update_diagonal self.active_layers = self._parse_active_layers() + self.progress = progress @property def is_fitted(self): @@ -977,7 +986,7 @@ def _get_layer_kfac_hooks( with_bias = module.bias is not None def input_hook(m, x, y): - x = x[0] + x = x[0].reshape(-1, module.in_features) if with_bias: x = torch.cat( (x, torch.ones((x.shape[0], 1), device=module.weight.device)), @@ -986,7 +995,7 @@ def input_hook(m, x, y): forward_x[m_name] += torch.mm(x.t(), x) def grad_hook(m, m_grad, m_out): - m_out = m_out[0] + m_out = m_out[0].reshape(-1, module.out_features) grad_y[m_name] += torch.mm(m_out.t(), m_out) else: @@ -1017,7 +1026,9 @@ def _get_kfac_blocks( hooks.append(module.register_forward_hook(layer_input_hook)) hooks.append(module.register_full_backward_hook(layer_grad_hook)) - for x, _ in data: + for x, *_ in tqdm( + data, disable=not self.progress, desc="K-FAC blocks - batch progress" + ): data_len += x.shape[0] pred_y = self.model(x) loss = empirical_cross_entropy_loss_fn(pred_y) @@ -1056,6 +1067,8 @@ def fit(self, data: DataLoader) -> EkfacInfluence: layers_evect_g.values(), layers_diags.values(), ) + if self.update_diagonal: + self._update_diag(data) return self @staticmethod @@ -1093,7 +1106,7 @@ def _get_layer_diag_hooks( with_bias = module.bias is not None def input_hook(m, x, y): - x = x[0] + x = x[0].reshape(-1, module.in_features) if with_bias: x = torch.cat( (x, torch.ones((x.shape[0], 1), device=module.weight.device)), @@ -1102,7 +1115,7 @@ def input_hook(m, x, y): last_x_kfe[m_name] = torch.mm(x, evecs_a[m_name]) def grad_hook(m, m_grad, m_out): - m_out = m_out[0] + m_out = m_out[0].reshape(-1, module.out_features) gy_kfe = torch.mm(m_out, evecs_g[m_name]) diags[m_name] += torch.mm( gy_kfe.t() ** 2, last_x_kfe[m_name] ** 2 @@ -1114,7 +1127,7 @@ def grad_hook(m, m_grad, m_out): ) return input_hook, grad_hook - def update_diag( + def _update_diag( self, data: DataLoader, ) -> EkfacInfluence: @@ -1125,8 +1138,7 @@ def update_diag( """ if not self.is_fitted: raise ValueError( - "EkfacInfluence must be fitted before calling update_diag on it. " - "Please call fit first." + "EkfacInfluence must be fitted before updating the diagonal. " ) diags = {} last_x_kfe: Dict[str, torch.Tensor] = {} @@ -1141,7 +1153,9 @@ def update_diag( hooks.append(module.register_forward_hook(input_hook)) hooks.append(module.register_full_backward_hook(grad_hook)) - for x, _ in data: + for x, _ in tqdm( + data, disable=not self.progress, desc="Update Diagonal - batch progress" + ): data_len += x.shape[0] pred_y = self.model(x) loss = empirical_cross_entropy_loss_fn(pred_y) @@ -1163,11 +1177,20 @@ def update_diag( return self - @log_duration - def _solve_hvp(self, rhs: torch.Tensor) -> torch.Tensor: - x = rhs.clone() + @staticmethod + def _solve_hvp_by_layer( + rhs: torch.Tensor, + ekfac_representation: EkfacRepresentation, + hessian_regularization: float, + ) -> Dict[str, torch.Tensor]: + """ + Compute the Hessian Vector Product for each layer of the model, using the + provided ekfac representation and hessian regularization. It returns a + dictionary containing the Hessian Vector Product for each layer. + """ + hvp_layers = {} start_idx = 0 - for _, (_, evecs_a, evecs_g, diag) in self.ekfac_representation: + for layer_id, (_, evecs_a, evecs_g, diag) in ekfac_representation: end_idx = start_idx + diag.shape[0] rhs_layer = rhs[:, start_idx : end_idx - evecs_g.shape[0]].reshape( rhs.shape[0], evecs_g.shape[0], -1 @@ -1179,22 +1202,283 @@ def _solve_hvp(self, rhs: torch.Tensor) -> torch.Tensor: torch.einsum("ij,bjk->bik", evecs_g.t(), rhs_layer), evecs_a, ) - inv_diag = 1 / ( - diag.reshape(*v_kfe.shape[1:]) + self.hessian_regularization - ) + inv_diag = 1 / (diag.reshape(*v_kfe.shape[1:]) + hessian_regularization) inv_kfe = torch.einsum("bij,ij->bij", v_kfe, inv_diag) inv = torch.einsum( "bij,jk->bik", torch.einsum("ij,bjk->bik", evecs_g, inv_kfe), evecs_a.t(), ) - x[:, start_idx:end_idx] = torch.cat( + hvp_layers[layer_id] = torch.cat( [inv[:, :, :-1].reshape(rhs.shape[0], -1), inv[:, :, -1]], dim=1 ) start_idx = end_idx + return hvp_layers + + @log_duration + def _solve_hvp(self, rhs: torch.Tensor) -> torch.Tensor: + x = rhs.clone() + start_idx = 0 + layer_hvp = self._solve_hvp_by_layer( + rhs, self.ekfac_representation, self.hessian_regularization + ) + for hvp in layer_hvp.values(): + end_idx = start_idx + hvp.shape[1] + x[:, start_idx:end_idx] = hvp + start_idx = end_idx x.detach_() return x + def influences_by_layer( + self, + x_test: torch.Tensor, + y_test: torch.Tensor, + x: Optional[torch.Tensor] = None, + y: Optional[torch.Tensor] = None, + mode: InfluenceMode = InfluenceMode.Up, + ) -> Dict[str, torch.Tensor]: + """ + Compute the influence of the data on the test data for each layer of the model. + + Args: + x_test: model input to use in the gradient computations of + $H^{-1}\nabla_{\theta} \ell(y_{\text{test}}, + f_{\theta}(x_{\text{test}}))$ + y_test: label tensor to compute gradients + x: optional model input to use in the gradient computations + $\nabla_{\theta}\ell(y, f_{\theta}(x))$, + resp. $\nabla_{x}\nabla_{\theta}\ell(y, f_{\theta}(x))$, + if None, use $x=x_{\text{test}}$ + y: optional label tensor to compute gradients + mode: enum value of [InfluenceType] + [pydvl.influence.base_influence_model.InfluenceType] + + Returns: + A dictionary containing the influence of the data on the test data for each + layer of the model, with the layer name as key. + """ + if not self.is_fitted: + raise ValueError( + "Instance must be fitted before calling influence methods on it" + ) + + if x is None: + + if y is not None: + raise ValueError( + "Providing labels y, without providing model input x " + "is not supported" + ) + + return self._symmetric_values_by_layer( + x_test.to(self.model_device), + y_test.to(self.model_device), + mode, + ) + + if y is None: + raise ValueError( + "Providing model input x without providing labels y is not supported" + ) + + return self._non_symmetric_values_by_layer( + x_test.to(self.model_device), + y_test.to(self.model_device), + x.to(self.model_device), + y.to(self.model_device), + mode, + ) + + def influence_factors_by_layer( + self, + x: torch.Tensor, + y: torch.Tensor, + ) -> Dict[str, torch.Tensor]: + """ + Computes the approximation of + + \[H^{-1}\nabla_{\theta} \ell(y, f_{\theta}(x))\] + + for each layer of the model separately. + + Args: + x: model input to use in the gradient computations + y: label tensor to compute gradients + + Returns: + A dictionary containing the influence factors for each layer of the model, + with the layer name as key. + """ + if not self.is_fitted: + raise ValueError( + "Instance must be fitted before calling influence methods on it" + ) + + return self._solve_hvp_by_layer( + self._loss_grad(x.to(self.model_device), y.to(self.model_device)), + self.ekfac_representation, + self.hessian_regularization, + ) + + def influences_from_factors_by_layer( + self, + z_test_factors: Dict[str, torch.Tensor], + x: torch.Tensor, + y: torch.Tensor, + mode: InfluenceMode = InfluenceMode.Up, + ) -> Dict[str, torch.Tensor]: + """ + Computation of + + \[ \langle z_{\text{test_factors}}, + \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \] + + for the case of up-weighting influence, resp. + + \[ \langle z_{\text{test_factors}}, + \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \] + + for the perturbation type influence case for each layer of the model separately. + The gradients are meant to be per sample of the batch $(x, y)$. + + Args: + z_test_factors: pre-computed tensor, approximating + $H^{-1}\nabla_{\theta} \ell(y_{\text{test}}, + f_{\theta}(x_{\text{test}}))$ + x: model input to use in the gradient computations + $\nabla_{\theta}\ell(y, f_{\theta}(x))$, + resp. $\nabla_{x}\nabla_{\theta}\ell(y, f_{\theta}(x))$ + y: label tensor to compute gradients + mode: enum value of [InfluenceType] + [pydvl.influence.twice_differentiable.InfluenceType] + + Returns: + A dictionary containing the influence of the data on the test data for each + layer of the model, with the layer name as key. + """ + if mode == InfluenceMode.Up: + total_grad = self._loss_grad( + x.to(self.model_device), y.to(self.model_device) + ) + start_idx = 0 + influences = {} + for layer_id, layer_z_test in z_test_factors.items(): + end_idx = start_idx + layer_z_test.shape[1] + influences[layer_id] = layer_z_test @ total_grad[:, start_idx:end_idx].T + start_idx = end_idx + return influences + elif mode == InfluenceMode.Perturbation: + total_mixed_grad = self._flat_loss_mixed_grad( + x.to(self.model_device), y.to(self.model_device) + ) + start_idx = 0 + influences = {} + for layer_id, layer_z_test in z_test_factors.items(): + end_idx = start_idx + layer_z_test.shape[1] + influences[layer_id] = torch.einsum( + "ia,j...a->ij...", + layer_z_test, + total_mixed_grad[:, start_idx:end_idx], + ) + start_idx = end_idx + return influences + else: + raise UnsupportedInfluenceModeException(mode) + + def _non_symmetric_values_by_layer( + self, + x_test: torch.Tensor, + y_test: torch.Tensor, + x: torch.Tensor, + y: torch.Tensor, + mode: InfluenceMode = InfluenceMode.Up, + ) -> Dict[str, torch.Tensor]: + """ + Similar to _non_symmetric_values, but computes the influence for each layer + separately. Returns a dictionary containing the influence for each layer, + with the layer name as key. + """ + if mode == InfluenceMode.Up: + if x_test.shape[0] <= x.shape[0]: + fac = self.influence_factors_by_layer(x_test, y_test) + values = self.influences_from_factors_by_layer(fac, x, y, mode=mode) + else: + fac = self.influence_factors_by_layer(x, y) + values = self.influences_from_factors_by_layer( + fac, x_test, y_test, mode=mode + ).T + elif mode == InfluenceMode.Perturbation: + fac = self.influence_factors_by_layer(x_test, y_test) + values = self.influences_from_factors_by_layer(fac, x, y, mode=mode) + else: + raise UnsupportedInfluenceModeException(mode) + return values + + def _symmetric_values_by_layer( + self, x: torch.Tensor, y: torch.Tensor, mode: InfluenceMode + ) -> Dict[str, torch.Tensor]: + """ + Similar to _symmetric_values, but computes the influence for each layer + separately. Returns a dictionary containing the influence for each layer, + with the layer name as key. + """ + grad = self._loss_grad(x, y) + fac = self._solve_hvp_by_layer( + grad, self.ekfac_representation, self.hessian_regularization + ) + + if mode == InfluenceMode.Up: + values = {} + start_idx = 0 + for layer_id, layer_fac in fac.items(): + end_idx = start_idx + layer_fac.shape[1] + values[layer_id] = layer_fac @ grad[:, start_idx:end_idx].T + start_idx = end_idx + elif mode == InfluenceMode.Perturbation: + values = self.influences_from_factors_by_layer(fac, x, y, mode=mode) + else: + raise UnsupportedInfluenceModeException(mode) + return values + + def explore_hessian_regularization( + self, + x: torch.Tensor, + y: torch.Tensor, + regularization_values: List[float], + ) -> Dict[float, Dict[str, torch.Tensor]]: + """ + Efficiently computes the influence for input x and label y for each layer of the + model, for different values of the hessian regularization parameter. This is done + by computing the gradient of the loss function for the input x and label y only once + and then solving the Hessian Vector Product for each regularization value. This is + useful for finding the optimal regularization value and for exploring + how robust the influence values are to changes in the regularization value. + + Args: + x: model input to use in the gradient computations + y: label tensor to compute gradients + regularization_values: list of regularization values to use + + Returns: + A dictionary containing with keys being the regularization values and values + being dictionaries containing the influences for each layer of the model, + with the layer name as key. + """ + grad = self._loss_grad(x, y) + influences_by_reg_value = {} + for reg_value in regularization_values: + reg_factors = self._solve_hvp_by_layer( + grad, self.ekfac_representation, reg_value + ) + values = {} + start_idx = 0 + for layer_id, layer_fac in reg_factors.items(): + end_idx = start_idx + layer_fac.shape[1] + values[layer_id] = layer_fac @ grad[:, start_idx:end_idx].T + start_idx = end_idx + influences_by_reg_value[reg_value] = values + return influences_by_reg_value + def to(self, device: torch.device): self.model.to(device) if self.is_fitted: diff --git a/tests/influence/torch/test_influence_model.py b/tests/influence/torch/test_influence_model.py index b18c30c42..9472ad398 100644 --- a/tests/influence/torch/test_influence_model.py +++ b/tests/influence/torch/test_influence_model.py @@ -548,6 +548,7 @@ def test_influences_ekfac( ekfac_influence = EkfacInfluence( model, + update_diagonal=True, hessian_regularization=test_case.hessian_reg, ) @@ -564,11 +565,18 @@ def test_influences_ekfac( ekfac_influence.fit(train_dataloader) elif isinstance(loss, nn.CrossEntropyLoss): ekfac_influence = ekfac_influence.fit(train_dataloader) - ekfac_influence = ekfac_influence.update_diag(train_dataloader) ekfac_influence_values = ekfac_influence.influences( x_test, y_test, x_train, y_train, mode=test_case.mode ).numpy() + ekfac_influences_by_layer = ekfac_influence.influences_by_layer( + x_test, y_test, x_train, y_train, mode=test_case.mode + ) + + accumulated_inf_by_layer = np.zeros_like(ekfac_influence_values) + for layer, infl in ekfac_influences_by_layer.items(): + accumulated_inf_by_layer += infl.detach().numpy() + ekfac_self_influence = ekfac_influence.influences( x_train, y_train, mode=test_case.mode ).numpy() @@ -580,5 +588,6 @@ def test_influences_ekfac( ).numpy() assert np.allclose(ekfac_influence_values, influence_from_factors) + assert np.allclose(ekfac_influence_values, accumulated_inf_by_layer) check_influence_correlations(direct_influences, ekfac_influence_values) check_influence_correlations(direct_sym_influences, ekfac_self_influence) From 4abb090dce23743aa43edd7d89c609a4859897ed Mon Sep 17 00:00:00 2001 From: Kristof Schroeder Date: Thu, 4 Jan 2024 15:48:57 +0100 Subject: [PATCH 36/87] Fix implementation of 'to' methods of TorchInfluenceFunctionModel implementations --- .../torch/influence_function_model.py | 38 ++++++++----------- 1 file changed, 16 insertions(+), 22 deletions(-) diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index 3b7c0a688..30c92fd26 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -304,6 +304,16 @@ def influences_from_factors( def _solve_hvp(self, rhs: torch.Tensor) -> torch.Tensor: pass + def to(self, device: torch.device): + self.model = self.model.to(device) + self._model_params = { + k: p.detach().to(device) + for k, p in self.model.named_parameters() + if p.requires_grad + } + self._model_device = device + return self + class DirectInfluence(TorchInfluenceFunctionModel): r""" @@ -402,15 +412,9 @@ def _solve_hvp(self, rhs: torch.Tensor) -> torch.Tensor: ).T def to(self, device: torch.device): - self.hessian = self.hessian.to(device) - self.model = self.model.to(device) - self._model_device = device - self._model_params = { - k: p.detach().to(device) - for k, p in self.model.named_parameters() - if p.requires_grad - } - return self + if self.is_fitted: + self.hessian = self.hessian.to(device) + return super().to(device) class CgInfluence(TorchInfluenceFunctionModel): @@ -537,16 +541,6 @@ def reg_hvp(v: torch.Tensor): batch_cg[idx] = batch_result return batch_cg - def to(self, device: torch.device): - self.model = self.model.to(device) - self._model_params = { - k: p.detach().to(device) - for k, p in self.model.named_parameters() - if p.requires_grad - } - self._model_device = device - return self - @staticmethod def _solve_cg( hvp: Callable[[torch.Tensor], torch.Tensor], @@ -873,6 +867,6 @@ def _solve_hvp(self, rhs: torch.Tensor) -> torch.Tensor: return result.t() def to(self, device: torch.device): - return ArnoldiInfluence( - self.model.to(device), self.loss, self.low_rank_representation.to(device) - ) + if self.is_fitted: + self.low_rank_representation = self.low_rank_representation.to(device) + return super().to(device) From 2d54f15c633dcbff9e47346e25bfd18b4120aef7 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Thu, 4 Jan 2024 15:54:03 +0100 Subject: [PATCH 37/87] fix typing --- src/pydvl/influence/torch/influence_function_model.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index 97dda0da5..974bc4ace 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -910,7 +910,7 @@ def __init__( self, model: nn.Module, update_diagonal: bool = False, - hessian_regularization: Optional[float] = None, + hessian_regularization: float = 0.0, progress: bool = False, ): From 73c14fcfe45f8887ba0efbc513ee0a24e096db86 Mon Sep 17 00:00:00 2001 From: Kristof Schroeder Date: Thu, 4 Jan 2024 15:54:54 +0100 Subject: [PATCH 38/87] Mention bug fix in CHANGELOG --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index efd1a1b6d..89d272062 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,8 @@ - Bug in using `DaskInfluenceCalcualator` with `TorchnumpyConverter` for single dimensional arrays [PR #485](https://github.com/aai-institute/pyDVL/pull/485) +- Fix implementations of `to` methods of `TorchInfluenceFunctionModel` implementations + [PR #487](https://github.com/aai-institute/pyDVL/pull/487) ## 0.8.0 - 🆕 New interfaces, scaling computation, bug fixes and improvements 🎁 From 03c169c2e5e5b2b8d73df08a5759ffcb336c70e5 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Thu, 4 Jan 2024 16:00:40 +0100 Subject: [PATCH 39/87] add notebook to mkdocs and small changes to notebook --- mkdocs.yml | 1 + notebooks/influence_sentiment_analysis.ipynb | 8 ++++++-- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/mkdocs.yml b/mkdocs.yml index 408b26b75..dace2fa73 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -215,6 +215,7 @@ nav: - For CNNs: examples/influence_imagenet.ipynb - For mislabeled data: examples/influence_synthetic.ipynb - For outlier detection: examples/influence_wine.ipynb + - For sentiment analysis: examples/influence_sentiment_analysis.ipynb - Code: - Changelog: CHANGELOG.md - API: api/pydvl/ diff --git a/notebooks/influence_sentiment_analysis.ipynb b/notebooks/influence_sentiment_analysis.ipynb index a4d47d0da..9cdb28347 100644 --- a/notebooks/influence_sentiment_analysis.ipynb +++ b/notebooks/influence_sentiment_analysis.ipynb @@ -146,7 +146,11 @@ { "cell_type": "code", "execution_count": 5, - "metadata": {}, + "metadata": { + "tags": [ + "hide-output" + ] + }, "outputs": [ { "name": "stderr", @@ -921,7 +925,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "This review is also quite hard to classify. This time it has a negative sentiment towards the movie, but it also contains several words with positive connotation. The parallel with the previous review is quite interesting, since both reviews talk about an invasion. " + "This review is also quite hard to classify. This time it has a negative sentiment towards the movie, but it also contains several words with positive connotation. The parallel with the previous review is quite interesting, since both talk about an invasion. " ] }, { From 460ce249bcc61f7a1a5108b22c70ad34128e449f Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Thu, 4 Jan 2024 16:25:39 +0100 Subject: [PATCH 40/87] change update diag interface and update readme --- README.md | 3 ++- docs/influence/influence_function_model.md | 4 ++-- notebooks/influence_wine.ipynb | 2 +- .../influence/torch/influence_function_model.py | 13 ++++++++++--- tests/influence/torch/test_influence_model.py | 2 +- 5 files changed, 16 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index ee0cc5d3d..948ffc842 100644 --- a/README.md +++ b/README.md @@ -318,7 +318,8 @@ We currently implement the following papers: - Schioppa, Andrea, Polina Zablotskaia, David Vilar, and Artem Sokolov. [Scaling Up Influence Functions](http://arxiv.org/abs/2112.03052). In Proceedings of the AAAI-22. arXiv, 2021. - +- James Martens, Roger Grosse, [Optimizing Neural Networks with Kronecker-factored Approximate Curvature](https://arxiv.org/abs/1503.05671), International Conference on Machine Learning (ICML), 2015. +- George, Thomas, César Laurent, Xavier Bouthillier, Nicolas Ballas, Pascal Vincent, [Fast Approximate Natural Gradient Descent in a Kronecker-factored Eigenbasis](https://arxiv.org/abs/1806.03884), Advances in Neural Information Processing Systems 31,2018. # License diff --git a/docs/influence/influence_function_model.md b/docs/influence/influence_function_model.md index 169bca12c..a126efdc5 100644 --- a/docs/influence/influence_function_model.md +++ b/docs/influence/influence_function_model.md @@ -115,14 +115,14 @@ if_model = EkfacInfluence( ``` Upon initialization, the K-FAC method will parse the model and extract which layers require grad and which do not. Then it will only calculate the influence scores for the layers that require grad. The current implementation of the K-FAC method is only available for linear layers, and therefore if the model contains non-linear layers that require gradient the K-FAC method will raise a NotImplementedLayerRepresentationException. -A further improvement of the K-FAC method is the Eigenvalue Corrected K-FAC (EKFAC) method [@george2018fast], which allows to further re-fit the eigenvalues of the Hessian, thus providing a more accurate approximation. On top of the K-FAC method, the EKFAC method is implemented by simply calling the update_diag method from [EkfacInfluence](pydvl/influence/torch/influence_function_model.py). The following code snippet shows how to use the EKFAC method to calculate the influence function of a model. +A further improvement of the K-FAC method is the Eigenvalue Corrected K-FAC (EKFAC) method [@george2018fast], which allows to further re-fit the eigenvalues of the Hessian, thus providing a more accurate approximation. On top of the K-FAC method, the EKFAC method is implemented by setting `update_diagonal=True` when initialising [EkfacInfluence](pydvl/influence/torch/influence_function_model.py). The following code snippet shows how to use the EKFAC method to calculate the influence function of a model. ```python from pydvl.influence.torch import EkfacInfluence if_model = EkfacInfluence( model, + update_diagonal=True, hessian_regularization=0.0, ) if_model.fit(train_loader) -if_model.update_diag(train_loader) ``` \ No newline at end of file diff --git a/notebooks/influence_wine.ipynb b/notebooks/influence_wine.ipynb index 4894f4ce2..a0f46fcae 100644 --- a/notebooks/influence_wine.ipynb +++ b/notebooks/influence_wine.ipynb @@ -824,10 +824,10 @@ "source": [ "ekfac_influence_model = EkfacInfluence(\n", " nn_model,\n", + " update_diagonal=True,\n", " hessian_regularization=0.1,\n", ")\n", "ekfac_influence_model = ekfac_influence_model.fit(training_data_loader)\n", - "ekfac_influence_model = ekfac_influence_model.update_diag(training_data_loader)\n", "ekfac_train_influences = ekfac_influence_model.influences(\n", " *test_data, *training_data, mode=\"up\"\n", ")\n", diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index 2072323f2..1721dc7dc 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -896,6 +896,10 @@ class EkfacInfluence(TorchInfluenceFunctionModel): Args: model: Instance of [torch.nn.Module][torch.nn.Module]. + update_diagonal: If True, the diagonal values in the ekfac representation are + refitted from the training data after calculating the KFAC blocks. + This provides a more accurate approximation of the Hessian, but it is + computationally more expensive. hessian_regularization: Regularization of the hessian. """ @@ -904,11 +908,13 @@ class EkfacInfluence(TorchInfluenceFunctionModel): def __init__( self, model: nn.Module, + update_diagonal: bool = False, hessian_regularization: float = 0.0, ): super().__init__(model, torch.nn.functional.cross_entropy) self.hessian_regularization = hessian_regularization + self.update_diagonal = update_diagonal self.active_layers = self._parse_active_layers() @property @@ -1056,6 +1062,8 @@ def fit(self, data: DataLoader) -> EkfacInfluence: layers_evect_g.values(), layers_diags.values(), ) + if self.update_diagonal: + self._update_diag(data) return self @staticmethod @@ -1114,7 +1122,7 @@ def grad_hook(m, m_grad, m_out): ) return input_hook, grad_hook - def update_diag( + def _update_diag( self, data: DataLoader, ) -> EkfacInfluence: @@ -1125,8 +1133,7 @@ def update_diag( """ if not self.is_fitted: raise ValueError( - "EkfacInfluence must be fitted before calling update_diag on it. " - "Please call fit first." + "EkfacInfluence must be fitted before updating the diagonal." ) diags = {} last_x_kfe: Dict[str, torch.Tensor] = {} diff --git a/tests/influence/torch/test_influence_model.py b/tests/influence/torch/test_influence_model.py index b18c30c42..d967bcff2 100644 --- a/tests/influence/torch/test_influence_model.py +++ b/tests/influence/torch/test_influence_model.py @@ -548,6 +548,7 @@ def test_influences_ekfac( ekfac_influence = EkfacInfluence( model, + update_diagonal=True, hessian_regularization=test_case.hessian_reg, ) @@ -564,7 +565,6 @@ def test_influences_ekfac( ekfac_influence.fit(train_dataloader) elif isinstance(loss, nn.CrossEntropyLoss): ekfac_influence = ekfac_influence.fit(train_dataloader) - ekfac_influence = ekfac_influence.update_diag(train_dataloader) ekfac_influence_values = ekfac_influence.influences( x_test, y_test, x_train, y_train, mode=test_case.mode ).numpy() From 1c73ccaa2a89d8e767c673ec2f703cc86e3f82d4 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Thu, 4 Jan 2024 16:30:00 +0100 Subject: [PATCH 41/87] small fix to update diag --- src/pydvl/influence/torch/influence_function_model.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index b0b1b71ad..5c207ceff 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -1153,7 +1153,7 @@ def _update_diag( hooks.append(module.register_forward_hook(input_hook)) hooks.append(module.register_full_backward_hook(grad_hook)) - for x, _ in tqdm( + for x, *_ in tqdm( data, disable=not self.progress, desc="Update Diagonal - batch progress" ): data_len += x.shape[0] From 053bbe4eb7605719c7903d5e84ef8b335157e9f6 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Fri, 5 Jan 2024 10:22:19 +0100 Subject: [PATCH 42/87] fix to method in ekfac --- src/pydvl/influence/torch/influence_function_model.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index 326a4efd5..8c181699f 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -1197,7 +1197,6 @@ def _solve_hvp(self, rhs: torch.Tensor) -> torch.Tensor: return x def to(self, device: torch.device): - self.model.to(device) if self.is_fitted: self.ekfac_representation.to(device) - return self + return super().to(device) From 62c69c821bccf3cc51581e8ccde829e989279f72 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Mon, 8 Jan 2024 13:13:24 +0100 Subject: [PATCH 43/87] factor out error message in NotImplementedLayerRepresentationException --- .../influence/base_influence_function_model.py | 3 ++- .../influence/torch/influence_function_model.py | 16 ++++------------ 2 files changed, 6 insertions(+), 13 deletions(-) diff --git a/src/pydvl/influence/base_influence_function_model.py b/src/pydvl/influence/base_influence_function_model.py index 3147b90e6..0a9a9f33b 100644 --- a/src/pydvl/influence/base_influence_function_model.py +++ b/src/pydvl/influence/base_influence_function_model.py @@ -37,7 +37,8 @@ def __init__(self): class NotImplementedLayerRepresentationException(ValueError): - def __init__(self, message: str): + def __init__(self, module_id: str): + message = f"Only Linear layers are supported, but found module {module_id} requiring grad." super().__init__(message) diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index 8c181699f..b5d9c7c8b 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -954,9 +954,7 @@ def _init_layer_kfac_blocks( forward_x_layer = torch.zeros((sA, sA), device=module.weight.device) grad_y_layer = torch.zeros((sG, sG), device=module.weight.device) else: - raise NotImplementedLayerRepresentationException( - f"Only Linear layers are supported, but found module {module} requiring grad." - ) + raise NotImplementedLayerRepresentationException(module_id=str(module)) return forward_x_layer, grad_y_layer @staticmethod @@ -990,9 +988,7 @@ def grad_hook(m, m_grad, m_out): grad_y[m_name] += torch.mm(m_out.t(), m_out) else: - raise NotImplementedLayerRepresentationException( - f"Only Linear layers are supported, but found module {module} requiring grad." - ) + raise NotImplementedLayerRepresentationException(module_id=str(module)) return input_hook, grad_hook def _get_kfac_blocks( @@ -1071,9 +1067,7 @@ def _init_layer_diag(module: torch.nn.Module) -> torch.Tensor: sA = module.in_features + int(with_bias) layer_diag = torch.zeros((sA * sG), device=module.weight.device) else: - raise NotImplementedLayerRepresentationException( - f"Only Linear layers are supported, but found module {module} requiring grad." - ) + raise NotImplementedLayerRepresentationException(module_id=str(module)) return layer_diag def _get_layer_diag_hooks( @@ -1111,9 +1105,7 @@ def grad_hook(m, m_grad, m_out): ).view(-1) else: - raise NotImplementedLayerRepresentationException( - f"Only Linear layers are supported, but found module {module} requiring grad." - ) + raise NotImplementedLayerRepresentationException(module_id=str(module)) return input_hook, grad_hook def _update_diag( From f7b282513a9a683c5ecf9318362c28a503969d2b Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Tue, 9 Jan 2024 10:37:47 +0100 Subject: [PATCH 44/87] update changelog and fix minor bug --- CHANGELOG.md | 4 +++- src/pydvl/influence/torch/influence_function_model.py | 2 +- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2809afe5e..afe61ac67 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,7 +9,9 @@ - Fix implementations of `to` methods of `TorchInfluenceFunctionModel` implementations [PR #487](https://github.com/aai-institute/pyDVL/pull/487) - Implement new method: `EkfacInfluence` - [PR #451](https://github.com/aai-institute/pyDVL/issues/451) + [PR #476](https://github.com/aai-institute/pyDVL/pull/476) +- New notebook to showcase ekfac for LLMs + [PR #483](https://github.com/aai-institute/pyDVL/pull/483) ## 0.8.0 - 🆕 New interfaces, scaling computation, bug fixes and improvements 🎁 diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index d2e005107..287291032 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -1392,7 +1392,7 @@ def _non_symmetric_values_by_layer( fac = self.influence_factors_by_layer(x, y) values = self.influences_from_factors_by_layer( fac, x_test, y_test, mode=mode - ).T + ) elif mode == InfluenceMode.Perturbation: fac = self.influence_factors_by_layer(x_test, y_test) values = self.influences_from_factors_by_layer(fac, x, y, mode=mode) From cdbd6b3e7554fcd4d62aacda6f9abc4e4462ea9b Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Sun, 14 Jan 2024 14:10:45 +0100 Subject: [PATCH 45/87] Move games.py module out of shapley package --- src/pydvl/value/{shapley => }/games.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename src/pydvl/value/{shapley => }/games.py (100%) diff --git a/src/pydvl/value/shapley/games.py b/src/pydvl/value/games.py similarity index 100% rename from src/pydvl/value/shapley/games.py rename to src/pydvl/value/games.py From 06352103d2613c7de858afae571018377dfe6cd8 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Sun, 14 Jan 2024 17:06:54 +0100 Subject: [PATCH 46/87] Reimplement games as classes --- src/pydvl/value/games.py | 595 ++++++++++++++++++++------------------- 1 file changed, 310 insertions(+), 285 deletions(-) diff --git a/src/pydvl/value/games.py b/src/pydvl/value/games.py index 21082bf11..020bb31d3 100644 --- a/src/pydvl/value/games.py +++ b/src/pydvl/value/games.py @@ -4,7 +4,8 @@ """ from __future__ import annotations -from dataclasses import dataclass +from abc import ABC, abstractmethod +from typing import Optional, Tuple import numpy as np import scipy as sp @@ -17,22 +18,16 @@ from pydvl.value import ValuationResult __all__ = [ - "symmetric_voting_game", - "asymmetric_voting_game", - "shoes_game", - "airport_game", - "minimum_spanning_tree_game", - "SolvedGame", + "Game", + "SymmetricVotingGame", + "AsymmetricVotingGame", + "ShoesGame", + "AirportGame", + "MinimumSpanningTreeGame", ] -@dataclass -class SolvedGame: - u: Utility - values: ValuationResult - - -def _dummy_dataset(num_samples: int, description: str) -> Dataset: +def _dummy_dataset(num_samples: int, description: Optional[str] = None) -> Dataset: x = np.arange(0, num_samples, 1).reshape(-1, 1) nil = np.zeros_like(x) return Dataset( @@ -61,297 +56,327 @@ def score(self, x: NDArray, y: NDArray) -> float: return 0 -def symmetric_voting_game(num_samples: int = 1000) -> SolvedGame: - """A symmetric voting game defined in :footcite:t:`castro_polynomial_2009` +class Game(ABC): + """Base class for games + + Any Game subclass has to implement the abstract `_score` method + to assign a score to each coalition/subset. + + It also has to define the `_shapley_values` and/or `_least_core_values` + attributes. + """ + + _shapley_values: ValuationResult | None = None + _least_core_values: ValuationResult | None = None + + def __init__( + self, + n_players: int, + score_range: Tuple[float, float] = (-np.inf, np.inf), + description: Optional[str] = None, + ): + self.n_players = n_players + self.data = _dummy_dataset(self.n_players, description) + self.u = Utility( + DummyModel(), + self.data, + scorer=Scorer(self._score, range=score_range), + catch_errors=False, + show_warnings=True, + ) + + def get_shapley_values(self) -> ValuationResult: + if self._shapley_values is None: + raise ValueError(f"Shapley values not implemented for {__class__.__name__}") + return self._shapley_values + + def get_least_core_values(self) -> ValuationResult: + if self._least_core_values is None: + raise ValueError( + f"Least core values not implemented for {__class__.__name__}" + ) + return self._least_core_values + + @abstractmethod + def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: + ... + + def __repr__(self) -> str: + return f"{self.__class__.__name__}(n_players={self.n_players})" + + +class SymmetricVotingGame(Game): + r"""Toy game that is used for testing and demonstration purposes. + + A symmetric voting game defined in :footcite:t:`castro_polynomial_2009` Section 4.1 Under this model the utility of a coalition is 1 if its cardinality is greater than num_samples/2, or 0 otherwise. """ - if num_samples % 2 != 0: - raise ValueError("num_samples must be an even number.") - - data = _dummy_dataset( - num_samples, "Dummy data for the symmetric voting game in Castro " "et al. 2009" - ) - - def symmetric_voting_score(model: SupervisedModel, X: NDArray, y: NDArray) -> float: - return 1 if len(X) > len(data) // 2 else 0 - u = Utility( - DummyModel(), - data, - scorer=Scorer(symmetric_voting_score, range=(0, 1)), - catch_errors=False, - show_warnings=True, - enable_cache=False, - ) - values: ValuationResult[np.int_, int] = ValuationResult( - algorithm="exact_shapley", - status=Status.Converged, - indices=data.indices, - values=np.ones_like(data.x_train) / len(data.x_train), - variances=np.zeros_like(data.x_train), - counts=np.zeros_like(data.x_train), - ) - - return SolvedGame(u, values) - - -def asymmetric_voting_game() -> SolvedGame: - """An asymmetric voting game defined in :footcite:t:`castro_polynomial_2009` + def __init__(self, n_players: int) -> None: + if n_players % 2 != 0: + raise ValueError("n_players must be an even number.") + description = "Dummy data for the symmetric voting game in Castro et al. 2009" + super().__init__( + n_players, + score_range=(0, 1), + description=description, + ) + + self._shapley_values: ValuationResult[np.int_, int] = ValuationResult( + algorithm="exact_shapley", + status=Status.Converged, + indices=self.data.indices, + values=np.ones_like(self.data.x_train) / len(self.data.x_train), + variances=np.zeros_like(self.data.x_train), + counts=np.zeros_like(self.data.x_train), + ) + + def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: + return 1 if len(X) > len(self.data) // 2 else 0 + + +class AsymmetricVotingGame(Game): + """Toy game that is used for testing and demonstration purposes. + + An asymmetric voting game defined in :footcite:t:`castro_polynomial_2009` Section 4.2. """ - n = 51 - ranges = [ - range(0, 1), - range(1, 2), - range(2, 3), - range(3, 5), - range(5, 6), - range(6, 7), - range(7, 9), - range(9, 10), - range(10, 12), - range(12, 15), - range(15, 16), - range(16, 20), - range(20, 24), - range(24, 26), - range(26, 30), - range(30, 34), - range(34, 35), - range(35, 44), - range(44, 51), - ] - - ranges_weights = [ - 45, - 41, - 27, - 26, - 25, - 21, - 17, - 14, - 13, - 12, - 11, - 10, - 9, - 8, - 7, - 6, - 5, - 4, - 3, - ] - ranges_values = [ - "0.08831", - "0.07973", - "0.05096", - "0.04898", - "0.047", - "0.03917", - "0.03147", - "0.02577", - "0.02388", - "0.022", - "0.02013", - "0.01827", - "0.01641", - "0.01456", - "0.01272", - "0.01088", - "0.009053", - "0.00723", - "0.005412", - ] - - weight_table = np.zeros(n) - exact_values = np.zeros(n) - for r, w, v in zip(ranges, ranges_weights, ranges_values): - weight_table[r] = w - exact_values[r] = v - - threshold = np.sum(weight_table) / 2 - - def assymetric_voting_game_score( - model: SupervisedModel, X: NDArray, y: NDArray - ) -> float: - return 1 if np.sum(weight_table[X]) > threshold else 0 - - data = _dummy_dataset( - n, "Dummy data for the asymmetric voting game in Castro et al. 2009" - ) - - u = Utility( - model=DummyModel(), - data=data, - scorer=Scorer(assymetric_voting_game_score, range=(0, 1)), - catch_errors=False, - show_warnings=True, - enable_cache=False, - ) - - values: ValuationResult[np.int_, int] = ValuationResult( - algorithm="exact_shapley", - status=Status.Converged, - indices=data.indices, - values=exact_values, - variances=np.zeros_like(data.x_train), - counts=np.zeros_like(data.x_train), - ) - - return SolvedGame(u, values) - -def shoes_game(num_samples: int = 1000) -> SolvedGame: - """A shoes game defined in :footcite:t:`castro_polynomial_2009` + def __init__(self, n_players: int = 51) -> None: + if n_players != 51: + raise ValueError( + f"{__class__.__name__} only supports n_players=51 but got {n_players=}." + ) + description = "Dummy data for the asymmetric voting game in Castro et al. 2009" + super().__init__( + n_players, + score_range=(0, 1), + description=description, + ) + + ranges = [ + range(0, 1), + range(1, 2), + range(2, 3), + range(3, 5), + range(5, 6), + range(6, 7), + range(7, 9), + range(9, 10), + range(10, 12), + range(12, 15), + range(15, 16), + range(16, 20), + range(20, 24), + range(24, 26), + range(26, 30), + range(30, 34), + range(34, 35), + range(35, 44), + range(44, 51), + ] + + ranges_weights = [ + 45, + 41, + 27, + 26, + 25, + 21, + 17, + 14, + 13, + 12, + 11, + 10, + 9, + 8, + 7, + 6, + 5, + 4, + 3, + ] + ranges_values = [ + "0.08831", + "0.07973", + "0.05096", + "0.04898", + "0.047", + "0.03917", + "0.03147", + "0.02577", + "0.02388", + "0.022", + "0.02013", + "0.01827", + "0.01641", + "0.01456", + "0.01272", + "0.01088", + "0.009053", + "0.00723", + "0.005412", + ] + + self.weight_table = np.zeros(self.n_players) + exact_values = np.zeros(self.n_players) + for r, w, v in zip(ranges, ranges_weights, ranges_values): + self.weight_table[r] = w + exact_values[r] = v + + self.threshold = np.sum(self.weight_table) / 2 + + self._shapley_values: ValuationResult[np.int_, int] = ValuationResult( + algorithm="exact_shapley", + status=Status.Converged, + indices=self.data.indices, + values=exact_values, + variances=np.zeros_like(self.data.x_train), + counts=np.zeros_like(self.data.x_train), + ) + + def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: + return 1 if np.sum(self.weight_table[X]) > self.threshold else 0 + + +class ShoesGame(Game): + """Toy game that is used for testing and demonstration purposes. + + A shoes game defined in :footcite:t:`castro_polynomial_2009` The utility of a coalition is the minimum of the number of left shoes or right shoes in a coalition. A player is a left shoe iff its index is among the first half, or a right shoe otherwise. """ - if num_samples % 2 != 0: - raise ValueError("num_samples must be an even number.") - - data = _dummy_dataset( - num_samples, "Dummy data for the shoe game in Castro et al. 2009" - ) - m = len(data) // 2 - - def shoe_game_score(model: SupervisedModel, X: NDArray, y: NDArray) -> float: - left_shoes = np.sum(X < m).item() - right_shoes = np.sum(X >= m).item() + def __init__(self, n_players: int) -> None: + if n_players % 2 != 0: + raise ValueError("n_players must be an even number.") + description = "Dummy data for the shoe game in Castro et al. 2009" + self.m = n_players // 2 + super().__init__(n_players, score_range=(0, self.m), description=description) + + self._shapley_values: ValuationResult[np.int_, int] = ValuationResult( + algorithm="exact_shapley", + status=Status.Converged, + indices=self.data.indices, + values=np.ones_like(self.data.x_train) * 0.5, + variances=np.zeros_like(self.data.x_train), + counts=np.zeros_like(self.data.x_train), + ) + + def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: + left_shoes = np.sum(X < self.m).item() + right_shoes = np.sum(X >= self.m).item() return min(left_shoes, right_shoes) - u = Utility( - model=DummyModel(), - data=data, - scorer=Scorer(shoe_game_score, range=(0, m)), - catch_errors=False, - show_warnings=True, - enable_cache=False, - ) - - values: ValuationResult[np.int_, int] = ValuationResult( - algorithm="exact_shapley", - status=Status.Converged, - indices=data.indices, - values=np.ones_like(data.x_train) * 0.5, - variances=np.zeros_like(data.x_train), - counts=np.zeros_like(data.x_train), - ) - - return SolvedGame(u, values) +class AirportGame(Game): + """Toy game that is used for testing and demonstration purposes. -def airport_game() -> SolvedGame: - """An airport game defined in :footcite:t:`castro_polynomial_2009`, + An airport game defined in :footcite:t:`castro_polynomial_2009`, Section 4.3""" - ranges = [ - range(0, 8), - range(8, 20), - range(20, 26), - range(26, 40), - range(40, 48), - range(48, 57), - range(57, 70), - range(70, 80), - range(80, 90), - range(90, 100), - ] - exact = [ - 0.01, - 0.020869565, - 0.033369565, - 0.046883079, - 0.063549745, - 0.082780515, - 0.106036329, - 0.139369662, - 0.189369662, - 0.289369662, - ] - c = list(range(1, 10)) - score_table = np.zeros(100) - exact_values = np.zeros(100) - - for r, v in zip(ranges, exact): - score_table[r] = c - exact_values[r] = v - - def airport_game_score(model: SupervisedModel, X: NDArray, y: NDArray) -> float: - return max(score_table[X]) or 0.0 - - data = _dummy_dataset(100, "A dummy dataset for...") - - u = Utility( - model=DummyModel(), - data=data, - scorer=Scorer(airport_game_score, range=(0, 100)), - catch_errors=False, - show_warnings=True, - enable_cache=False, - ) - values: ValuationResult[np.int_, int] = ValuationResult( - algorithm="exact_shapley", - status=Status.Converged, - indices=data.indices, - values=exact_values, - variances=np.zeros_like(data.x_train), - counts=np.zeros_like(data.x_train), - ) - - return SolvedGame(u, values) - - -def minimum_spanning_tree_game() -> SolvedGame: - data = _dummy_dataset(101, "A dummy dataset for...") - n = 101 - graph = np.zeros(shape=(n, n)) - - for i in range(n): - for j in range(n): - if ( - i == j + 1 - or i == j - 1 - or (i == 1 and j == n - 1) - or (i == n - 1 and j == 1) - ): - graph[i, j] = 1 - elif i == 0 or j == 0: - graph[i, j] = 0 - else: - graph[i, j] = np.inf - assert np.all(graph == graph.T) - - def minimum_spanning_tree_score( - model: SupervisedModel, X: NDArray, y: NDArray - ) -> float: - partial_graph = sp.sparse.csr_array(graph[np.ix_(X, X)]) + def __init__(self, n_players: int = 100) -> None: + if n_players != 100: + raise ValueError( + f"{__class__.__name__} only supports n_players=100 but got {n_players=}." + ) + description = "A dummy dataset for the airport game in Castro et al. 2009" + super().__init__(n_players, score_range=(0, 100), description=description) + ranges = [ + range(0, 8), + range(8, 20), + range(20, 26), + range(26, 40), + range(40, 48), + range(48, 57), + range(57, 70), + range(70, 80), + range(80, 90), + range(90, 100), + ] + exact = [ + 0.01, + 0.020869565, + 0.033369565, + 0.046883079, + 0.063549745, + 0.082780515, + 0.106036329, + 0.139369662, + 0.189369662, + 0.289369662, + ] + c = list(range(1, 10)) + score_table = np.zeros(100) + exact_values = np.zeros(100) + + for r, v in zip(ranges, exact): + score_table[r] = c + exact_values[r] = v + + self.score_table = score_table + self._shapley_values: ValuationResult[np.int_, int] = ValuationResult( + algorithm="exact_shapley", + status=Status.Converged, + indices=self.data.indices, + values=exact_values, + variances=np.zeros_like(self.data.x_train), + counts=np.zeros_like(self.data.x_train), + ) + + def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: + return max(self.score_table[X]) or 0.0 + + +class MinimumSpanningTreeGame(Game): + """Toy game that is used for testing and demonstration purposes.""" + + def __init__(self, n_players: int = 101) -> None: + if n_players != 101: + raise ValueError( + f"{__class__.__name__} only supports n_players=101 but got {n_players=}." + ) + description = ( + "A dummy dataset for the minimum spanning tree game in Castro et al. 2009" + ) + super().__init__(n_players, score_range=(0, np.inf), description=description) + + graph = np.zeros(shape=(self.n_players, self.n_players)) + + for i in range(self.n_players): + for j in range(self.n_players): + if ( + i == j + 1 + or i == j - 1 + or (i == 1 and j == self.n_players - 1) + or (i == self.n_players - 1 and j == 1) + ): + graph[i, j] = 1 + elif i == 0 or j == 0: + graph[i, j] = 0 + else: + graph[i, j] = np.inf + assert np.all(graph == graph.T) + + exact_values = 2 * np.ones_like(self.data.x_train) + + self.graph = graph + self._shapley_values: ValuationResult[np.int_, int] = ValuationResult( + algorithm="exact_shapley", + status=Status.Converged, + indices=self.data.indices, + values=exact_values, + variances=np.zeros_like(self.data.x_train), + counts=np.zeros_like(self.data.x_train), + ) + + def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: + partial_graph = sp.sparse.csr_array(self.graph[np.ix_(X, X)]) span_tree = sp.sparse.csgraph.minimum_spanning_tree(partial_graph) return span_tree.sum() or 0 - - u = Utility( - model=DummyModel(), - data=data, - scorer=Scorer(minimum_spanning_tree_score, range=(0, np.inf)), - catch_errors=False, - show_warnings=True, - enable_cache=False, - ) - - values: ValuationResult[np.int_, int] = ValuationResult( - algorithm="exact_shapley", - status=Status.Converged, - indices=data.indices, - values=2 * np.ones_like(data.x_train), - variances=np.zeros_like(data.x_train), - counts=np.zeros_like(data.x_train), - ) - - return SolvedGame(u, values) From 64756393ee6ad9839b02b090882f8fbd810d258d Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 15 Jan 2024 11:01:43 +0100 Subject: [PATCH 47/87] Create DummyGameDataset class to fix dataset handling in games, slightly change Game interface --- src/pydvl/value/games.py | 156 +++++++++++++++++++++++---------------- 1 file changed, 94 insertions(+), 62 deletions(-) diff --git a/src/pydvl/value/games.py b/src/pydvl/value/games.py index 020bb31d3..c6d080a06 100644 --- a/src/pydvl/value/games.py +++ b/src/pydvl/value/games.py @@ -5,7 +5,8 @@ from __future__ import annotations from abc import ABC, abstractmethod -from typing import Optional, Tuple +from functools import lru_cache +from typing import Iterable, Optional, Tuple import numpy as np import scipy as sp @@ -27,18 +28,36 @@ ] -def _dummy_dataset(num_samples: int, description: Optional[str] = None) -> Dataset: - x = np.arange(0, num_samples, 1).reshape(-1, 1) - nil = np.zeros_like(x) - return Dataset( - x, - nil.copy(), - nil.copy(), - nil.copy(), - feature_names=["x"], - target_names=["y"], - description=description, - ) +class DummyGameDataset(Dataset): + def __init__(self, n_players: int, description: Optional[str] = None) -> None: + x = np.arange(0, n_players, 1).reshape(-1, 1) + nil = np.zeros_like(x) + super().__init__( + x, + nil.copy(), + nil.copy(), + nil.copy(), + feature_names=["x"], + target_names=["y"], + description=description, + ) + + def get_test_data( + self, indices: Optional[Iterable[int]] = None + ) -> Tuple[NDArray, NDArray]: + """Returns the subsets of the train set instead of the test set. + + Args: + indices: Indices into the traing data. + + Returns: + Subset of the train data. + """ + if indices is None: + return self.x_train, self.y_train + x = self.x_train[indices] + y = self.y_train[indices] + return x, y class DummyModel(SupervisedModel): @@ -49,7 +68,7 @@ def fit(self, x: NDArray, y: NDArray): pass def predict(self, x: NDArray) -> NDArray: - return x + pass def score(self, x: NDArray, y: NDArray) -> float: # Dummy, will be overriden @@ -60,15 +79,10 @@ class Game(ABC): """Base class for games Any Game subclass has to implement the abstract `_score` method - to assign a score to each coalition/subset. - - It also has to define the `_shapley_values` and/or `_least_core_values` - attributes. + to assign a score to each coalition/subset and at least + one of `shapley_values`, `least_core_values`. """ - _shapley_values: ValuationResult | None = None - _least_core_values: ValuationResult | None = None - def __init__( self, n_players: int, @@ -76,7 +90,7 @@ def __init__( description: Optional[str] = None, ): self.n_players = n_players - self.data = _dummy_dataset(self.n_players, description) + self.data = DummyGameDataset(self.n_players, description) self.u = Utility( DummyModel(), self.data, @@ -85,17 +99,15 @@ def __init__( show_warnings=True, ) - def get_shapley_values(self) -> ValuationResult: - if self._shapley_values is None: - raise ValueError(f"Shapley values not implemented for {__class__.__name__}") - return self._shapley_values + def shapley_values(self) -> ValuationResult: + raise NotImplementedError( + f"shapley_values method was not implemented for class {__class__.__name__}" + ) - def get_least_core_values(self) -> ValuationResult: - if self._least_core_values is None: - raise ValueError( - f"Least core values not implemented for {__class__.__name__}" - ) - return self._least_core_values + def least_core_values(self) -> ValuationResult: + raise NotImplementedError( + f"least_core_values method was not implemented for class {__class__.__name__}" + ) @abstractmethod def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: @@ -125,17 +137,21 @@ def __init__(self, n_players: int) -> None: description=description, ) - self._shapley_values: ValuationResult[np.int_, int] = ValuationResult( + def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: + return 1 if len(X) > len(self.data) // 2 else 0 + + @lru_cache + def shapley_values(self) -> ValuationResult: + exact_values = np.ones_like(self.data.x_train) / len(self.data.x_train) + result: ValuationResult[np.int_, int] = ValuationResult( algorithm="exact_shapley", status=Status.Converged, indices=self.data.indices, - values=np.ones_like(self.data.x_train) / len(self.data.x_train), + values=exact_values, variances=np.zeros_like(self.data.x_train), counts=np.zeros_like(self.data.x_train), ) - - def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: - return 1 if len(X) > len(self.data) // 2 else 0 + return result class AsymmetricVotingGame(Game): @@ -228,19 +244,23 @@ def __init__(self, n_players: int = 51) -> None: self.weight_table[r] = w exact_values[r] = v + self.exact_values = exact_values self.threshold = np.sum(self.weight_table) / 2 - self._shapley_values: ValuationResult[np.int_, int] = ValuationResult( + def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: + return 1 if np.sum(self.weight_table[X]) > self.threshold else 0 + + @lru_cache + def shapley_values(self) -> ValuationResult: + result: ValuationResult[np.int_, int] = ValuationResult( algorithm="exact_shapley", status=Status.Converged, indices=self.data.indices, - values=exact_values, + values=self.exact_values, variances=np.zeros_like(self.data.x_train), counts=np.zeros_like(self.data.x_train), ) - - def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: - return 1 if np.sum(self.weight_table[X]) > self.threshold else 0 + return result class ShoesGame(Game): @@ -260,19 +280,23 @@ def __init__(self, n_players: int) -> None: self.m = n_players // 2 super().__init__(n_players, score_range=(0, self.m), description=description) - self._shapley_values: ValuationResult[np.int_, int] = ValuationResult( + def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: + left_shoes = np.sum(X < self.m).item() + right_shoes = np.sum(X >= self.m).item() + return min(left_shoes, right_shoes) + + @lru_cache + def shapley_values(self) -> ValuationResult: + exact_values = np.ones_like(self.data.x_train) * 0.5 + result: ValuationResult[np.int_, int] = ValuationResult( algorithm="exact_shapley", status=Status.Converged, indices=self.data.indices, - values=np.ones_like(self.data.x_train) * 0.5, + values=exact_values, variances=np.zeros_like(self.data.x_train), counts=np.zeros_like(self.data.x_train), ) - - def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: - left_shoes = np.sum(X < self.m).item() - right_shoes = np.sum(X >= self.m).item() - return min(left_shoes, right_shoes) + return result class AirportGame(Game): @@ -320,18 +344,23 @@ def __init__(self, n_players: int = 100) -> None: score_table[r] = c exact_values[r] = v + self.exact_values = exact_values self.score_table = score_table - self._shapley_values: ValuationResult[np.int_, int] = ValuationResult( + + def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: + return max(self.score_table[X]) or 0.0 + + @lru_cache + def shapley_values(self) -> ValuationResult: + result: ValuationResult[np.int_, int] = ValuationResult( algorithm="exact_shapley", status=Status.Converged, indices=self.data.indices, - values=exact_values, + values=self.exact_values, variances=np.zeros_like(self.data.x_train), counts=np.zeros_like(self.data.x_train), ) - - def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: - return max(self.score_table[X]) or 0.0 + return result class MinimumSpanningTreeGame(Game): @@ -364,10 +393,17 @@ def __init__(self, n_players: int = 101) -> None: graph[i, j] = np.inf assert np.all(graph == graph.T) - exact_values = 2 * np.ones_like(self.data.x_train) - self.graph = graph - self._shapley_values: ValuationResult[np.int_, int] = ValuationResult( + + def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: + partial_graph = sp.sparse.csr_array(self.graph[np.ix_(X, X)]) + span_tree = sp.sparse.csgraph.minimum_spanning_tree(partial_graph) + return span_tree.sum() or 0 + + @lru_cache + def shapley_values(self) -> ValuationResult: + exact_values = 2 * np.ones_like(self.data.x_train) + result: ValuationResult[np.int_, int] = ValuationResult( algorithm="exact_shapley", status=Status.Converged, indices=self.data.indices, @@ -375,8 +411,4 @@ def __init__(self, n_players: int = 101) -> None: variances=np.zeros_like(self.data.x_train), counts=np.zeros_like(self.data.x_train), ) - - def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: - partial_graph = sp.sparse.csr_array(self.graph[np.ix_(X, X)]) - span_tree = sp.sparse.csgraph.minimum_spanning_tree(partial_graph) - return span_tree.sum() or 0 + return result From 865c378c49dbaf1459c46509223bbe2b66befdd1 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 15 Jan 2024 11:02:52 +0100 Subject: [PATCH 48/87] Implement Miner and Gloves games using new Game interface --- src/pydvl/utils/utility.py | 117 ------------------- src/pydvl/value/games.py | 135 ++++++++++++++++++++++ tests/value/least_core/conftest.py | 27 +---- tests/value/least_core/test_common.py | 15 +-- tests/value/least_core/test_montecarlo.py | 13 +-- tests/value/least_core/test_naive.py | 14 +-- 6 files changed, 162 insertions(+), 159 deletions(-) diff --git a/src/pydvl/utils/utility.py b/src/pydvl/utils/utility.py index b975c0ff2..bd25a564e 100644 --- a/src/pydvl/utils/utility.py +++ b/src/pydvl/utils/utility.py @@ -356,120 +356,3 @@ def __call__(self, indices: Iterable[int]) -> float: def data(self) -> Dataset: """Returns the wrapped utility's [Dataset][pydvl.utils.dataset.Dataset].""" return self.utility.data - - -class MinerGameUtility(Utility): - r"""Toy game utility that is used for testing and demonstration purposes. - - Consider a group of n miners, who have discovered large bars of gold. - - If two miners can carry one piece of gold, then the payoff of a - coalition $S$ is: - - $${ - v(S) = \left\{\begin{array}{lll} - \mid S \mid / 2 & \text{, if} & \mid S \mid \text{ is even} \\ - ( \mid S \mid - 1)/2 & \text{, if} & \mid S \mid \text{ is odd} - \end{array}\right. - }$$ - - If there are more than two miners and there is an even number of miners, - then the core consists of the single payoff where each miner gets 1/2. - - If there is an odd number of miners, then the core is empty. - - Taken from [Wikipedia](https://en.wikipedia.org/wiki/Core_(game_theory)) - - Args: - n_miners: Number of miners that participate in the game. - """ - - def __init__(self, n_miners: int, **kwargs): - if n_miners <= 2: - raise ValueError(f"n_miners, {n_miners} should be > 2") - self.n_miners = n_miners - - x = np.arange(n_miners)[..., np.newaxis] - # The y values don't matter here - y = np.zeros_like(x) - - self.data = Dataset(x_train=x, y_train=y, x_test=x, y_test=y) - - def __call__(self, indices: Iterable[int]) -> float: - n = len(tuple(indices)) - if n % 2 == 0: - return n / 2 - else: - return (n - 1) / 2 - - def _initialize_utility_wrapper(self): - pass - - def exact_least_core_values(self) -> Tuple[NDArray[np.float_], float]: - if self.n_miners % 2 == 0: - values = np.array([0.5] * self.n_miners) - subsidy = 0.0 - else: - values = np.array( - [(self.n_miners - 1) / (2 * self.n_miners)] * self.n_miners - ) - subsidy = (self.n_miners - 1) / (2 * self.n_miners) - return values, subsidy - - def __repr__(self) -> str: - return f"{self.__class__.__name__}(n={self.n_miners})" - - -class GlovesGameUtility(Utility): - r"""Toy game utility that is used for testing and demonstration purposes. - - In this game, some players have a left glove and others a right glove. - Single gloves have a worth of zero while pairs have a worth of 1. - - The payoff of a coalition $S$ is: - - $${ - v(S) = \min( \mid S \cap L \mid, \mid S \cap R \mid ) - }$$ - - Where $L$, respectively $R$, is the set of players with left gloves, - respectively right gloves. - - Args: - left: Number of players with a left glove. - right: Number of player with a right glove. - - """ - - def __init__(self, left: int, right: int, **kwargs): - self.left = left - self.right = right - - x = np.empty(left + right)[..., np.newaxis] - # The y values don't matter here - y = np.zeros_like(x) - - self.data = Dataset(x_train=x, y_train=y, x_test=x, y_test=y) - - def __call__(self, indices: Iterable[int]) -> float: - left_sum = float(np.sum(np.asarray(indices) < self.left)) - right_sum = float(np.sum(np.asarray(indices) >= self.left)) - return min(left_sum, right_sum) - - def _initialize_utility_wrapper(self): - pass - - def exact_least_core_values(self) -> Tuple[NDArray[np.float_], float]: - if self.left == self.right: - subsidy = -0.5 - values = np.array([0.5] * (self.left + self.right)) - elif self.left < self.right: - subsidy = 0.0 - values = np.array([1.0] * self.left + [0.0] * self.right) - else: - subsidy = 0.0 - values = np.array([0.0] * self.left + [1.0] * self.right) - return values, subsidy - - def __repr__(self) -> str: - return f"{self.__class__.__name__}(L={self.left}, R={self.right})" diff --git a/src/pydvl/value/games.py b/src/pydvl/value/games.py index c6d080a06..7ed33a833 100644 --- a/src/pydvl/value/games.py +++ b/src/pydvl/value/games.py @@ -25,6 +25,8 @@ "ShoesGame", "AirportGame", "MinimumSpanningTreeGame", + "MinerGame", + "GlovesGame", ] @@ -412,3 +414,136 @@ def shapley_values(self) -> ValuationResult: counts=np.zeros_like(self.data.x_train), ) return result + + +class MinerGame(Game): + r"""Toy game that is used for testing and demonstration purposes. + + Consider a group of n miners, who have discovered large bars of gold. + + If two miners can carry one piece of gold, then the payoff of a + coalition $S$ is: + + $${ + v(S) = \left\{\begin{array}{lll} + \mid S \mid / 2 & \text{, if} & \mid S \mid \text{ is even} \\ + ( \mid S \mid - 1)/2 & \text{, if} & \mid S \mid \text{ is odd} + \end{array}\right. + }$$ + + If there are more than two miners and there is an even number of miners, + then the core consists of the single payoff where each miner gets 1/2. + + If there is an odd number of miners, then the core is empty. + + Taken from [Wikipedia](https://en.wikipedia.org/wiki/Core_(game_theory)) + + Args: + n_players: Number of miners that participate in the game. + """ + + def __init__(self, n_players: int) -> None: + if n_players <= 2: + raise ValueError(f"n_players, {n_players}, should be > 2") + description = "Dummy data for Miner Game taken from https://en.wikipedia.org/wiki/Core_(game_theory)" + super().__init__( + n_players, + score_range=(0, n_players // 2), + description=description, + ) + + def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: + n = len(X) + if n % 2 == 0: + return n / 2 + else: + return (n - 1) / 2 + + @lru_cache() + def least_core_values(self) -> ValuationResult: + if self.n_players % 2 == 0: + values = np.array([0.5] * self.n_players) + subsidy = 0.0 + else: + values = np.array( + [(self.n_players - 1) / (2 * self.n_players)] * self.n_players + ) + subsidy = (self.n_players - 1) / (2 * self.n_players) + + result: ValuationResult[np.int_, int] = ValuationResult( + algorithm="exact_least_core", + status=Status.Converged, + indices=self.data.indices, + values=values, + subsidy=subsidy, + variances=np.zeros_like(self.data.x_train), + counts=np.zeros_like(self.data.x_train), + ) + return result + + def __repr__(self) -> str: + return f"{self.__class__.__name__}(n={self.n_players})" + + +class GlovesGame(Game): + r"""Toy game that is used for testing and demonstration purposes. + + In this game, some players have a left glove and others a right glove. + Single gloves have a worth of zero while pairs have a worth of 1. + + The payoff of a coalition $S$ is: + + $${ + v(S) = \min( \mid S \cap L \mid, \mid S \cap R \mid ) + }$$ + + Where $L$, respectively $R$, is the set of players with left gloves, + respectively right gloves. + + Args: + left: Number of players with a left glove. + right: Number of player with a right glove. + + """ + + def __init__(self, left: int, right: int): + description = "Dummy data for Gloves Game" + self.left = left + self.right = right + n_players = self.left + self.right + super().__init__( + n_players, + score_range=(0, min(self.left, self.right)), + description=description, + ) + + def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: + left_sum = float(np.sum(np.asarray(X) < self.left)) + right_sum = float(np.sum(np.asarray(X) >= self.left)) + return min(left_sum, right_sum) + + @lru_cache + def least_core_values(self) -> ValuationResult: + if self.left == self.right: + subsidy = -0.5 + values = np.array([0.5] * (self.left + self.right)) + elif self.left < self.right: + subsidy = 0.0 + values = np.array([1.0] * self.left + [0.0] * self.right) + else: + subsidy = 0.0 + values = np.array([0.0] * self.left + [1.0] * self.right) + + result: ValuationResult[np.int_, int] = ValuationResult( + algorithm="exact_least_core", + status=Status.Converged, + indices=self.data.indices, + values=values, + subsidy=subsidy, + variances=np.zeros_like(self.data.x_train), + counts=np.zeros_like(self.data.x_train), + ) + return result + + def __repr__(self) -> str: + return f"{self.__class__.__name__}(L={self.left}, R={self.right})" diff --git a/tests/value/least_core/conftest.py b/tests/value/least_core/conftest.py index 2355c443a..df24a6f3a 100644 --- a/tests/value/least_core/conftest.py +++ b/tests/value/least_core/conftest.py @@ -1,30 +1,15 @@ -from typing import Tuple - -import numpy as np import pytest -from pydvl.utils import Utility -from pydvl.utils.status import Status -from pydvl.utils.utility import GlovesGameUtility, MinerGameUtility -from pydvl.value.result import ValuationResult +from pydvl.value.games import Game, GlovesGame, MinerGame @pytest.fixture(scope="module") -def test_utility(request) -> Tuple[Utility, ValuationResult]: +def test_game(request) -> Game: name, kwargs = request.param if name == "miner": - u = MinerGameUtility(**kwargs) + game = MinerGame(n_players=kwargs["n_players"]) elif name == "gloves": - u = GlovesGameUtility(**kwargs) + game = GlovesGame(left=kwargs["left"], right=kwargs["right"]) else: - raise ValueError(f"Unknown '{name}'") - exact_values, subsidy = u.exact_least_core_values() - result = ValuationResult( - algorithm="exact", - values=exact_values, - subsidy=subsidy, - variances=np.zeros_like(exact_values), - data_names=np.arange(len(exact_values)), - status=Status.Converged, - ) - return u, result + raise ValueError(f"Unknown game '{name}'") + return game diff --git a/tests/value/least_core/test_common.py b/tests/value/least_core/test_common.py index feadeb954..6add2d12a 100644 --- a/tests/value/least_core/test_common.py +++ b/tests/value/least_core/test_common.py @@ -8,29 +8,30 @@ @pytest.mark.parametrize( - "test_utility", - [("miner", {"n_miners": 5})], + "test_game", + [("miner", {"n_players": 5})], indirect=True, ) -def test_lc_solve_problems(test_utility, n_jobs, parallel_config): +def test_lc_solve_problems(test_game, n_jobs, parallel_config): """Test solving LeastCoreProblems in parallel.""" - u, exact_values = test_utility n_problems = n_jobs - problem = lc_prepare_problem(u) + problem = lc_prepare_problem(test_game.u) solutions = lc_solve_problems( [problem] * n_problems, - u, + test_game.u, algorithm="test_lc", n_jobs=n_jobs, config=parallel_config, ) assert len(solutions) == n_problems + exact_values = test_game.least_core_values() + for solution in solutions: assert solution.status == Status.Converged check_values(solution, exact_values, rtol=0.01) - check = lc_solve_problem(problem, u=u, algorithm="test_lc") + check = lc_solve_problem(problem, u=test_game.u, algorithm="test_lc") assert check.status == Status.Converged check_values(solution, check, rtol=0.01) diff --git a/tests/value/least_core/test_montecarlo.py b/tests/value/least_core/test_montecarlo.py index 38d675e0d..9fff3b044 100644 --- a/tests/value/least_core/test_montecarlo.py +++ b/tests/value/least_core/test_montecarlo.py @@ -10,28 +10,27 @@ @pytest.mark.parametrize( - "test_utility, rtol, n_iterations", + "test_game, rtol, n_iterations", [ - (("miner", {"n_miners": 8}), 0.1, 128), + (("miner", {"n_players": 8}), 0.1, 128), (("gloves", {"left": 10, "right": 5}), 0.2, 10000), ], - indirect=["test_utility"], + indirect=["test_game"], ) @pytest.mark.parametrize("n_jobs", [1, -1]) @pytest.mark.parametrize("non_negative_subsidy", (True, False)) def test_montecarlo_least_core( - test_utility, rtol, n_iterations, n_jobs, non_negative_subsidy, seed + test_game, rtol, n_iterations, n_jobs, non_negative_subsidy, seed ): - u, exact_values = test_utility - values = montecarlo_least_core( - u, + test_game.u, n_iterations=n_iterations, non_negative_subsidy=non_negative_subsidy, progress=False, n_jobs=n_jobs, seed=seed, ) + exact_values = test_game.least_core_values() if non_negative_subsidy: check_values(values, exact_values) # Sometimes the subsidy is negative but really close to zero diff --git a/tests/value/least_core/test_naive.py b/tests/value/least_core/test_naive.py index 28a79e381..4a2305e2e 100644 --- a/tests/value/least_core/test_naive.py +++ b/tests/value/least_core/test_naive.py @@ -6,10 +6,10 @@ @pytest.mark.parametrize( - "test_utility", + "test_game", [ - ("miner", {"n_miners": 3}), - ("miner", {"n_miners": 4}), + ("miner", {"n_players": 3}), + ("miner", {"n_players": 4}), ("gloves", {"left": 1, "right": 1}), ("gloves", {"left": 2, "right": 1}), ("gloves", {"left": 1, "right": 2}), @@ -17,12 +17,12 @@ indirect=True, ) @pytest.mark.parametrize("non_negative_subsidy", (True, False)) -def test_naive_least_core(test_utility, non_negative_subsidy): - u, exact_values = test_utility +def test_naive_least_core(test_game, non_negative_subsidy): values = exact_least_core( - u, non_negative_subsidy=non_negative_subsidy, progress=False + test_game.u, non_negative_subsidy=non_negative_subsidy, progress=False ) - check_total_value(u, values) + check_total_value(test_game.u, values) + exact_values = test_game.least_core_values() if non_negative_subsidy: check_values(values, exact_values) # Sometimes the subsidy is negative but really close to zero From a90f0414ccbbe3c213e2b4964c4d9f9f9e79a3f3 Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Mon, 15 Jan 2024 16:48:34 +0100 Subject: [PATCH 49/87] addressing PR comments --- notebooks/influence_sentiment_analysis.ipynb | 107 +++++-------------- notebooks/support/torch.py | 42 ++++++++ 2 files changed, 67 insertions(+), 82 deletions(-) diff --git a/notebooks/influence_sentiment_analysis.ipynb b/notebooks/influence_sentiment_analysis.ipynb index 9cdb28347..8604bd02a 100644 --- a/notebooks/influence_sentiment_analysis.ipynb +++ b/notebooks/influence_sentiment_analysis.ipynb @@ -83,16 +83,19 @@ } ], "source": [ - "from datasets import load_dataset\n", - "import torch\n", - "from sklearn.metrics import f1_score\n", + "from copy import deepcopy\n", "from typing import Sequence\n", - "from pydvl.influence.torch import EkfacInfluence\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", "import torch.nn.functional as F\n", - "from transformers import AutoTokenizer, AutoModelForSequenceClassification\n", - "from copy import deepcopy\n", + "from datasets import load_dataset\n", "from IPython.display import HTML, display\n", - "import matplotlib.pyplot as plt" + "from sklearn.metrics import f1_score\n", + "from transformers import AutoModelForSequenceClassification, AutoTokenizer\n", + "\n", + "from pydvl.influence.torch import EkfacInfluence\n", + "from support.torch import ImdbDataset, ModelLogitsWrapper" ] }, { @@ -156,8 +159,9 @@ "name": "stderr", "output_type": "stream", "text": [ + "Using the latest cached version of the module from /Users/fabio/.cache/huggingface/modules/datasets_modules/datasets/imdb/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0 (last modified on Thu Dec 14 21:47:25 2023) since it couldn't be found locally at imdb., or remotely on the Hugging Face Hub.\n", "Found cached dataset imdb (/Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0)\n", - "100%|██████████| 3/3 [00:00<00:00, 136.16it/s]\n" + "100%|██████████| 3/3 [00:00<00:00, 111.43it/s]\n" ] } ], @@ -265,18 +269,11 @@ "tokenized_example = tokenizer(\n", " [example_phrase],\n", " return_tensors=\"pt\",\n", - " padding=True,\n", " truncation=True,\n", ")\n", "\n", - "tokenized_example_input_ids, tokenized_example_attention_mask = (\n", - " tokenized_example.input_ids,\n", - " tokenized_example.attention_mask,\n", - ")\n", - "\n", "model_output = model(\n", - " input_ids=tokenized_example_input_ids,\n", - " attention_mask=tokenized_example_attention_mask,\n", + " input_ids=tokenized_example.input_ids,\n", ")" ] }, @@ -322,13 +319,7 @@ "metadata": {}, "outputs": [], "source": [ - "model_predictions = F.softmax(\n", - " model(\n", - " input_ids=tokenized_example_input_ids,\n", - " attention_mask=tokenized_example_attention_mask,\n", - " )[\"logits\"],\n", - " dim=1,\n", - ")" + "model_predictions = F.softmax(model_output.logits, dim=1)" ] }, { @@ -386,7 +377,7 @@ "output_type": "stream", "text": [ "Loading cached shuffled indices for dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-c1eaa46e94dfbfd3.arrow\n", - "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-c5cc0d728c27151c.arrow\n" + "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-5dd4cdcbaa0bcc93.arrow\n" ] } ], @@ -402,7 +393,7 @@ " logits = model(\n", " input_ids=sample_test_set[\"input_ids\"],\n", " attention_mask=sample_test_set[\"attention_mask\"],\n", - " )[0]\n", + " ).logits\n", " predictions = torch.argmax(logits, dim=1)" ] }, @@ -435,7 +426,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In this section we will define several helper function and classes that will be used in the rest of the notebook. " + "In this section we will define two helper function and classes that will be used in the rest of the notebook. " ] }, { @@ -444,47 +435,6 @@ "metadata": {}, "outputs": [], "source": [ - "class ImdbDataset(torch.utils.data.Dataset):\n", - " \"\"\"\n", - " A PyTorch Dataset that takes in an HuggingFace Dataset object and tokenizes it.\n", - " The objects returned by __getitem__ are PyTorch tensors, with x being a tuple of\n", - " (input_ids, attention_mask), ready to be fed into a model, and y being the label.\n", - " It also returns the original text, for printing and debugging purposes.\n", - " \"\"\"\n", - "\n", - " def __init__(self, dataset):\n", - " self.tokenized_ds = dataset.map(self.preprocess_function, batched=True)\n", - " self.encodings = self.tokenized_ds[\"input_ids\"]\n", - " self.attn_mask = self.tokenized_ds[\"attention_mask\"]\n", - " self.labels = self.tokenized_ds[\"label\"]\n", - "\n", - " def preprocess_function(self, examples):\n", - " return tokenizer(examples[\"text\"], truncation=True, padding=True)\n", - "\n", - " def __getitem__(self, idx):\n", - " x = torch.tensor([self.encodings[idx], self.attn_mask[idx]])\n", - " y = torch.tensor(self.labels[idx])\n", - " text = self.tokenized_ds[idx][\"text\"]\n", - " return x, y, text\n", - "\n", - " def __len__(self):\n", - " return len(self.labels)\n", - "\n", - "\n", - "class ModelLogitsWrapper(torch.nn.Module):\n", - " \"\"\"\n", - " A wrapper around a PyTorch model that returns only the logits and not the loss or\n", - " the attention mask.\n", - " \"\"\"\n", - "\n", - " def __init__(self, model):\n", - " super().__init__()\n", - " self.model = model\n", - "\n", - " def forward(self, x):\n", - " return self.model(x[:, 0], x[:, 1])[\"logits\"]\n", - "\n", - "\n", "def print_sentiment_preds(\n", " model: ModelLogitsWrapper, model_input: torch.Tensor, true_label: int\n", "):\n", @@ -620,8 +570,8 @@ "text": [ "Loading cached shuffled indices for dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-9c48ce5d173413c7.arrow\n", "Loading cached shuffled indices for dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-c1eaa46e94dfbfd3.arrow\n", - "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-9aaaa3770ef3f9bf.arrow\n", - "Loading cached processed dataset at /Users/fabio/.cache/huggingface/datasets/imdb/plain_text/1.0.0/d613c88cf8fa3bab83b4ded3713f1f74830d1100e171db75bbddb80b3345c9c0/cache-7a8cbae367cafa72.arrow\n" + " 0%| | 0/1 [00:00 Losses: return pkl.load(file) +class ImdbDataset(torch.utils.data.Dataset): + """ + A PyTorch Dataset that takes in an HuggingFace Dataset object and tokenizes it. + The objects returned by __getitem__ are PyTorch tensors, with x being a tuple of + (input_ids, attention_mask), ready to be fed into a model, and y being the label. + It also returns the original text, for printing and debugging purposes. + """ + + def __init__(self, dataset, tokenizer): + self.tokenizer = tokenizer + self.tokenized_ds = dataset.map(self.preprocess_function, batched=True) + self.encodings = self.tokenized_ds["input_ids"] + self.attn_mask = self.tokenized_ds["attention_mask"] + self.labels = self.tokenized_ds["label"] + + def preprocess_function(self, examples): + return self.tokenizer(examples["text"], truncation=True, padding=True) + + def __getitem__(self, idx): + x = torch.tensor([self.encodings[idx], self.attn_mask[idx]]) + y = torch.tensor(self.labels[idx]) + text = self.tokenized_ds[idx]["text"] + return x, y, text + + def __len__(self): + return len(self.labels) + + +class ModelLogitsWrapper(torch.nn.Module): + """ + A wrapper around a PyTorch model that returns only the logits and not the loss or + the attention mask. + """ + + def __init__(self, model): + super().__init__() + self.model = model + + def forward(self, x): + return self.model(x[:, 0], x[:, 1]).logits + + def process_imgnet_io( df: pd.DataFrame, labels: dict ) -> Tuple[torch.Tensor, torch.Tensor]: From aa0931a9258da96e3fcb30facc0342e63adce54c Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 15 Jan 2024 20:10:57 +0100 Subject: [PATCH 50/87] Delete GlovesGame in favor of ShoesGame, improve Game classes' docstrings --- src/pydvl/utils/utility.py | 2 +- src/pydvl/value/games.py | 202 ++++++++++++---------- tests/value/least_core/conftest.py | 6 +- tests/value/least_core/test_montecarlo.py | 2 +- tests/value/least_core/test_naive.py | 6 +- 5 files changed, 123 insertions(+), 95 deletions(-) diff --git a/src/pydvl/utils/utility.py b/src/pydvl/utils/utility.py index bd25a564e..1afbfdeb3 100644 --- a/src/pydvl/utils/utility.py +++ b/src/pydvl/utils/utility.py @@ -38,7 +38,7 @@ from pydvl.utils.score import Scorer from pydvl.utils.types import SupervisedModel -__all__ = ["Utility", "DataUtilityLearning", "MinerGameUtility", "GlovesGameUtility"] +__all__ = ["Utility", "DataUtilityLearning"] logger = logging.getLogger(__name__) diff --git a/src/pydvl/value/games.py b/src/pydvl/value/games.py index 7ed33a833..092d4b08a 100644 --- a/src/pydvl/value/games.py +++ b/src/pydvl/value/games.py @@ -1,6 +1,14 @@ """ -This module provides several predefined games and their Shapley values, for +This module provides several predefined games and, depending on the game, +the corresponding Shapley values, Least Core values or both of them, for benchmarking purposes. + +## References + +[^1]: Castro, J., Gómez, D. and Tejada, J., 2009. + [Polynomial calculation of the Shapley value based on sampling](http://www.sciencedirect.com/science/article/pii/S0305054808000804). + Computers & Operations Research, 36(5), pp.1726-1730. + """ from __future__ import annotations @@ -26,11 +34,23 @@ "AirportGame", "MinimumSpanningTreeGame", "MinerGame", - "GlovesGame", ] class DummyGameDataset(Dataset): + """Dummy game dataset. + + Initializes a dummy game dataset with n_players and an optional + description. + + This class is used internally inside the [Game][pydvl.value.games.Game] + class. + + Args: + n_players: Number of players. + description: Optional description of the dataset. + """ + def __init__(self, n_players: int, description: Optional[str] = None) -> None: x = np.arange(0, n_players, 1).reshape(-1, 1) nil = np.zeros_like(x) @@ -50,7 +70,7 @@ def get_test_data( """Returns the subsets of the train set instead of the test set. Args: - indices: Indices into the traing data. + indices: Indices into the training data. Returns: Subset of the train data. @@ -63,7 +83,12 @@ def get_test_data( class DummyModel(SupervisedModel): - def __init__(self): + """Dummy model class. + + A dummy supervised model used for testing purposes only. + """ + + def __init__(self) -> None: pass def fit(self, x: NDArray, y: NDArray): @@ -122,11 +147,19 @@ def __repr__(self) -> str: class SymmetricVotingGame(Game): r"""Toy game that is used for testing and demonstration purposes. - A symmetric voting game defined in :footcite:t:`castro_polynomial_2009` + A symmetric voting game defined in + (Castro et al., 2009)1 Section 4.1 - Under this model the utility of a coalition is 1 if its cardinality is + For this game the utility of a coalition is 1 if its cardinality is greater than num_samples/2, or 0 otherwise. + + $${ + v(S) = \left\{\begin{array}{ll} + 1, & \text{ if} \quad \mid S \mid > \frac{N}{2} \\ + 0, & \text{ otherwise} + \end{array}\right. + }$$ """ def __init__(self, n_players: int) -> None: @@ -157,10 +190,23 @@ def shapley_values(self) -> ValuationResult: class AsymmetricVotingGame(Game): - """Toy game that is used for testing and demonstration purposes. + r"""Toy game that is used for testing and demonstration purposes. - An asymmetric voting game defined in :footcite:t:`castro_polynomial_2009` + An asymmetric voting game defined in + (Castro et al., 2009)1 Section 4.2. + + For this game the player set is $N = \{1,\dots,51\}$ and + the utility of a coalition is given by: + + $${ + v(S) = \left\{\begin{array}{ll} + 1, & \text{ if} \quad \sum\limits_{i \in S} w_i > \sum\limits_{j \in N}\frac{w_j}{2} \\ + 0, & \text{ otherwise} + \end{array}\right. + }$$ + + where $w = [w_1,\dots, w_{51}]$ is a list of weights associated with each player. """ def __init__(self, n_players: int = 51) -> None: @@ -268,24 +314,38 @@ def shapley_values(self) -> ValuationResult: class ShoesGame(Game): """Toy game that is used for testing and demonstration purposes. - A shoes game defined in :footcite:t:`castro_polynomial_2009` + An shoes game defined in + (Castro et al., 2009)1. + + In this game, some players have a left shoe and others a right shoe. + Single shoes have a worth of zero while pairs have a worth of 1. + + The payoff of a coalition $S$ is: + + $${ + v(S) = \min( \mid S \cap L \mid, \mid S \cap R \mid ) + }$$ + + Where $L$, respectively $R$, is the set of players with left shoes, + respectively right shoes. - The utility of a coalition is the minimum of the number of left shoes or - right shoes in a coalition. A player is a left shoe iff its index is among - the first half, or a right shoe otherwise. + Args: + left: Number of players with a left shoe. + right: Number of player with a right shoe. """ - def __init__(self, n_players: int) -> None: - if n_players % 2 != 0: - raise ValueError("n_players must be an even number.") + def __init__(self, left: int, right: int) -> None: + self.left = left + self.right = right + n_players = self.left + self.right description = "Dummy data for the shoe game in Castro et al. 2009" - self.m = n_players // 2 - super().__init__(n_players, score_range=(0, self.m), description=description) + max_score = n_players // 2 + super().__init__(n_players, score_range=(0, max_score), description=description) def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: - left_shoes = np.sum(X < self.m).item() - right_shoes = np.sum(X >= self.m).item() - return min(left_shoes, right_shoes) + left_sum = float(np.sum(np.asarray(X) < self.left)) + right_sum = float(np.sum(np.asarray(X) >= self.left)) + return min(left_sum, right_sum) @lru_cache def shapley_values(self) -> ValuationResult: @@ -300,12 +360,40 @@ def shapley_values(self) -> ValuationResult: ) return result + @lru_cache + def least_core_values(self) -> ValuationResult: + if self.left == self.right: + subsidy = -0.5 + values = np.array([0.5] * (self.left + self.right)) + elif self.left < self.right: + subsidy = 0.0 + values = np.array([1.0] * self.left + [0.0] * self.right) + else: + subsidy = 0.0 + values = np.array([0.0] * self.left + [1.0] * self.right) + + result: ValuationResult[np.int_, int] = ValuationResult( + algorithm="exact_least_core", + status=Status.Converged, + indices=self.data.indices, + values=values, + subsidy=subsidy, + variances=np.zeros_like(self.data.x_train), + counts=np.zeros_like(self.data.x_train), + ) + return result + + def __repr__(self) -> str: + return f"{self.__class__.__name__}(L={self.left}, R={self.right})" + class AirportGame(Game): """Toy game that is used for testing and demonstration purposes. - An airport game defined in :footcite:t:`castro_polynomial_2009`, - Section 4.3""" + An airport game defined in + (Castro et al., 2009)1 + Section 4.3 + """ def __init__(self, n_players: int = 100) -> None: if n_players != 100: @@ -366,7 +454,11 @@ def shapley_values(self) -> ValuationResult: class MinimumSpanningTreeGame(Game): - """Toy game that is used for testing and demonstration purposes.""" + """Toy game that is used for testing and demonstration purposes. + + A minimum spanning tree game defined in + (Castro et al., 2009)1 + """ def __init__(self, n_players: int = 101) -> None: if n_players != 101: @@ -483,67 +575,3 @@ def least_core_values(self) -> ValuationResult: def __repr__(self) -> str: return f"{self.__class__.__name__}(n={self.n_players})" - - -class GlovesGame(Game): - r"""Toy game that is used for testing and demonstration purposes. - - In this game, some players have a left glove and others a right glove. - Single gloves have a worth of zero while pairs have a worth of 1. - - The payoff of a coalition $S$ is: - - $${ - v(S) = \min( \mid S \cap L \mid, \mid S \cap R \mid ) - }$$ - - Where $L$, respectively $R$, is the set of players with left gloves, - respectively right gloves. - - Args: - left: Number of players with a left glove. - right: Number of player with a right glove. - - """ - - def __init__(self, left: int, right: int): - description = "Dummy data for Gloves Game" - self.left = left - self.right = right - n_players = self.left + self.right - super().__init__( - n_players, - score_range=(0, min(self.left, self.right)), - description=description, - ) - - def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: - left_sum = float(np.sum(np.asarray(X) < self.left)) - right_sum = float(np.sum(np.asarray(X) >= self.left)) - return min(left_sum, right_sum) - - @lru_cache - def least_core_values(self) -> ValuationResult: - if self.left == self.right: - subsidy = -0.5 - values = np.array([0.5] * (self.left + self.right)) - elif self.left < self.right: - subsidy = 0.0 - values = np.array([1.0] * self.left + [0.0] * self.right) - else: - subsidy = 0.0 - values = np.array([0.0] * self.left + [1.0] * self.right) - - result: ValuationResult[np.int_, int] = ValuationResult( - algorithm="exact_least_core", - status=Status.Converged, - indices=self.data.indices, - values=values, - subsidy=subsidy, - variances=np.zeros_like(self.data.x_train), - counts=np.zeros_like(self.data.x_train), - ) - return result - - def __repr__(self) -> str: - return f"{self.__class__.__name__}(L={self.left}, R={self.right})" diff --git a/tests/value/least_core/conftest.py b/tests/value/least_core/conftest.py index df24a6f3a..50e1767ea 100644 --- a/tests/value/least_core/conftest.py +++ b/tests/value/least_core/conftest.py @@ -1,6 +1,6 @@ import pytest -from pydvl.value.games import Game, GlovesGame, MinerGame +from pydvl.value.games import Game, MinerGame, ShoesGame @pytest.fixture(scope="module") @@ -8,8 +8,8 @@ def test_game(request) -> Game: name, kwargs = request.param if name == "miner": game = MinerGame(n_players=kwargs["n_players"]) - elif name == "gloves": - game = GlovesGame(left=kwargs["left"], right=kwargs["right"]) + elif name == "shoes": + game = ShoesGame(left=kwargs["left"], right=kwargs["right"]) else: raise ValueError(f"Unknown game '{name}'") return game diff --git a/tests/value/least_core/test_montecarlo.py b/tests/value/least_core/test_montecarlo.py index 9fff3b044..8b926a3bf 100644 --- a/tests/value/least_core/test_montecarlo.py +++ b/tests/value/least_core/test_montecarlo.py @@ -13,7 +13,7 @@ "test_game, rtol, n_iterations", [ (("miner", {"n_players": 8}), 0.1, 128), - (("gloves", {"left": 10, "right": 5}), 0.2, 10000), + (("shoes", {"left": 10, "right": 5}), 0.2, 10000), ], indirect=["test_game"], ) diff --git a/tests/value/least_core/test_naive.py b/tests/value/least_core/test_naive.py index 4a2305e2e..a972e72c0 100644 --- a/tests/value/least_core/test_naive.py +++ b/tests/value/least_core/test_naive.py @@ -10,9 +10,9 @@ [ ("miner", {"n_players": 3}), ("miner", {"n_players": 4}), - ("gloves", {"left": 1, "right": 1}), - ("gloves", {"left": 2, "right": 1}), - ("gloves", {"left": 1, "right": 2}), + ("shoes", {"left": 1, "right": 1}), + ("shoes", {"left": 2, "right": 1}), + ("shoes", {"left": 1, "right": 2}), ], indirect=True, ) From c38ebe93b6cf9b0632222367eb3e6b3a1d0be476 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 15 Jan 2024 20:33:23 +0100 Subject: [PATCH 51/87] Improve games docstrings --- src/pydvl/value/games.py | 57 +++++++++++++++++++++++++++++++++------- 1 file changed, 48 insertions(+), 9 deletions(-) diff --git a/src/pydvl/value/games.py b/src/pydvl/value/games.py index 092d4b08a..6c3f6d9ac 100644 --- a/src/pydvl/value/games.py +++ b/src/pydvl/value/games.py @@ -47,7 +47,7 @@ class DummyGameDataset(Dataset): class. Args: - n_players: Number of players. + n_players: Number of players that participate in the game. description: Optional description of the dataset. """ @@ -108,6 +108,16 @@ class Game(ABC): Any Game subclass has to implement the abstract `_score` method to assign a score to each coalition/subset and at least one of `shapley_values`, `least_core_values`. + + Args: + n_players: Number of players that participate in the game. + score_range: Minimum and maximum values of the `_score` method. + description: Optional string description of the dummy dataset that will be created. + + Attributes: + n_players: Number of players that participate in the game. + data: Dummy dataset object. + u: Utility object with a dummy model and dataset. """ def __init__( @@ -160,6 +170,9 @@ class SymmetricVotingGame(Game): 0, & \text{ otherwise} \end{array}\right. }$$ + + Args: + n_players: Number of players that participate in the game. """ def __init__(self, n_players: int) -> None: @@ -207,6 +220,9 @@ class AsymmetricVotingGame(Game): }$$ where $w = [w_1,\dots, w_{51}]$ is a list of weights associated with each player. + + Args: + n_players: Number of players that participate in the game. """ def __init__(self, n_players: int = 51) -> None: @@ -331,7 +347,7 @@ class ShoesGame(Game): Args: left: Number of players with a left shoe. - right: Number of player with a right shoe. + right: Number of players with a right shoe. """ def __init__(self, left: int, right: int) -> None: @@ -393,6 +409,9 @@ class AirportGame(Game): An airport game defined in (Castro et al., 2009)1 Section 4.3 + + Args: + n_players: Number of players that participate in the game. """ def __init__(self, n_players: int = 100) -> None: @@ -454,16 +473,36 @@ def shapley_values(self) -> ValuationResult: class MinimumSpanningTreeGame(Game): - """Toy game that is used for testing and demonstration purposes. + r"""Toy game that is used for testing and demonstration purposes. A minimum spanning tree game defined in - (Castro et al., 2009)1 + (Castro et al., 2009)1. + + Let $G = (N \cup \{0\},E)$ be a valued graph where $N = \{1,\dots,100\}$, + and the cost associated to an edge $(i, j)$ is: + + $${ + c_{ij} = \left\{\begin{array}{lll} + 1, & \text{ if} & i = j + 1 \text{ or } i = j - 1 \\ + & & \text{ or } (i = 1 \text{ and } j = 100) \text{ or } (i = 100 \text{ and } j = 1) \\ + 101, & \text{ if} & i = 0 \text{ or } j = 0 \\ + \infty, & \text{ otherwise} + \end{array}\right. + }$$ + + A minimum spanning tree game $(N, c)$ is a cost game, where for a given coalition + $S \subset N$, $v(S)$ is the sum of the edge cost of the minimum spanning tree, + i.e. $v(S)$ = Minimum Spanning Tree of the graph $G|_{S\cup\{0\}}$, + which is the partial graph restricted to the players $S$ and the source node $0$. + + Args: + n_players: Number of players that participate in the game. """ - def __init__(self, n_players: int = 101) -> None: - if n_players != 101: + def __init__(self, n_players: int = 100) -> None: + if n_players != 100: raise ValueError( - f"{__class__.__name__} only supports n_players=101 but got {n_players=}." + f"{__class__.__name__} only supports n_players=100 but got {n_players=}." ) description = ( "A dummy dataset for the minimum spanning tree game in Castro et al. 2009" @@ -518,8 +557,8 @@ class MinerGame(Game): $${ v(S) = \left\{\begin{array}{lll} - \mid S \mid / 2 & \text{, if} & \mid S \mid \text{ is even} \\ - ( \mid S \mid - 1)/2 & \text{, if} & \mid S \mid \text{ is odd} + \mid S \mid / 2, & \text{ if} & \mid S \mid \text{ is even} \\ + ( \mid S \mid - 1)/2, & \text{ otherwise} \end{array}\right. }$$ From 79cdd4b044ca9c3e742a320616707da83a95bcdc Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 15 Jan 2024 22:01:26 +0100 Subject: [PATCH 52/87] Fix shapley value computation for shoes game --- src/pydvl/value/games.py | 30 +++++++++++++++++++++++++----- tests/value/least_core/conftest.py | 15 --------------- 2 files changed, 25 insertions(+), 20 deletions(-) delete mode 100644 tests/value/least_core/conftest.py diff --git a/src/pydvl/value/games.py b/src/pydvl/value/games.py index 6c3f6d9ac..44ca3b936 100644 --- a/src/pydvl/value/games.py +++ b/src/pydvl/value/games.py @@ -365,7 +365,27 @@ def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: @lru_cache def shapley_values(self) -> ValuationResult: - exact_values = np.ones_like(self.data.x_train) * 0.5 + if self.left != self.right and (self.left > 4 or self.right > 4): + raise ValueError( + "This class only supports getting exact shapley values " + "for left <= 4 and right <= 4 or left == right" + ) + precomputed_values = np.array( + [ + [0.0, 0.0, 0.0, 0.0, 0.0], + [0.0, 0.5, 0.667, 0.75, 0.8], + [0.0, 0.167, 0.5, 0.65, 0.733], + [0.0, 0.083, 0.233, 0.5, 0.638], + [0.0, 0.050, 0.133, 0.271, 0.5], + ] + ) + if self.left == self.right: + value_left = min(self.left, self.right) / 2 + value_right = value_left + else: + value_left = precomputed_values[self.left, self.right] + value_right = precomputed_values[self.right, self.left] + exact_values = np.array([value_left] * self.left + [value_right] * self.right) result: ValuationResult[np.int_, int] = ValuationResult( algorithm="exact_shapley", status=Status.Converged, @@ -380,19 +400,19 @@ def shapley_values(self) -> ValuationResult: def least_core_values(self) -> ValuationResult: if self.left == self.right: subsidy = -0.5 - values = np.array([0.5] * (self.left + self.right)) + exact_values = np.array([0.5] * (self.left + self.right)) elif self.left < self.right: subsidy = 0.0 - values = np.array([1.0] * self.left + [0.0] * self.right) + exact_values = np.array([1.0] * self.left + [0.0] * self.right) else: subsidy = 0.0 - values = np.array([0.0] * self.left + [1.0] * self.right) + exact_values = np.array([0.0] * self.left + [1.0] * self.right) result: ValuationResult[np.int_, int] = ValuationResult( algorithm="exact_least_core", status=Status.Converged, indices=self.data.indices, - values=values, + values=exact_values, subsidy=subsidy, variances=np.zeros_like(self.data.x_train), counts=np.zeros_like(self.data.x_train), diff --git a/tests/value/least_core/conftest.py b/tests/value/least_core/conftest.py deleted file mode 100644 index 50e1767ea..000000000 --- a/tests/value/least_core/conftest.py +++ /dev/null @@ -1,15 +0,0 @@ -import pytest - -from pydvl.value.games import Game, MinerGame, ShoesGame - - -@pytest.fixture(scope="module") -def test_game(request) -> Game: - name, kwargs = request.param - if name == "miner": - game = MinerGame(n_players=kwargs["n_players"]) - elif name == "shoes": - game = ShoesGame(left=kwargs["left"], right=kwargs["right"]) - else: - raise ValueError(f"Unknown game '{name}'") - return game From c963ee8a1b26fafe232ba1fcf3abe0863cfcd946 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 15 Jan 2024 22:02:05 +0100 Subject: [PATCH 53/87] Add tests for exact shapley methods using toy games --- tests/value/conftest.py | 23 +++++++++++ tests/value/shapley/test_naive.py | 63 ++++++++----------------------- 2 files changed, 38 insertions(+), 48 deletions(-) diff --git a/tests/value/conftest.py b/tests/value/conftest.py index 0e3c48d29..139f0f5b6 100644 --- a/tests/value/conftest.py +++ b/tests/value/conftest.py @@ -11,12 +11,35 @@ from pydvl.utils.caching import InMemoryCacheBackend from pydvl.utils.status import Status from pydvl.value import ValuationResult +from pydvl.value.games import ( + AsymmetricVotingGame, + Game, + MinerGame, + ShoesGame, + SymmetricVotingGame, +) from pydvl.value.shapley.naive import combinatorial_exact_shapley from ..conftest import num_workers from . import polynomial +@pytest.fixture(scope="module") +def test_game(request) -> Game: + name, kwargs = request.param + if name == "miner": + game = MinerGame(n_players=kwargs["n_players"]) + elif name == "shoes": + game = ShoesGame(left=kwargs["left"], right=kwargs["right"]) + elif name == "symmetric-voting": + game = SymmetricVotingGame(n_players=kwargs["n_players"]) + elif name == "asymmetric-voting": + game = AsymmetricVotingGame() + else: + raise ValueError(f"Unknown game '{name}'") + return game + + @pytest.fixture(scope="function") def polynomial_dataset(coefficients: np.ndarray): """Coefficients must be for monomials of increasing degree""" diff --git a/tests/value/shapley/test_naive.py b/tests/value/shapley/test_naive.py index 45c32b1a9..98a18a626 100644 --- a/tests/value/shapley/test_naive.py +++ b/tests/value/shapley/test_naive.py @@ -15,55 +15,26 @@ log = logging.getLogger(__name__) -# noinspection PyTestParametrized @pytest.mark.parametrize( - "num_samples, fun, rtol, total_atol", + "test_game, rtol, total_atol", [ - (12, combinatorial_exact_shapley, 0.01, 1e-5), - (6, permutation_exact_shapley, 0.01, 1e-5), + (("symmetric-voting", {"n_players": 4}), 0.1, 1e-5), + (("shoes", {"left": 1, "right": 1}), 0.1, 1e-5), + (("shoes", {"left": 2, "right": 1}), 0.1, 1e-5), + (("shoes", {"left": 1, "right": 2}), 0.1, 1e-5), + (("shoes", {"left": 2, "right": 4}), 0.1, 1e-5), ], + indirect=["test_game"], ) -def test_analytic_exact_shapley(num_samples, analytic_shapley, fun, rtol, total_atol): - """Compares the combinatorial exact shapley and permutation exact shapley with - the analytic_shapley calculation for a dummy model. - """ - u, exact_values = analytic_shapley - values_p = fun(u, progress=False) - check_total_value(u, values_p, atol=total_atol) - check_values(values_p, exact_values, rtol=rtol) - - @pytest.mark.parametrize( - "a, b, num_points, scorer", - [ - (2, 0, 10, "r2"), - (2, 1, 10, "r2"), - (2, 1, 10, "neg_median_absolute_error"), - (2, 1, 10, "explained_variance"), - ], + "fun", + [combinatorial_exact_shapley, permutation_exact_shapley], ) -def test_linear( - linear_dataset, - memcache_client_config, - scorer, - cache_backend, - rtol=0.01, - total_atol=1e-5, -): - linear_utility = Utility( - LinearRegression(), - data=linear_dataset, - scorer=scorer, - cache_backend=cache_backend, - ) - - values_combinatorial = combinatorial_exact_shapley(linear_utility, progress=False) - check_total_value(linear_utility, values_combinatorial, atol=total_atol) - - values_permutation = permutation_exact_shapley(linear_utility, progress=False) - check_total_value(linear_utility, values_permutation, atol=total_atol) - - check_values(values_combinatorial, values_permutation, rtol=rtol) +def test_games(fun, test_game, rtol, total_atol): + values_p = fun(test_game.u) + exact_values = test_game.shapley_values() + check_total_value(test_game.u, values_p, atol=total_atol) + check_values(values_p, exact_values, rtol=rtol) @pytest.mark.parametrize( @@ -73,7 +44,6 @@ def test_linear( def test_grouped_linear( linear_dataset, num_groups, - memcache_client_config, scorer, cache_backend, rtol=0.01, @@ -112,9 +82,7 @@ def test_grouped_linear( (2, 1, 20, "r2"), ], ) -def test_linear_with_outlier( - linear_dataset, memcache_client_config, scorer, cache_backend, total_atol=1e-5 -): +def test_linear_with_outlier(linear_dataset, scorer, cache_backend, total_atol=1e-5): outlier_idx = np.random.randint(len(linear_dataset.y_train)) linear_dataset.y_train[outlier_idx] -= 100 linear_utility = Utility( @@ -173,7 +141,6 @@ def test_polynomial( def test_polynomial_with_outlier( polynomial_dataset, polynomial_pipeline, - memcache_client_config, scorer, cache_backend, total_atol=1e-5, From bda5d2aed42f00e962a642dfa7353be52973842a Mon Sep 17 00:00:00 2001 From: Xuzzo Date: Tue, 16 Jan 2024 00:56:30 +0100 Subject: [PATCH 54/87] hiding a few more cell inputs and fix bulltpoint rendering --- notebooks/influence_sentiment_analysis.ipynb | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/notebooks/influence_sentiment_analysis.ipynb b/notebooks/influence_sentiment_analysis.ipynb index 8604bd02a..e11ff92b2 100644 --- a/notebooks/influence_sentiment_analysis.ipynb +++ b/notebooks/influence_sentiment_analysis.ipynb @@ -16,6 +16,7 @@ "Not all the methods for influence function calculation can scale to large models and datasets. In this notebook we will use the [Kronecker-Factored Approximate Curvature](https://arxiv.org/abs/1503.05671) method, which is the only one that can scale to current state-of-the-art language models.\n", "\n", "The notebook is structured as follows:\n", + "\n", "- [Setup](#Setup) imports the required libraries and downloads the dataset and the model.\n", "- [Sentiment analysis](#Sentiment-analysis) loads the model and the dataset and goes through a few examples of sentiment analysis.\n", "- [Model and data preparation](#Model-and-data-preparation) prepares the model and the dataset for influence function calculation. In particular, it assigns all the linear layers to require gradients and wraps the model so that only logits are returned (and not the loss or attention masks).\n", @@ -1045,7 +1046,11 @@ { "cell_type": "code", "execution_count": 30, - "metadata": {}, + "metadata": { + "tags": [ + "hide-input" + ] + }, "outputs": [ { "data": { @@ -1216,7 +1221,11 @@ { "cell_type": "code", "execution_count": 35, - "metadata": {}, + "metadata": { + "tags": [ + "hide-input" + ] + }, "outputs": [ { "data": { From 307401336af2bdfeb72266ee2a9cc809fd2561f6 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 16 Jan 2024 17:40:24 +0100 Subject: [PATCH 55/87] Add test_game for montecarlo shapley methods --- src/pydvl/value/games.py | 5 +- tests/value/shapley/test_montecarlo.py | 77 +++++++++++++------------- 2 files changed, 41 insertions(+), 41 deletions(-) diff --git a/src/pydvl/value/games.py b/src/pydvl/value/games.py index 44ca3b936..f0106348a 100644 --- a/src/pydvl/value/games.py +++ b/src/pydvl/value/games.py @@ -380,8 +380,9 @@ def shapley_values(self) -> ValuationResult: ] ) if self.left == self.right: - value_left = min(self.left, self.right) / 2 - value_right = value_left + value_left = value_right = min(self.left, self.right) / ( + self.left + self.right + ) else: value_left = precomputed_values[self.left, self.right] value_right = precomputed_values[self.right, self.left] diff --git a/tests/value/shapley/test_montecarlo.py b/tests/value/shapley/test_montecarlo.py index ef9deed1f..065559956 100644 --- a/tests/value/shapley/test_montecarlo.py +++ b/tests/value/shapley/test_montecarlo.py @@ -6,7 +6,7 @@ from sklearn.linear_model import LinearRegression from pydvl.parallel.config import ParallelConfig -from pydvl.utils import Dataset, GroupedDataset, Status, Utility +from pydvl.utils import GroupedDataset, Status, Utility from pydvl.utils.numeric import num_samples_permutation_hoeffding from pydvl.utils.score import Scorer, squashed_r2 from pydvl.utils.types import Seed @@ -21,35 +21,33 @@ log = logging.getLogger(__name__) -# noinspection PyTestParametrized @pytest.mark.parametrize( - "num_samples, fun, rtol, atol, kwargs", + "test_game", [ - (12, ShapleyMode.PermutationMontecarlo, 0.1, 1e-5, {"done": MaxUpdates(10)}), - # FIXME! it should be enough with 2**(len(data)-1) samples - ( - 8, - ShapleyMode.CombinatorialMontecarlo, - 0.2, - 1e-4, - {"done": MaxUpdates(2**10)}, - ), - (12, ShapleyMode.Owen, 0.1, 1e-4, dict(n_samples=4, max_q=200)), - (12, ShapleyMode.OwenAntithetic, 0.1, 1e-4, dict(n_samples=4, max_q=200)), + ("symmetric-voting", {"n_players": 6}), + ("shoes", {"left": 3, "right": 4}), + ], + indirect=["test_game"], +) +@pytest.mark.parametrize( + "fun, rtol, atol, kwargs", + [ + (ShapleyMode.PermutationMontecarlo, 0.5, 1e-4, dict(done=MaxUpdates(60))), + (ShapleyMode.CombinatorialMontecarlo, 0.5, 1e-4, dict(done=MaxUpdates(2**6))), + (ShapleyMode.Owen, 0.2, 1e-4, dict(n_samples=5, max_q=200)), + (ShapleyMode.OwenAntithetic, 0.1, 1e-4, dict(n_samples=5, max_q=200)), + # Because of the inaccuracy of GroupTesting, a high atol is required for the + # value 0, for which the rtol has no effect. ( - 3, ShapleyMode.GroupTesting, 0.1, - # Because of the inaccuracy of GTS, a high atol is required for the - # value 0, for which the rtol has no effect. 1e-2, dict(n_samples=int(4e4), epsilon=0.2, delta=0.01), ), ], ) -def test_analytic_montecarlo_shapley( - num_samples, - analytic_shapley, +def test_games( + test_game, parallel_config, n_jobs, fun: ShapleyMode, @@ -58,10 +56,8 @@ def test_analytic_montecarlo_shapley( kwargs: dict, seed, ): - u, exact_values = analytic_shapley - values = compute_shapley_values( - u, + test_game.u, mode=fun, n_jobs=n_jobs, config=parallel_config, @@ -70,29 +66,31 @@ def test_analytic_montecarlo_shapley( **kwargs ) + exact_values = test_game.shapley_values() check_values(values, exact_values, rtol=rtol, atol=atol) @pytest.mark.slow @pytest.mark.parametrize( - "num_samples, fun, kwargs", + "test_game", + [ + ("symmetric-voting", {"n_players": 12}), + ], + indirect=["test_game"], +) +@pytest.mark.parametrize( + "fun, kwargs", [ # TODO Add once issue #416 is closed. - # (12, ShapleyMode.PermutationMontecarlo, {"done": MaxChecks(1)}), - ( - 12, - ShapleyMode.CombinatorialMontecarlo, - {"done": MaxChecks(4)}, - ), - (12, ShapleyMode.Owen, dict(n_samples=4, max_q=200)), - (12, ShapleyMode.OwenAntithetic, dict(n_samples=4, max_q=200)), - (4, ShapleyMode.GroupTesting, dict(n_samples=21, epsilon=0.2, delta=0.01)), + # (ShapleyMode.PermutationMontecarlo, dict(done=MaxChecks(1))), + (ShapleyMode.CombinatorialMontecarlo, dict(done=MaxChecks(4))), + (ShapleyMode.Owen, dict(n_samples=4, max_q=200)), + (ShapleyMode.OwenAntithetic, dict(n_samples=4, max_q=200)), + (ShapleyMode.GroupTesting, dict(n_samples=21, epsilon=0.2, delta=0.01)), ], ) -@pytest.mark.parametrize("num_points, num_features", [(12, 3)]) -def test_montecarlo_shapley_housing_dataset( - num_samples: int, - housing_dataset: Dataset, +def test_seed( + test_game, parallel_config: ParallelConfig, n_jobs: int, fun: ShapleyMode, @@ -102,11 +100,10 @@ def test_montecarlo_shapley_housing_dataset( ): values_1, values_2, values_3 = call_with_seeds( compute_shapley_values, - Utility(LinearRegression(), data=housing_dataset, scorer="r2"), + test_game.u, mode=fun, n_jobs=n_jobs, config=parallel_config, - progress=False, seeds=(seed, seed, seed_alt), **deepcopy(kwargs) ) @@ -143,6 +140,8 @@ def test_hoeffding_bound_montecarlo( check_rank_correlation(values, exact_values, threshold=0.8) +# TODO: Delete this test now that we have `test_game` defined above? +@pytest.mark.slow @pytest.mark.parametrize( "a, b, num_points", [(2, 0, 21)] # training set will have 0.3 * 21 = 6 samples ) From 5a4bc04918dc56ee8018ed6c3eb9d7e1034ccaeb Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 17 Jan 2024 09:28:51 +0100 Subject: [PATCH 56/87] Fix type annotation issues --- src/pydvl/utils/types.py | 2 +- src/pydvl/value/games.py | 28 ++++++++++++++-------------- 2 files changed, 15 insertions(+), 15 deletions(-) diff --git a/src/pydvl/utils/types.py b/src/pydvl/utils/types.py index 1a915c33c..18a22bd26 100644 --- a/src/pydvl/utils/types.py +++ b/src/pydvl/utils/types.py @@ -23,7 +23,7 @@ ] IndexT = TypeVar("IndexT", bound=np.int_) -NameT = TypeVar("NameT", bound=np.object_) +NameT = TypeVar("NameT", np.object_, np.int_) R = TypeVar("R", covariant=True) Seed = Union[int, Generator] diff --git a/src/pydvl/value/games.py b/src/pydvl/value/games.py index f0106348a..f8b3358d5 100644 --- a/src/pydvl/value/games.py +++ b/src/pydvl/value/games.py @@ -91,10 +91,10 @@ class DummyModel(SupervisedModel): def __init__(self) -> None: pass - def fit(self, x: NDArray, y: NDArray): + def fit(self, x: NDArray, y: NDArray) -> None: pass - def predict(self, x: NDArray) -> NDArray: + def predict(self, x: NDArray) -> NDArray: # type: ignore pass def score(self, x: NDArray, y: NDArray) -> float: @@ -138,12 +138,12 @@ def __init__( def shapley_values(self) -> ValuationResult: raise NotImplementedError( - f"shapley_values method was not implemented for class {__class__.__name__}" + f"shapley_values method was not implemented for class {self.__class__.__name__}" ) def least_core_values(self) -> ValuationResult: raise NotImplementedError( - f"least_core_values method was not implemented for class {__class__.__name__}" + f"least_core_values method was not implemented for class {self.__class__.__name__}" ) @abstractmethod @@ -191,7 +191,7 @@ def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: @lru_cache def shapley_values(self) -> ValuationResult: exact_values = np.ones_like(self.data.x_train) / len(self.data.x_train) - result: ValuationResult[np.int_, int] = ValuationResult( + result: ValuationResult[np.int_, np.int_] = ValuationResult( algorithm="exact_shapley", status=Status.Converged, indices=self.data.indices, @@ -228,7 +228,7 @@ class AsymmetricVotingGame(Game): def __init__(self, n_players: int = 51) -> None: if n_players != 51: raise ValueError( - f"{__class__.__name__} only supports n_players=51 but got {n_players=}." + f"{self.__class__.__name__} only supports n_players=51 but got {n_players=}." ) description = "Dummy data for the asymmetric voting game in Castro et al. 2009" super().__init__( @@ -316,7 +316,7 @@ def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: @lru_cache def shapley_values(self) -> ValuationResult: - result: ValuationResult[np.int_, int] = ValuationResult( + result: ValuationResult[np.int_, np.int_] = ValuationResult( algorithm="exact_shapley", status=Status.Converged, indices=self.data.indices, @@ -387,7 +387,7 @@ def shapley_values(self) -> ValuationResult: value_left = precomputed_values[self.left, self.right] value_right = precomputed_values[self.right, self.left] exact_values = np.array([value_left] * self.left + [value_right] * self.right) - result: ValuationResult[np.int_, int] = ValuationResult( + result: ValuationResult[np.int_, np.int_] = ValuationResult( algorithm="exact_shapley", status=Status.Converged, indices=self.data.indices, @@ -409,7 +409,7 @@ def least_core_values(self) -> ValuationResult: subsidy = 0.0 exact_values = np.array([0.0] * self.left + [1.0] * self.right) - result: ValuationResult[np.int_, int] = ValuationResult( + result: ValuationResult[np.int_, np.int_] = ValuationResult( algorithm="exact_least_core", status=Status.Converged, indices=self.data.indices, @@ -438,7 +438,7 @@ class AirportGame(Game): def __init__(self, n_players: int = 100) -> None: if n_players != 100: raise ValueError( - f"{__class__.__name__} only supports n_players=100 but got {n_players=}." + f"{self.__class__.__name__} only supports n_players=100 but got {n_players=}." ) description = "A dummy dataset for the airport game in Castro et al. 2009" super().__init__(n_players, score_range=(0, 100), description=description) @@ -482,7 +482,7 @@ def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: @lru_cache def shapley_values(self) -> ValuationResult: - result: ValuationResult[np.int_, int] = ValuationResult( + result: ValuationResult[np.int_, np.int_] = ValuationResult( algorithm="exact_shapley", status=Status.Converged, indices=self.data.indices, @@ -523,7 +523,7 @@ class MinimumSpanningTreeGame(Game): def __init__(self, n_players: int = 100) -> None: if n_players != 100: raise ValueError( - f"{__class__.__name__} only supports n_players=100 but got {n_players=}." + f"{self.__class__.__name__} only supports n_players=100 but got {n_players=}." ) description = ( "A dummy dataset for the minimum spanning tree game in Castro et al. 2009" @@ -557,7 +557,7 @@ def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: @lru_cache def shapley_values(self) -> ValuationResult: exact_values = 2 * np.ones_like(self.data.x_train) - result: ValuationResult[np.int_, int] = ValuationResult( + result: ValuationResult[np.int_, np.int_] = ValuationResult( algorithm="exact_shapley", status=Status.Converged, indices=self.data.indices, @@ -622,7 +622,7 @@ def least_core_values(self) -> ValuationResult: ) subsidy = (self.n_players - 1) / (2 * self.n_players) - result: ValuationResult[np.int_, int] = ValuationResult( + result: ValuationResult[np.int_, np.int_] = ValuationResult( algorithm="exact_least_core", status=Status.Converged, indices=self.data.indices, From 56502dae60389c8867a082995d5d919ef5cf2110 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 17 Jan 2024 23:45:02 +0100 Subject: [PATCH 57/87] Fix parameters in test --- tests/value/shapley/test_montecarlo.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/tests/value/shapley/test_montecarlo.py b/tests/value/shapley/test_montecarlo.py index 065559956..4255890c2 100644 --- a/tests/value/shapley/test_montecarlo.py +++ b/tests/value/shapley/test_montecarlo.py @@ -32,8 +32,13 @@ @pytest.mark.parametrize( "fun, rtol, atol, kwargs", [ - (ShapleyMode.PermutationMontecarlo, 0.5, 1e-4, dict(done=MaxUpdates(60))), - (ShapleyMode.CombinatorialMontecarlo, 0.5, 1e-4, dict(done=MaxUpdates(2**6))), + (ShapleyMode.PermutationMontecarlo, 0.2, 1e-4, dict(done=MaxUpdates(500))), + ( + ShapleyMode.CombinatorialMontecarlo, + 0.2, + 1e-4, + dict(done=MaxUpdates(2**10)), + ), (ShapleyMode.Owen, 0.2, 1e-4, dict(n_samples=5, max_q=200)), (ShapleyMode.OwenAntithetic, 0.1, 1e-4, dict(n_samples=5, max_q=200)), # Because of the inaccuracy of GroupTesting, a high atol is required for the From 329ed80c9213cbf01405dedec6751da3acff50b2 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 18 Jan 2024 09:07:31 +0100 Subject: [PATCH 58/87] Delete test_linear_montecarlo_shapley --- tests/value/shapley/test_montecarlo.py | 72 +++++--------------------- 1 file changed, 14 insertions(+), 58 deletions(-) diff --git a/tests/value/shapley/test_montecarlo.py b/tests/value/shapley/test_montecarlo.py index 4255890c2..58f9df2a9 100644 --- a/tests/value/shapley/test_montecarlo.py +++ b/tests/value/shapley/test_montecarlo.py @@ -61,6 +61,20 @@ def test_games( kwargs: dict, seed, ): + """Tests values for all methods using a toy games. + + For permutation, the rtol for each scorer is chosen + so that the number of samples selected is just above the (ε,δ) bound for ε = + rtol, δ=0.001 and the range corresponding to each score. This means that + roughly once every 1000/num_methods runs the test will fail. + + FIXME: + - We don't have a bound for Owen. + NOTE: + - The variance in the combinatorial method is huge, so we need lots of + samples + + """ values = compute_shapley_values( test_game.u, mode=fun, @@ -145,64 +159,6 @@ def test_hoeffding_bound_montecarlo( check_rank_correlation(values, exact_values, threshold=0.8) -# TODO: Delete this test now that we have `test_game` defined above? -@pytest.mark.slow -@pytest.mark.parametrize( - "a, b, num_points", [(2, 0, 21)] # training set will have 0.3 * 21 = 6 samples -) -@pytest.mark.parametrize("scorer, rtol", [(squashed_r2, 0.25)]) -@pytest.mark.parametrize( - "fun, kwargs", - [ - # FIXME: Hoeffding says 400 should be enough - (ShapleyMode.PermutationMontecarlo, dict(done=MaxUpdates(500))), - (ShapleyMode.CombinatorialMontecarlo, dict(done=MaxUpdates(2**11))), - (ShapleyMode.Owen, dict(n_samples=2, max_q=300)), - (ShapleyMode.OwenAntithetic, dict(n_samples=2, max_q=300)), - pytest.param( - ShapleyMode.GroupTesting, - dict(n_samples=int(5e4), epsilon=0.25, delta=0.1), - marks=pytest.mark.slow, - ), - ], -) -def test_linear_montecarlo_shapley( - linear_shapley, - n_jobs, - memcache_client_config, - scorer: Scorer, - rtol: float, - fun: ShapleyMode, - kwargs: dict, - seed: int, -): - """Tests values for all methods using a linear dataset. - - For permutation and truncated montecarlo, the rtol for each scorer is chosen - so that the number of samples selected is just above the (ε,δ) bound for ε = - rtol, δ=0.001 and the range corresponding to each score. This means that - roughly once every 1000/num_methods runs the test will fail. - - FIXME: - - For permutation, we must increase the number of samples above that what - is done for truncated, this is probably due to the averaging done by the - latter to reduce variance - - We don't have a bound for Owen. - NOTE: - - The variance in the combinatorial method is huge, so we need lots of - samples - - """ - u, exact_values = linear_shapley - - values = compute_shapley_values( - u, mode=fun, progress=False, n_jobs=n_jobs, seed=seed, **kwargs - ) - - check_values(values, exact_values, rtol=rtol) - check_total_value(u, values, rtol=rtol) # FIXME, could be more than rtol - - @pytest.mark.slow @pytest.mark.parametrize( "a, b, num_points", [(2, 0, 21)] # training set will have 0.3 * 21 ~= 6 samples From 7c3227f8f0139187bdd0e35c3bf0c246340dd226 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Thu, 18 Jan 2024 13:47:25 +0100 Subject: [PATCH 59/87] Replace analytic and linear montecarlo truncated tests with games --- tests/value/shapley/test_truncated.py | 103 ++++++++------------------ 1 file changed, 30 insertions(+), 73 deletions(-) diff --git a/tests/value/shapley/test_truncated.py b/tests/value/shapley/test_truncated.py index ac980ab96..7d5977216 100644 --- a/tests/value/shapley/test_truncated.py +++ b/tests/value/shapley/test_truncated.py @@ -8,7 +8,7 @@ from pydvl.utils.score import Scorer, squashed_r2 from pydvl.value import compute_shapley_values from pydvl.value.shapley import ShapleyMode -from pydvl.value.shapley.truncated import NoTruncation +from pydvl.value.shapley.truncated import FixedTruncation, NoTruncation from pydvl.value.stopping import HistoryDeviation, MaxUpdates from .. import check_total_value, check_values @@ -16,92 +16,49 @@ log = logging.getLogger(__name__) -# noinspection PyTestParametrized @pytest.mark.parametrize( - "num_samples, fun, rtol, atol, kwargs", + "test_game", [ - ( - 12, - ShapleyMode.TruncatedMontecarlo, - 0.1, - 1e-5, - dict( - done=MaxUpdates(500), - truncation=NoTruncation(), - ), - ), + ("symmetric-voting", {"n_players": 6}), + ("shoes", {"left": 3, "right": 4}), ], + indirect=["test_game"], ) -def test_tmcs_analytic_montecarlo_shapley( - num_samples, - analytic_shapley, - parallel_config, - n_jobs, - fun: ShapleyMode, - rtol: float, - atol: float, - kwargs: dict, -): - u, exact_values = analytic_shapley - - values = compute_shapley_values( - u, mode=fun, n_jobs=n_jobs, config=parallel_config, progress=False, **kwargs - ) - - check_values(values, exact_values, rtol=rtol, atol=atol) - - @pytest.mark.parametrize( - "a, b, num_points", [(2, 0, 21)] # training set will have 0.3 * 21 = 6 samples -) -@pytest.mark.parametrize("scorer, rtol", [(squashed_r2, 0.25)]) -@pytest.mark.parametrize( - "fun, kwargs", + "done, truncation_cls, truncation_kwargs", [ - ( - ShapleyMode.TruncatedMontecarlo, - dict( - done=MaxUpdates(500), - truncation=NoTruncation(), - ), - ), + (MaxUpdates(600), NoTruncation, dict()), + (MaxUpdates(600), FixedTruncation, dict(fraction=0.9)), ], ) -def test_tmcs_linear_montecarlo_shapley( - linear_shapley, +def test_games( + test_game, + parallel_config, n_jobs, - memcache_client_config, - scorer: Scorer, - rtol: float, - fun: ShapleyMode, - kwargs: dict, + done, + truncation_cls, + truncation_kwargs, + seed, ): - """Tests values for all methods using a linear dataset. - - For permutation and truncated montecarlo, the rtol for each scorer is chosen - so that the number of samples selected is just above the (ε,δ) bound for ε = - rtol, δ=0.001 and the range corresponding to each score. This means that - roughly once every 1000/num_methods runs the test will fail. - - FIXME: - - For permutation, we must increase the number of samples above that what - is done for truncated, this is probably due to the averaging done by the - latter to reduce variance - - We don't have a bound for Owen. - NOTE: - - The variance in the combinatorial method is huge, so we need lots of - samples - - """ - u, exact_values = linear_shapley - check_total_value(u, exact_values, rtol=rtol) + try: + truncation = truncation_cls(test_game.u, **truncation_kwargs) + except TypeError: + # The NoTruncation class's constructor doesn't take any arguments + truncation = truncation_cls(**truncation_kwargs) values = compute_shapley_values( - u, mode=fun, progress=False, n_jobs=n_jobs, **kwargs + test_game.u, + mode=ShapleyMode.TruncatedMontecarlo, + done=done, + truncation=truncation, + n_jobs=n_jobs, + config=parallel_config, + seed=seed, + progress=True, ) - check_values(values, exact_values, rtol=rtol) - check_total_value(u, values, rtol=rtol) # FIXME, could be more than rtol + exact_values = test_game.shapley_values() + check_values(values, exact_values, rtol=0.2, atol=1e-4) @pytest.mark.parametrize( From 762a198047d5d7be574d9d9961480a737145090a Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 22 Jan 2024 08:59:37 +0100 Subject: [PATCH 60/87] Fix counting number of converged values --- src/pydvl/value/games.py | 2 +- src/pydvl/value/semivalues.py | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/pydvl/value/games.py b/src/pydvl/value/games.py index f8b3358d5..ef942ebcf 100644 --- a/src/pydvl/value/games.py +++ b/src/pydvl/value/games.py @@ -190,7 +190,7 @@ def _score(self, model: SupervisedModel, X: NDArray, y: NDArray) -> float: @lru_cache def shapley_values(self) -> ValuationResult: - exact_values = np.ones_like(self.data.x_train) / len(self.data.x_train) + exact_values = np.ones(self.n_players) / self.n_players result: ValuationResult[np.int_, np.int_] = ValuationResult( algorithm="exact_shapley", status=Status.Converged, diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index 9eee1c83d..a32d5c610 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -94,6 +94,7 @@ from itertools import islice from typing import Iterable, List, Optional, Protocol, Tuple, Type, cast +import numpy as np import scipy as sp from deprecate import deprecated from tqdm import tqdm @@ -271,7 +272,7 @@ def compute_generic_semivalues( # Filter out samples for indices that have already converged filtered_samples = samples - if skip_converged and len(done.converged) > 0: + if skip_converged and np.count_nonzero(done.converged) > 0: # TODO: cloudpickle can't pickle this on python 3.8: # filtered_samples = filter( # lambda t: not done.converged[t[0]], samples From 0233c5e178943a231c19ec79e1412773d4b6886e Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 22 Jan 2024 11:00:52 +0100 Subject: [PATCH 61/87] Simplify code for skipping converged values --- src/pydvl/value/semivalues.py | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/src/pydvl/value/semivalues.py b/src/pydvl/value/semivalues.py index a32d5c610..2119e38a9 100644 --- a/src/pydvl/value/semivalues.py +++ b/src/pydvl/value/semivalues.py @@ -273,14 +273,9 @@ def compute_generic_semivalues( # Filter out samples for indices that have already converged filtered_samples = samples if skip_converged and np.count_nonzero(done.converged) > 0: - # TODO: cloudpickle can't pickle this on python 3.8: - # filtered_samples = filter( - # lambda t: not done.converged[t[0]], samples - # ) + # TODO: cloudpickle can't pickle result of `filter` on python 3.8 filtered_samples = tuple( - (idx, sample) - for idx, sample in samples - if not done.converged[idx] + filter(lambda t: not done.converged[t[0]], samples) ) if filtered_samples: From 8dd892179d8294125540d11a271165d51466ba8c Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 22 Jan 2024 11:01:29 +0100 Subject: [PATCH 62/87] Use numpy's testing functions instead of plain asserts --- tests/value/__init__.py | 20 +++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-) diff --git a/tests/value/__init__.py b/tests/value/__init__.py index 4b27711c4..19a703d2d 100644 --- a/tests/value/__init__.py +++ b/tests/value/__init__.py @@ -19,7 +19,9 @@ def check_total_value( Shapley value is supposed to fulfill the total value axiom.""" total_utility = u(u.data.indices) # We can use relative tolerances if we don't have the range of the scorer. - assert np.isclose(np.sum(values.values), total_utility, rtol=rtol, atol=atol) + np.testing.assert_allclose( + np.sum(values.values), total_utility, rtol=rtol, atol=atol + ) def check_exact( @@ -33,10 +35,14 @@ def check_exact( values.sort() exact_values.sort() - assert np.all(values.indices == exact_values.indices), "Ranks do not match" - assert np.allclose( - values.values, exact_values.values, rtol=rtol, atol=atol - ), "Values do not match" + np.testing.assert_equal(values.indices, exact_values.indices, "Ranks do not match") + np.testing.assert_allclose( + values.values, + exact_values.values, + rtol=rtol, + atol=atol, + err_msg="Values do not match", + ) def check_values( @@ -66,9 +72,9 @@ def check_values( values.sort() exact_values.sort() - assert np.allclose(values.values, exact_values.values, rtol=rtol, atol=atol) + np.testing.assert_allclose(values.values, exact_values.values, rtol=rtol, atol=atol) for name in extra_values_names: - assert np.isclose( + np.testing.assert_allclose( getattr(values, name), getattr(exact_values, name), rtol=rtol, atol=atol ) From 117647c5460a98ab51f9c62016294d7997a9f5f1 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 22 Jan 2024 11:02:06 +0100 Subject: [PATCH 63/87] Use toy games for testing semivalues, add more tests --- tests/value/test_semivalues.py | 181 +++++++++++++++++++++++++-------- 1 file changed, 137 insertions(+), 44 deletions(-) diff --git a/tests/value/test_semivalues.py b/tests/value/test_semivalues.py index 50a0201b7..1058602b4 100644 --- a/tests/value/test_semivalues.py +++ b/tests/value/test_semivalues.py @@ -1,4 +1,5 @@ import math +from itertools import islice from typing import Type import numpy as np @@ -17,6 +18,7 @@ ) from pydvl.value.semivalues import ( SVCoefficient, + _marginal, banzhaf_coefficient, beta_coefficient, compute_generic_semivalues, @@ -28,12 +30,108 @@ from .utils import timed -@pytest.mark.parametrize("num_samples", [5]) +@pytest.mark.parametrize( + "test_game", + [ + ("shoes", {"left": 3, "right": 2}), + ], + indirect=["test_game"], +) +@pytest.mark.parametrize( + "sampler, coefficient, batch_size", + [(PermutationSampler, beta_coefficient(1, 1), 5)], +) +def test_marginal_batch_size(test_game, sampler, coefficient, batch_size, seed): + sampler_it = iter(sampler(test_game.u.data.indices, seed=seed)) + samples = tuple(islice(sampler_it, batch_size)) + + marginals_single = [] + for sample in samples: + marginals_single.extend( + _marginal(test_game.u, coefficient=coefficient, samples=[sample]) + ) + + marginals_batch = _marginal(test_game.u, coefficient=coefficient, samples=samples) + + assert len(marginals_single) == len(marginals_batch) + assert set(marginals_single) == set(marginals_batch) + + +@pytest.mark.parametrize("n", [10, 100]) +@pytest.mark.parametrize( + "coefficient", + [ + beta_coefficient(1, 1), + beta_coefficient(1, 16), + beta_coefficient(4, 1), + banzhaf_coefficient, + shapley_coefficient, + ], +) +def test_coefficients(n: int, coefficient: SVCoefficient): + r"""Coefficients for semi-values must fulfill: + + $$ \sum_{i=1}^{n}\choose{n-1}{j-1}w^{(n)}(j) = 1 $$ + + Note that we depart from the usual definitions by including the factor $1/n$ + in the shapley and beta coefficients. + """ + s = [math.comb(n - 1, j - 1) * coefficient(n, j - 1) for j in range(1, n + 1)] + assert np.isclose(1, np.sum(s)) + + +@pytest.mark.parametrize( + "test_game", + [ + ("symmetric-voting", {"n_players": 4}), + ("shoes", {"left": 1, "right": 1}), + ("shoes", {"left": 2, "right": 1}), + ("shoes", {"left": 1, "right": 2}), + ], + indirect=["test_game"], +) @pytest.mark.parametrize( "sampler", [ DeterministicUniformSampler, DeterministicPermutationSampler, + ], +) +@pytest.mark.parametrize("coefficient", [shapley_coefficient, beta_coefficient(1, 1)]) +def test_games_shapley_deterministic( + test_game, + parallel_config, + n_jobs, + sampler: Type[PowersetSampler], + coefficient: SVCoefficient, + seed: Seed, +): + criterion = MaxUpdates(50) + values = compute_generic_semivalues( + sampler(test_game.u.data.indices, seed=seed), + test_game.u, + coefficient, + criterion, + skip_converged=True, + n_jobs=n_jobs, + config=parallel_config, + progress=True, + ) + exact_values = test_game.shapley_values() + check_values(values, exact_values, rtol=0.1) + + +@pytest.mark.parametrize( + "test_game", + [ + ("symmetric-voting", {"n_players": 6}), + ("shoes", {"left": 3, "right": 2}), + ], + indirect=["test_game"], +) +@pytest.mark.parametrize( + "sampler", + [ UniformSampler, PermutationSampler, pytest.param(AntitheticSampler, marks=pytest.mark.slow), @@ -41,36 +139,55 @@ ], ) @pytest.mark.parametrize("coefficient", [shapley_coefficient, beta_coefficient(1, 1)]) -def test_shapley( - num_samples: int, - analytic_shapley, +def test_games_shapley( + test_game, + parallel_config, + n_jobs, sampler: Type[PowersetSampler], coefficient: SVCoefficient, - n_jobs: int, - parallel_config: ParallelConfig, seed: Seed, ): - u, exact_values = analytic_shapley - criterion = HistoryDeviation(50, 1e-3) | MaxUpdates(1000) + criterion = HistoryDeviation(50, 1e-4) | MaxUpdates(500) values = compute_generic_semivalues( - sampler(u.data.indices, seed=seed), - u, + sampler(test_game.u.data.indices, seed=seed), + test_game.u, coefficient, criterion, skip_converged=True, n_jobs=n_jobs, config=parallel_config, + progress=True, ) + + exact_values = test_game.shapley_values() check_values(values, exact_values, rtol=0.2) @pytest.mark.parametrize( - "num_samples,sampler,coefficient,batch_size", - [(5, PermutationSampler, beta_coefficient(1, 1), 5)], + "test_game", + [ + ("shoes", {"left": 3, "right": 2}), + ], + indirect=["test_game"], +) +@pytest.mark.parametrize( + "sampler, coefficient, batch_size", + [(PermutationSampler, beta_coefficient(1, 1), 5)], +) +@pytest.mark.parametrize( + "n_jobs", + [ + 1, + pytest.param( + 2, + marks=pytest.mark.xfail( + reason="Bad interaction between parallelization and batching" + ), + ), + ], ) def test_shapley_batch_size( - num_samples: int, - analytic_shapley, + test_game, sampler: Type[PermutationSampler], coefficient: SVCoefficient, batch_size: int, @@ -78,13 +195,12 @@ def test_shapley_batch_size( parallel_config: ParallelConfig, seed: Seed, ): - u, exact_values = analytic_shapley timed_fn = timed(compute_generic_semivalues) result_single_batch = timed_fn( - sampler(u.data.indices, seed=seed), - u, + sampler(test_game.u.data.indices, seed=seed), + test_game.u, coefficient, - done=HistoryDeviation(50, 1e-3) | MaxUpdates(1000), + done=MaxUpdates(100), skip_converged=True, n_jobs=n_jobs, batch_size=1, @@ -93,10 +209,10 @@ def test_shapley_batch_size( total_seconds_single_batch = timed_fn.execution_time result_multi_batch = timed_fn( - sampler(u.data.indices, seed=seed), - u, + sampler(test_game.u.data.indices, seed=seed), + test_game.u, coefficient, - done=HistoryDeviation(50, 1e-3) | MaxUpdates(1000), + done=MaxUpdates(100), skip_converged=True, n_jobs=n_jobs, batch_size=batch_size, @@ -141,26 +257,3 @@ def test_banzhaf( config=parallel_config, ) check_values(values, exact_values, rtol=0.2) - - -@pytest.mark.parametrize("n", [10, 100]) -@pytest.mark.parametrize( - "coefficient", - [ - beta_coefficient(1, 1), - beta_coefficient(1, 16), - beta_coefficient(4, 1), - banzhaf_coefficient, - shapley_coefficient, - ], -) -def test_coefficients(n: int, coefficient: SVCoefficient): - r"""Coefficients for semi-values must fulfill: - - $$ \sum_{i=1}^{n}\choose{n-1}{j-1}w^{(n)}(j) = 1 $$ - - Note that we depart from the usual definitions by including the factor $1/n$ - in the shapley and beta coefficients. - """ - s = [math.comb(n - 1, j - 1) * coefficient(n, j - 1) for j in range(1, n + 1)] - assert np.isclose(1, np.sum(s)) From 59401738197b4fb815e8300812b4cef7d51a2d92 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 22 Jan 2024 11:02:28 +0100 Subject: [PATCH 64/87] Add test for the order invariance of updating vauation results --- tests/test_results.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/tests/test_results.py b/tests/test_results.py index 4ea80cf72..4a73586eb 100644 --- a/tests/test_results.py +++ b/tests/test_results.py @@ -4,6 +4,7 @@ import operator import pickle from copy import deepcopy +from itertools import permutations import cloudpickle import numpy as np @@ -159,6 +160,20 @@ def test_updating(): assert v.counts[1] == 2 +def test_updating_order_invariance(): + updates = [0.8, 0.9, 1.0, 1.1, 1.2] + values = [] + for permutation in permutations(updates): + v = ValuationResult.zeros(indices=np.array([0])) + for update in permutation: + v.update(0, update) + values.append(v) + + v1 = values[0] + for v2 in values[1:]: + np.testing.assert_equal(v1.values, v2.values) + + @pytest.mark.parametrize( "serialize, deserialize", [(pickle.dumps, pickle.loads), (cloudpickle.dumps, cloudpickle.loads)], From 4a1b107d1ddcacf42ff670135d3b662d25ec888b Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 22 Jan 2024 11:28:03 +0100 Subject: [PATCH 65/87] Use assert_almost_equal instead of assert_equal in test_updating_order_invariance --- tests/test_results.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_results.py b/tests/test_results.py index 4a73586eb..01870ec94 100644 --- a/tests/test_results.py +++ b/tests/test_results.py @@ -171,7 +171,7 @@ def test_updating_order_invariance(): v1 = values[0] for v2 in values[1:]: - np.testing.assert_equal(v1.values, v2.values) + np.testing.assert_almost_equal(v1.values, v2.values) @pytest.mark.parametrize( From 487071f171fe588870b56c400b44098fac306c0a Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 22 Jan 2024 11:28:31 +0100 Subject: [PATCH 66/87] Fix scorer representation test for newer version of scikit-learn --- tests/utils/test_score.py | 10 +++++++++- tests/value/shapley/test_classwise.py | 10 +++++++++- 2 files changed, 18 insertions(+), 2 deletions(-) diff --git a/tests/utils/test_score.py b/tests/utils/test_score.py index 078775240..5423c48be 100644 --- a/tests/utils/test_score.py +++ b/tests/utils/test_score.py @@ -1,5 +1,7 @@ import numpy as np +import sklearn from numpy.typing import NDArray +from packaging import version from pydvl.utils.score import Scorer, compose_score, squashed_r2, squashed_variance @@ -24,7 +26,13 @@ def test_scorer(): """Tests the Scorer class.""" scorer = Scorer("r2") assert str(scorer) == "r2" - assert repr(scorer) == "R2 (scorer=make_scorer(r2_score))" + if version.parse(sklearn.__version__) >= version.parse("1.4.0"): + assert ( + repr(scorer) + == "R2 (scorer=make_scorer(r2_score, response_method='predict'))" + ) + else: + assert repr(scorer) == "R2 (scorer=make_scorer(r2_score))" coef = np.array([1, 2]) X = np.array([[1, 2], [3, 4]]) diff --git a/tests/value/shapley/test_classwise.py b/tests/value/shapley/test_classwise.py index bd4f55a5d..d73e86a0b 100644 --- a/tests/value/shapley/test_classwise.py +++ b/tests/value/shapley/test_classwise.py @@ -3,7 +3,9 @@ import numpy as np import pandas as pd import pytest +import sklearn from numpy.typing import NDArray +from packaging import version from pydvl.utils import Dataset, Utility, powerset from pydvl.value import MaxChecks, ValuationResult @@ -165,7 +167,13 @@ def test_classwise_scorer_representation(): scorer = ClasswiseScorer("accuracy", initial_label=0) assert str(scorer) == "classwise accuracy" - assert repr(scorer) == "ClasswiseAccuracy (scorer=make_scorer(accuracy_score))" + if version.parse(sklearn.__version__) >= version.parse("1.4.0"): + assert ( + repr(scorer) + == "ClasswiseAccuracy (scorer=make_scorer(accuracy_score, response_method='predict'))" + ) + else: + assert repr(scorer) == "ClasswiseAccuracy (scorer=make_scorer(accuracy_score))" @pytest.mark.parametrize("n_element, left_margin, right_margin", [(101, 0.3, 0.4)]) From f199b7754e42098095d865fb729445f3da20b76d Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 22 Jan 2024 11:46:39 +0100 Subject: [PATCH 67/87] [skip ci] add comment for test_marginal_batch_size --- tests/value/test_semivalues.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tests/value/test_semivalues.py b/tests/value/test_semivalues.py index 1058602b4..e33f92543 100644 --- a/tests/value/test_semivalues.py +++ b/tests/value/test_semivalues.py @@ -42,6 +42,10 @@ [(PermutationSampler, beta_coefficient(1, 1), 5)], ) def test_marginal_batch_size(test_game, sampler, coefficient, batch_size, seed): + # TODO: This test is probably not needed. + # Because I added it and then realized that it doesn't do much. + # The only difference between the two calls is that for the first one + # the loop is outside and the second one the loop is inside. sampler_it = iter(sampler(test_game.u.data.indices, seed=seed)) samples = tuple(islice(sampler_it, batch_size)) From a3f5a53791775808a7d38a0b28c4eac873154f40 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 22 Jan 2024 13:45:05 +0100 Subject: [PATCH 68/87] Small fixes to contributing guide --- CONTRIBUTING.md | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 198c7ded3..3d1bd0dc9 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -343,8 +343,12 @@ runs](#skipping-ci-runs)). 3. We split the tests based on their duration into groups and run them in parallel. For that we use [pytest-split](https://jerry-git.github.io/pytest-split) - to first store the duration of all tests with `pytest --store-durations pytest --slow-tests` + to first store the duration of all tests with + `tox -e tests -- --store-durations --slow-tests` in a `.test_durations` file. + + Alternatively, we case use pytest directly + `pytest --store-durations --slow-tests`. > **Note** This does not have to be done each time a new test or test case > is added. For new tests and test cases pytes-split assumes @@ -359,11 +363,14 @@ runs](#skipping-ci-runs)). Then we can have as many splits as we want: ```shell - pytest --splits 3 --group 1 - pytest --splits 3 --group 2 - pytest --splits 3 --group 3 + tox -e tests -- --splits 3 --group 1 + tox -e tests -- --splits 3 --group 2 + tox -e tests -- --splits 3 --group 3 ``` + Alternatively, we case use pytest directly + `pytest --splits 3 ---group 1`. + Each one of these commands should be run in a separate shell/job to run the test groups in parallel and decrease the total runtime. From 23243fb697f27c80a025156be936146fbf2d9ec6 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Mon, 22 Jan 2024 14:59:37 +0100 Subject: [PATCH 69/87] Update test durations --- .test_durations | 1015 ++++++++++++++++++++++++++++++++--------------- 1 file changed, 696 insertions(+), 319 deletions(-) diff --git a/.test_durations b/.test_durations index bf283f1a9..7a7768311 100644 --- a/.test_durations +++ b/.test_durations @@ -1,4 +1,74 @@ { + "tests/influence/test_influence_calculator.py::test_dask_ekfac_influence[conv1d_nn_pert]": 2.59026943400022, + "tests/influence/test_influence_calculator.py::test_dask_ekfac_influence[conv1d_nn_up]": 2.7703545530002884, + "tests/influence/test_influence_calculator.py::test_dask_ekfac_influence[conv1d_no_grad_up]": 0.8260756999989098, + "tests/influence/test_influence_calculator.py::test_dask_ekfac_influence[conv2d_nn_pert]": 1.101015895999808, + "tests/influence/test_influence_calculator.py::test_dask_ekfac_influence[conv2d_nn_up]": 1.206421760000012, + "tests/influence/test_influence_calculator.py::test_dask_ekfac_influence[conv3d_nn_pert]": 1.4294998579989624, + "tests/influence/test_influence_calculator.py::test_dask_ekfac_influence[conv3d_nn_up]": 1.3345100419992377, + "tests/influence/test_influence_calculator.py::test_dask_ekfac_influence[simple_nn_class_up]": 3.361096810000163, + "tests/influence/test_influence_calculator.py::test_dask_ekfac_influence[simple_nn_pert]": 0.6431655560008949, + "tests/influence/test_influence_calculator.py::test_dask_ekfac_influence[simple_nn_up]": 0.7108467549987836, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[conv1d_nn_pert-arnoldi]": 1.4143697240015172, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[conv1d_nn_pert-cg]": 2.522983850998571, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[conv1d_nn_pert-direct]": 1.3974800130017684, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[conv1d_nn_up-arnoldi]": 1.4222584220005956, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[conv1d_nn_up-cg]": 2.5742563249987143, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[conv1d_nn_up-direct]": 1.3653277730008995, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[conv1d_no_grad_up-arnoldi]": 0.48600830500072334, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[conv1d_no_grad_up-cg]": 0.7124692380002671, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[conv1d_no_grad_up-direct]": 0.47575023000172223, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[conv2d_nn_pert-arnoldi]": 0.8454596849987865, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[conv2d_nn_pert-cg]": 1.7426123529985489, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[conv2d_nn_pert-direct]": 0.808057442000063, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[conv2d_nn_up-arnoldi]": 0.8408936979994905, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[conv2d_nn_up-cg]": 1.8711466349977854, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[conv2d_nn_up-direct]": 0.7968461060008849, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[conv3d_nn_pert-arnoldi]": 1.041476223997961, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[conv3d_nn_pert-cg]": 2.6348945509980695, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[conv3d_nn_pert-direct]": 1.0208977649999724, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[conv3d_nn_up-arnoldi]": 1.3290127370019036, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[conv3d_nn_up-cg]": 5.805227180999282, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[conv3d_nn_up-direct]": 1.8304335940010787, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[simple_nn_class_up-arnoldi]": 1.9109577300005185, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[simple_nn_class_up-cg]": 4.174298836998787, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[simple_nn_class_up-direct]": 1.5329143839990138, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[simple_nn_pert-arnoldi]": 0.4525704900006531, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[simple_nn_pert-cg]": 0.8970914879992051, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[simple_nn_pert-direct]": 0.46585072099878744, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[simple_nn_up-arnoldi]": 0.4456351110020478, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[simple_nn_up-cg]": 1.0693235140006436, + "tests/influence/test_influence_calculator.py::test_dask_influence_factors[simple_nn_up-direct]": 0.473094435999883, + "tests/influence/test_influence_calculator.py::test_dask_influence_nn[conv1d_nn_pert]": 2.9761773999980505, + "tests/influence/test_influence_calculator.py::test_dask_influence_nn[conv1d_nn_up]": 4.120701600999382, + "tests/influence/test_influence_calculator.py::test_dask_influence_nn[conv1d_no_grad_up]": 1.3337201610011107, + "tests/influence/test_influence_calculator.py::test_dask_influence_nn[conv2d_nn_pert]": 2.1662617799993313, + "tests/influence/test_influence_calculator.py::test_dask_influence_nn[conv2d_nn_up]": 3.132741712999632, + "tests/influence/test_influence_calculator.py::test_dask_influence_nn[conv3d_nn_pert]": 2.958187670999905, + "tests/influence/test_influence_calculator.py::test_dask_influence_nn[conv3d_nn_up]": 29.53393912699903, + "tests/influence/test_influence_calculator.py::test_dask_influence_nn[simple_nn_class_up]": 3.257567571998152, + "tests/influence/test_influence_calculator.py::test_dask_influence_nn[simple_nn_pert]": 1.361139677999745, + "tests/influence/test_influence_calculator.py::test_dask_influence_nn[simple_nn_up]": 1.261350679998941, + "tests/influence/test_influence_calculator.py::test_sequential_calculator[conv1d_nn_pert]": 2.6579838110010314, + "tests/influence/test_influence_calculator.py::test_sequential_calculator[conv1d_nn_up]": 2.6499502710012166, + "tests/influence/test_influence_calculator.py::test_sequential_calculator[conv1d_no_grad_up]": 0.8881425300005503, + "tests/influence/test_influence_calculator.py::test_sequential_calculator[conv2d_nn_pert]": 1.463408392999554, + "tests/influence/test_influence_calculator.py::test_sequential_calculator[conv2d_nn_up]": 1.4602782740003022, + "tests/influence/test_influence_calculator.py::test_sequential_calculator[conv3d_nn_pert]": 1.7320480180023878, + "tests/influence/test_influence_calculator.py::test_sequential_calculator[conv3d_nn_up]": 1.5744405670029664, + "tests/influence/test_influence_calculator.py::test_sequential_calculator[simple_nn_class_up]": 4.504372877998321, + "tests/influence/test_influence_calculator.py::test_sequential_calculator[simple_nn_pert]": 0.8736393959989073, + "tests/influence/test_influence_calculator.py::test_sequential_calculator[simple_nn_up]": 0.8922971840001992, + "tests/influence/test_influence_calculator.py::test_thread_safety_violation_error[conv1d_nn_pert]": 2.381483594999736, + "tests/influence/test_influence_calculator.py::test_thread_safety_violation_error[conv1d_nn_up]": 2.314768557000207, + "tests/influence/test_influence_calculator.py::test_thread_safety_violation_error[conv1d_no_grad_up]": 0.7438636890019552, + "tests/influence/test_influence_calculator.py::test_thread_safety_violation_error[conv2d_nn_pert]": 0.9980942529964523, + "tests/influence/test_influence_calculator.py::test_thread_safety_violation_error[conv2d_nn_up]": 1.1705565329993988, + "tests/influence/test_influence_calculator.py::test_thread_safety_violation_error[conv3d_nn_pert]": 1.2230443010012095, + "tests/influence/test_influence_calculator.py::test_thread_safety_violation_error[conv3d_nn_up]": 4.6594328910014156, + "tests/influence/test_influence_calculator.py::test_thread_safety_violation_error[simple_nn_class_up]": 3.0931850600009057, + "tests/influence/test_influence_calculator.py::test_thread_safety_violation_error[simple_nn_pert]": 0.7189972920023138, + "tests/influence/test_influence_calculator.py::test_thread_safety_violation_error[simple_nn_up]": 0.7615732119993481, "tests/influence/test_influences.py::test_influence_linear_model[cg-train_set_size_200-perturbation]": 0.8664472580130678, "tests/influence/test_influences.py::test_influence_linear_model[cg-train_set_size_200-up]": 0.18988716599415056, "tests/influence/test_influences.py::test_influence_linear_model[direct-train_set_size_200-perturbation]": 0.66577532098745, @@ -78,61 +148,230 @@ "tests/influence/test_util.py::test_lanzcos_low_rank_hessian_approx[model_data3-8-160-1e-05]": 4.422049004002474, "tests/influence/test_util.py::test_lanzcos_low_rank_hessian_approx[model_data4-4-250-1e-05]": 9.08382142597111, "tests/influence/test_util.py::test_lanzcos_low_rank_hessian_approx_exception": 0.0035210640053264797, - "tests/test_plugin.py::test_failure": 0.001304317032918334, - "tests/test_plugin.py::test_fixture_call_no_arguments": 0.0014436830242630094, - "tests/test_plugin.py::test_fixture_only[1]": 0.0011941569682676345, - "tests/test_plugin.py::test_fixture_only[2]": 0.0013037140015512705, - "tests/test_plugin.py::test_marker_and_fixture[1]": 0.0011783259978983551, - "tests/test_plugin.py::test_marker_and_fixture[2]": 0.001276884024264291, - "tests/test_plugin.py::test_marker_ignore_exception[0]": 0.0011224850022699684, - "tests/test_plugin.py::test_marker_ignore_exception[1]": 0.0009688139834906906, - "tests/test_plugin.py::test_marker_ignore_exception[2]": 0.0011277040175627917, - "tests/test_plugin.py::test_marker_ignore_exception[3]": 0.001226628024596721, - "tests/test_plugin.py::test_marker_ignore_exception[4]": 0.0010670160118024796, - "tests/test_plugin.py::test_marker_only[0]": 0.0027732179732993245, - "tests/test_plugin.py::test_marker_only_with_data_fixture[0]": 0.0012184199877083302, - "tests/test_plugin.py::test_marker_only_with_data_fixture[1]": 0.0014672029938083142, + "tests/influence/torch/test_functional.py::test_get_hessian[model_data0-4-avg]": 0.20045989400023245, + "tests/influence/torch/test_functional.py::test_get_hessian[model_data0-4-full]": 0.06902083099885203, + "tests/influence/torch/test_functional.py::test_get_hessian[model_data1-5-avg]": 0.5016348780009139, + "tests/influence/torch/test_functional.py::test_get_hessian[model_data1-5-full]": 0.1801713530021516, + "tests/influence/torch/test_functional.py::test_get_hessian[model_data2-10-avg]": 0.1689359069987404, + "tests/influence/torch/test_functional.py::test_get_hessian[model_data2-10-full]": 0.06361526499858883, + "tests/influence/torch/test_functional.py::test_get_hessian[model_data3-8-avg]": 0.23464886900001147, + "tests/influence/torch/test_functional.py::test_get_hessian[model_data3-8-full]": 0.08587454999906186, + "tests/influence/torch/test_functional.py::test_get_hessian[model_data4-4-avg]": 3.4049244679990807, + "tests/influence/torch/test_functional.py::test_get_hessian[model_data4-4-full]": 0.8161465619996306, + "tests/influence/torch/test_functional.py::test_get_hvp_function[model_data0-4-avg-no_precomputed_grad]": 0.07086462199913512, + "tests/influence/torch/test_functional.py::test_get_hvp_function[model_data0-4-avg-precomputed_grad]": 0.05853749299967603, + "tests/influence/torch/test_functional.py::test_get_hvp_function[model_data0-4-full-no_precomputed_grad]": 0.042555562999041285, + "tests/influence/torch/test_functional.py::test_get_hvp_function[model_data0-4-full-precomputed_grad]": 0.04254312700140872, + "tests/influence/torch/test_functional.py::test_get_hvp_function[model_data1-5-avg-no_precomputed_grad]": 0.12398883400055638, + "tests/influence/torch/test_functional.py::test_get_hvp_function[model_data1-5-avg-precomputed_grad]": 0.09578048600087641, + "tests/influence/torch/test_functional.py::test_get_hvp_function[model_data1-5-full-no_precomputed_grad]": 0.08458008900015557, + "tests/influence/torch/test_functional.py::test_get_hvp_function[model_data1-5-full-precomputed_grad]": 0.08726069599833863, + "tests/influence/torch/test_functional.py::test_get_hvp_function[model_data2-10-avg-no_precomputed_grad]": 0.04802275299880421, + "tests/influence/torch/test_functional.py::test_get_hvp_function[model_data2-10-avg-precomputed_grad]": 0.03521194200220634, + "tests/influence/torch/test_functional.py::test_get_hvp_function[model_data2-10-full-no_precomputed_grad]": 0.036551941999277915, + "tests/influence/torch/test_functional.py::test_get_hvp_function[model_data2-10-full-precomputed_grad]": 0.037776481000037165, + "tests/influence/torch/test_functional.py::test_get_hvp_function[model_data3-8-avg-no_precomputed_grad]": 0.07563198299976648, + "tests/influence/torch/test_functional.py::test_get_hvp_function[model_data3-8-avg-precomputed_grad]": 0.06490736200066749, + "tests/influence/torch/test_functional.py::test_get_hvp_function[model_data3-8-full-no_precomputed_grad]": 0.04830970400143997, + "tests/influence/torch/test_functional.py::test_get_hvp_function[model_data3-8-full-precomputed_grad]": 0.046601254001870984, + "tests/influence/torch/test_functional.py::test_get_hvp_function[model_data4-4-avg-no_precomputed_grad]": 0.6670472200003132, + "tests/influence/torch/test_functional.py::test_get_hvp_function[model_data4-4-avg-precomputed_grad]": 0.5045342149987846, + "tests/influence/torch/test_functional.py::test_get_hvp_function[model_data4-4-full-no_precomputed_grad]": 0.2970590019995143, + "tests/influence/torch/test_functional.py::test_get_hvp_function[model_data4-4-full-precomputed_grad]": 0.3075855399983993, + "tests/influence/torch/test_functional.py::test_hvp[model_data0-1e-05]": 0.021658439001839724, + "tests/influence/torch/test_functional.py::test_hvp[model_data1-1e-05]": 0.059265748001053, + "tests/influence/torch/test_functional.py::test_hvp[model_data2-1e-05]": 0.01743878900015261, + "tests/influence/torch/test_functional.py::test_hvp[model_data3-1e-05]": 0.02271863699934329, + "tests/influence/torch/test_functional.py::test_hvp[model_data4-1e-05]": 0.03280089899999439, + "tests/influence/torch/test_functional.py::test_matrix_jacobian_product[100-5-110]": 0.022210784001799766, + "tests/influence/torch/test_functional.py::test_matrix_jacobian_product[25-10-500]": 0.020637996000004932, + "tests/influence/torch/test_functional.py::test_matrix_jacobian_product[46-1-632]": 0.01833421299852489, + "tests/influence/torch/test_functional.py::test_matrix_jacobian_product[50-3-120]": 0.01751421799781383, + "tests/influence/torch/test_functional.py::test_mixed_derivatives[100-5-512]": 1.7785364399987884, + "tests/influence/torch/test_functional.py::test_mixed_derivatives[25-10-734]": 0.27127136799936125, + "tests/influence/torch/test_functional.py::test_mixed_derivatives[46-1-1000]": 0.18510219099880487, + "tests/influence/torch/test_functional.py::test_mixed_derivatives[50-3-100]": 0.055743695000273874, + "tests/influence/torch/test_functional.py::test_per_sample_gradient[100-5-120]": 0.022160912998515414, + "tests/influence/torch/test_functional.py::test_per_sample_gradient[25-10-550]": 0.0378074430009292, + "tests/influence/torch/test_functional.py::test_per_sample_gradient[46-6-632]": 0.033401361002688645, + "tests/influence/torch/test_functional.py::test_per_sample_gradient[50-3-120]": 0.02004740899974422, + "tests/influence/torch/test_influence_model.py::test_influence_linear_model[cg-train_set_size_200-perturbation]": 4.1002855009992345, + "tests/influence/torch/test_influence_model.py::test_influence_linear_model[cg-train_set_size_200-up]": 4.092100218998894, + "tests/influence/torch/test_influence_model.py::test_influence_linear_model[direct-train_set_size_200-perturbation]": 0.5856196849999833, + "tests/influence/torch/test_influence_model.py::test_influence_linear_model[direct-train_set_size_200-up]": 0.1793102950014145, + "tests/influence/torch/test_influence_model.py::test_influence_linear_model[lissa-train_set_size_200-perturbation]": 74.52067036900007, + "tests/influence/torch/test_influence_model.py::test_influence_linear_model[lissa-train_set_size_200-up]": 72.80234433299847, + "tests/influence/torch/test_influence_model.py::test_influences_arnoldi[conv1d_nn_pert]": 2.6213616719978745, + "tests/influence/torch/test_influence_model.py::test_influences_arnoldi[conv1d_nn_up]": 2.9271264809995046, + "tests/influence/torch/test_influence_model.py::test_influences_arnoldi[conv1d_no_grad_up]": 1.1280039110006328, + "tests/influence/torch/test_influence_model.py::test_influences_arnoldi[conv2d_nn_pert]": 16.078887900001064, + "tests/influence/torch/test_influence_model.py::test_influences_arnoldi[conv2d_nn_up]": 16.092805495001812, + "tests/influence/torch/test_influence_model.py::test_influences_arnoldi[conv3d_nn_pert]": 5.826150597002197, + "tests/influence/torch/test_influence_model.py::test_influences_arnoldi[conv3d_nn_up]": 5.808433192996745, + "tests/influence/torch/test_influence_model.py::test_influences_arnoldi[simple_nn_class_up]": 3.4398634410008526, + "tests/influence/torch/test_influence_model.py::test_influences_arnoldi[simple_nn_pert]": 1.783800326000346, + "tests/influence/torch/test_influence_model.py::test_influences_arnoldi[simple_nn_up]": 1.5235134640006436, + "tests/influence/torch/test_influence_model.py::test_influences_ekfac[conv1d_nn_pert]": 2.470179049998478, + "tests/influence/torch/test_influence_model.py::test_influences_ekfac[conv1d_nn_up]": 2.3925959699990926, + "tests/influence/torch/test_influence_model.py::test_influences_ekfac[conv1d_no_grad_up]": 0.7791441699991992, + "tests/influence/torch/test_influence_model.py::test_influences_ekfac[conv2d_nn_pert]": 1.128924710001229, + "tests/influence/torch/test_influence_model.py::test_influences_ekfac[conv2d_nn_up]": 1.256267286998991, + "tests/influence/torch/test_influence_model.py::test_influences_ekfac[conv3d_nn_pert]": 1.2739636030000838, + "tests/influence/torch/test_influence_model.py::test_influences_ekfac[conv3d_nn_up]": 1.2143029310009297, + "tests/influence/torch/test_influence_model.py::test_influences_ekfac[simple_nn_class_up]": 3.279752685999483, + "tests/influence/torch/test_influence_model.py::test_influences_ekfac[simple_nn_pert]": 0.7043358350001654, + "tests/influence/torch/test_influence_model.py::test_influences_ekfac[simple_nn_up]": 0.7221000240006106, + "tests/influence/torch/test_influence_model.py::test_influences_nn[conv1d_nn_pert-cg]": 2.666355408999152, + "tests/influence/torch/test_influence_model.py::test_influences_nn[conv1d_nn_pert-lissa]": 3.536100011000599, + "tests/influence/torch/test_influence_model.py::test_influences_nn[conv1d_nn_up-cg]": 2.8996486520009057, + "tests/influence/torch/test_influence_model.py::test_influences_nn[conv1d_nn_up-lissa]": 3.648799233000318, + "tests/influence/torch/test_influence_model.py::test_influences_nn[conv1d_no_grad_up-cg]": 0.846027261000927, + "tests/influence/torch/test_influence_model.py::test_influences_nn[conv1d_no_grad_up-lissa]": 1.46926116800023, + "tests/influence/torch/test_influence_model.py::test_influences_nn[conv2d_nn_pert-cg]": 1.322623816999112, + "tests/influence/torch/test_influence_model.py::test_influences_nn[conv2d_nn_pert-lissa]": 2.4566458920016885, + "tests/influence/torch/test_influence_model.py::test_influences_nn[conv2d_nn_up-cg]": 1.3719535260006523, + "tests/influence/torch/test_influence_model.py::test_influences_nn[conv2d_nn_up-lissa]": 2.3520564940008626, + "tests/influence/torch/test_influence_model.py::test_influences_nn[conv3d_nn_pert-cg]": 1.4215319300001283, + "tests/influence/torch/test_influence_model.py::test_influences_nn[conv3d_nn_pert-lissa]": 2.5365598410025996, + "tests/influence/torch/test_influence_model.py::test_influences_nn[conv3d_nn_up-cg]": 1.4816708039998048, + "tests/influence/torch/test_influence_model.py::test_influences_nn[conv3d_nn_up-lissa]": 2.420441305001077, + "tests/influence/torch/test_influence_model.py::test_influences_nn[simple_nn_class_up-cg]": 3.5962213779985177, + "tests/influence/torch/test_influence_model.py::test_influences_nn[simple_nn_class_up-lissa]": 4.116930427000625, + "tests/influence/torch/test_influence_model.py::test_influences_nn[simple_nn_pert-cg]": 0.8423471179994522, + "tests/influence/torch/test_influence_model.py::test_influences_nn[simple_nn_pert-lissa]": 1.8240221239993843, + "tests/influence/torch/test_influence_model.py::test_influences_nn[simple_nn_up-cg]": 0.8927097550003964, + "tests/influence/torch/test_influence_model.py::test_influences_nn[simple_nn_up-lissa]": 1.7715864019992296, + "tests/influence/torch/test_util.py::test_align_structure_error[source0-target0]": 0.008872623999195639, + "tests/influence/torch/test_util.py::test_align_structure_error[source1-target1]": 0.008990501999505796, + "tests/influence/torch/test_util.py::test_align_structure_error[source2-unsupported]": 0.008625348000350641, + "tests/influence/torch/test_util.py::test_align_structure_success[source0-target0]": 0.009682354999313247, + "tests/influence/torch/test_util.py::test_align_structure_success[source1-target1]": 0.011076738001065678, + "tests/influence/torch/test_util.py::test_align_structure_success[source2-target2]": 0.008422474998951657, + "tests/influence/torch/test_util.py::test_batch_hvp[model_data0-1e-05]": 0.018433343999276985, + "tests/influence/torch/test_util.py::test_batch_hvp[model_data1-1e-05]": 0.04329261199745815, + "tests/influence/torch/test_util.py::test_batch_hvp[model_data2-1e-05]": 0.021779085998787195, + "tests/influence/torch/test_util.py::test_batch_hvp[model_data3-1e-05]": 0.02447877800113929, + "tests/influence/torch/test_util.py::test_batch_hvp[model_data4-1e-05]": 0.027325978000590112, + "tests/influence/torch/test_util.py::test_get_hvp_function[model_data0-4-avg]": 0.05654373300058069, + "tests/influence/torch/test_util.py::test_get_hvp_function[model_data0-4-full]": 0.048235695001494605, + "tests/influence/torch/test_util.py::test_get_hvp_function[model_data1-5-avg]": 0.10194805900027859, + "tests/influence/torch/test_util.py::test_get_hvp_function[model_data1-5-full]": 0.07934144700084289, + "tests/influence/torch/test_util.py::test_get_hvp_function[model_data2-10-avg]": 0.04320316699704563, + "tests/influence/torch/test_util.py::test_get_hvp_function[model_data2-10-full]": 0.03360124099890527, + "tests/influence/torch/test_util.py::test_get_hvp_function[model_data3-8-avg]": 0.062039004000325804, + "tests/influence/torch/test_util.py::test_get_hvp_function[model_data3-8-full]": 0.039968260998648475, + "tests/influence/torch/test_util.py::test_get_hvp_function[model_data4-4-avg]": 0.5075304600013624, + "tests/influence/torch/test_util.py::test_get_hvp_function[model_data4-4-full]": 0.29033965000235185, + "tests/influence/torch/test_util.py::test_lanzcos_low_rank_hessian_approx[model_data0-4-200-0.0001]": 6.130291282001053, + "tests/influence/torch/test_util.py::test_lanzcos_low_rank_hessian_approx[model_data1-5-70-0.001]": 7.575732932000392, + "tests/influence/torch/test_util.py::test_lanzcos_low_rank_hessian_approx[model_data2-10-50-0.0001]": 5.145587835002516, + "tests/influence/torch/test_util.py::test_lanzcos_low_rank_hessian_approx[model_data3-8-160-1e-05]": 9.05795658399984, + "tests/influence/torch/test_util.py::test_lanzcos_low_rank_hessian_approx[model_data4-4-250-1e-05]": 15.930120687000453, + "tests/influence/torch/test_util.py::test_lanzcos_low_rank_hessian_approx_exception": 0.010992516999976942, + "tests/influence/torch/test_util.py::test_torch_dataset_to_dask_array[tailing_dimensions0-30-5]": 0.3716939040004945, + "tests/influence/torch/test_util.py::test_torch_dataset_to_dask_array[tailing_dimensions0-30-6]": 0.3245709369984979, + "tests/influence/torch/test_util.py::test_torch_dataset_to_dask_array[tailing_dimensions0-45-5]": 0.4916222280025977, + "tests/influence/torch/test_util.py::test_torch_dataset_to_dask_array[tailing_dimensions0-45-6]": 0.44272739400003047, + "tests/influence/torch/test_util.py::test_torch_dataset_to_dask_array[tailing_dimensions0-50-5]": 11.764691698001116, + "tests/influence/torch/test_util.py::test_torch_dataset_to_dask_array[tailing_dimensions0-50-6]": 6.499053524999908, + "tests/influence/torch/test_util.py::test_torch_dataset_to_dask_array[tailing_dimensions1-30-5]": 0.3747018210015085, + "tests/influence/torch/test_util.py::test_torch_dataset_to_dask_array[tailing_dimensions1-30-6]": 0.33021277699845086, + "tests/influence/torch/test_util.py::test_torch_dataset_to_dask_array[tailing_dimensions1-45-5]": 0.5002059710004687, + "tests/influence/torch/test_util.py::test_torch_dataset_to_dask_array[tailing_dimensions1-45-6]": 0.46272212300027604, + "tests/influence/torch/test_util.py::test_torch_dataset_to_dask_array[tailing_dimensions1-50-5]": 0.5805674699986412, + "tests/influence/torch/test_util.py::test_torch_dataset_to_dask_array[tailing_dimensions1-50-6]": 0.5113370569997642, + "tests/influence/torch/test_util.py::test_torch_dataset_to_dask_array[tailing_dimensions2-30-5]": 0.44749919500100077, + "tests/influence/torch/test_util.py::test_torch_dataset_to_dask_array[tailing_dimensions2-30-6]": 0.37910716500118724, + "tests/influence/torch/test_util.py::test_torch_dataset_to_dask_array[tailing_dimensions2-45-5]": 0.5593350939998345, + "tests/influence/torch/test_util.py::test_torch_dataset_to_dask_array[tailing_dimensions2-45-6]": 0.47198495200063917, + "tests/influence/torch/test_util.py::test_torch_dataset_to_dask_array[tailing_dimensions2-50-5]": 0.5512238980008988, + "tests/influence/torch/test_util.py::test_torch_dataset_to_dask_array[tailing_dimensions2-50-6]": 0.5188143759987724, + "tests/test_plugin.py::test_failure": 0.003285975997641799, + "tests/test_plugin.py::test_fixture_call_no_arguments": 0.0033647860000201035, + "tests/test_plugin.py::test_fixture_only[1]": 0.0034970750002685236, + "tests/test_plugin.py::test_fixture_only[2]": 0.0034195480002381373, + "tests/test_plugin.py::test_marker_and_fixture[1]": 0.0034149520015489543, + "tests/test_plugin.py::test_marker_and_fixture[2]": 0.003513548002956668, + "tests/test_plugin.py::test_marker_ignore_exception[0]": 0.003384523999557132, + "tests/test_plugin.py::test_marker_ignore_exception[1]": 0.00331666099918948, + "tests/test_plugin.py::test_marker_ignore_exception[2]": 0.00323147399831214, + "tests/test_plugin.py::test_marker_ignore_exception[3]": 0.0032334910029021557, + "tests/test_plugin.py::test_marker_ignore_exception[4]": 0.003230911001082859, + "tests/test_plugin.py::test_marker_only[0]": 0.006288947000939515, + "tests/test_plugin.py::test_marker_only_with_data_fixture[0]": 0.003481858999293763, + "tests/test_plugin.py::test_marker_only_with_data_fixture[1]": 0.003525184998579789, "tests/test_plugin.py::test_marker_only_with_data_fixture[2]": 0.0012167239910922945, - "tests/test_results.py::test_adding_different_indices[indices_10-names_10-values_10-indices_20-names_20-values_20-expected_indices0-expected_names0-expected_values0]": 0.0020641259907279164, - "tests/test_results.py::test_adding_different_indices[indices_11-names_11-values_11-indices_21-names_21-values_21-expected_indices1-expected_names1-expected_values1]": 0.002675808995263651, - "tests/test_results.py::test_adding_different_indices[indices_12-names_12-values_12-indices_22-names_22-values_22-expected_indices2-expected_names2-expected_values2]": 0.002674269024282694, - "tests/test_results.py::test_adding_different_indices[indices_13-names_13-values_13-indices_23-names_23-values_23-expected_indices3-expected_names3-expected_values3]": 0.0020707659714389592, - "tests/test_results.py::test_adding_random": 0.0034820580040104687, - "tests/test_results.py::test_dataframe_sorting[values0-names0-ranks_asc0]": 0.0029723149491474032, - "tests/test_results.py::test_dataframe_sorting[values1-names1-ranks_asc1]": 0.002218269946752116, - "tests/test_results.py::test_empty[0]": 0.0012037760170642287, - "tests/test_results.py::test_empty[5]": 0.001365817035548389, - "tests/test_results.py::test_empty_deprecation": 0.0013571020099334419, - "tests/test_results.py::test_equality[values0-names0]": 0.0021291770099196583, - "tests/test_results.py::test_equality[values1-names1]": 0.0016342299932148308, - "tests/test_results.py::test_extra_values[extra_values0]": 0.001437259983504191, - "tests/test_results.py::test_extra_values[extra_values1]": 0.0015066640044096857, - "tests/test_results.py::test_from_random_creation[-1.0-10]": 0.0015409209881909192, - "tests/test_results.py::test_from_random_creation[-1.0-1]": 0.0014630080258939415, - "tests/test_results.py::test_from_random_creation[1.0-10]": 0.0012284110125619918, - "tests/test_results.py::test_from_random_creation[1.0-1]": 0.0013108189741615206, - "tests/test_results.py::test_from_random_creation[None-10]": 0.0012196720344945788, - "tests/test_results.py::test_from_random_creation[None-1]": 0.0015253000019583851, - "tests/test_results.py::test_from_random_creation_errors": 0.0009378239628858864, - "tests/test_results.py::test_get_idx": 0.0010275309905409813, - "tests/test_results.py::test_indexing[values0-names0-ranks_asc0]": 0.0014630479854531586, - "tests/test_results.py::test_indexing[values1-names1-ranks_asc1]": 0.001598447997821495, - "tests/test_results.py::test_iter[values0-names0-ranks_asc0]": 0.0013525879476219416, - "tests/test_results.py::test_iter[values1-names1-ranks_asc1]": 0.0014122460270300508, - "tests/test_results.py::test_names[data_names0]": 0.0015603950014337897, - "tests/test_results.py::test_serialization[values0-None-dumps-loads0]": 0.001649087033001706, - "tests/test_results.py::test_serialization[values0-None-dumps-loads1]": 0.0016458219906780869, - "tests/test_results.py::test_serialization[values1-None-dumps-loads0]": 0.0015400749980472028, - "tests/test_results.py::test_serialization[values1-None-dumps-loads1]": 0.0019450989784672856, - "tests/test_results.py::test_sorting[values0-names0-ranks_asc0]": 0.0016402129840571433, - "tests/test_results.py::test_sorting[values1-names1-ranks_asc1]": 0.0016363860049750656, - "tests/test_results.py::test_todataframe[values0-names0-ranks_asc0]": 0.0023001570079941303, - "tests/test_results.py::test_todataframe[values1-names1-ranks_asc1]": 0.002222412033006549, - "tests/test_results.py::test_types[indices0-int32-data_names0---True]": 0.013553835999118746, + "tests/utils/test_caching.py::test_cached_func_hash_function[foo--False]": 0.009608976999516017, + "tests/utils/test_caching.py::test_cached_func_hash_function[foo-foo-True]": 0.007844682999348151, + "tests/utils/test_caching.py::test_cached_func_hash_function[foo-foo_duplicate-True]": 0.00921746999847528, + "tests/utils/test_caching.py::test_cached_func_hash_function[foo-foo_with_random-False]": 0.006780997000532807, + "tests/utils/test_caching.py::test_cached_func_hash_function[foo_with_random-foo_with_random_and_sleep-False]": 0.008397087000048487, "tests/utils/test_caching.py::test_failed_connection": 0.0039788429858163, + "tests/utils/test_caching.py::test_faster_with_repeated_training[disk]": 5.499508081999011, + "tests/utils/test_caching.py::test_faster_with_repeated_training[in-memory]": 5.596929604998877, + "tests/utils/test_caching.py::test_faster_with_repeated_training[memcached]": 6.545152930997574, + "tests/utils/test_caching.py::test_memcached_failed_connection": 0.009630470000047353, "tests/utils/test_caching.py::test_memcached_faster_with_repeated_training": 5.003239913989091, "tests/utils/test_caching.py::test_memcached_parallel_jobs[joblib]": 3.1677759810409043, "tests/utils/test_caching.py::test_memcached_parallel_jobs[ray-external]": 38.430890925985295, @@ -151,303 +390,439 @@ "tests/utils/test_caching.py::test_memcached_parallel_repeated_training[ray-local-20-2-20-10]": 0.007027510990155861, "tests/utils/test_caching.py::test_memcached_repeated_training": 2.3077823049970903, "tests/utils/test_caching.py::test_memcached_single_job": 0.007132280006771907, - "tests/utils/test_dataset.py::test_creating_dataset_from_sklearn[0.1]": 0.009810923977056518, - "tests/utils/test_dataset.py::test_creating_dataset_from_sklearn[0.5]": 0.0023630280047655106, - "tests/utils/test_dataset.py::test_creating_dataset_from_sklearn[0.8]": 0.002483188029145822, - "tests/utils/test_dataset.py::test_creating_dataset_from_x_y_arrays[0.1-kwargs0]": 0.0022864479979034513, - "tests/utils/test_dataset.py::test_creating_dataset_from_x_y_arrays[0.1-kwargs1]": 0.001960736990440637, - "tests/utils/test_dataset.py::test_creating_dataset_from_x_y_arrays[0.5-kwargs0]": 0.0018571619875729084, - "tests/utils/test_dataset.py::test_creating_dataset_from_x_y_arrays[0.5-kwargs1]": 0.0019256969972047955, - "tests/utils/test_dataset.py::test_creating_dataset_from_x_y_arrays[0.8-kwargs0]": 0.0020103229908272624, - "tests/utils/test_dataset.py::test_creating_dataset_from_x_y_arrays[0.8-kwargs1]": 0.001870437990874052, - "tests/utils/test_dataset.py::test_creating_dataset_subsclassfrom_sklearn[0.1]": 0.004145220998907462, - "tests/utils/test_dataset.py::test_creating_dataset_subsclassfrom_sklearn[0.5]": 0.002273507008794695, - "tests/utils/test_dataset.py::test_creating_dataset_subsclassfrom_sklearn[0.8]": 0.0025340290158055723, - "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_sklearn[0.1]": 0.002445343037834391, - "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_sklearn[0.5]": 0.002387374988757074, - "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_sklearn[0.8]": 0.0025074610312003642, - "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_sklearn_failure[0.1]": 0.0031885300122667104, - "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_sklearn_failure[0.5]": 0.0018069100042339414, - "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_sklearn_failure[0.8]": 0.0019649149908218533, - "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_x_y_arrays[0.1-kwargs0]": 0.002473844971973449, - "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_x_y_arrays[0.1-kwargs1]": 0.0024133779807016253, - "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_x_y_arrays[0.5-kwargs0]": 0.0023138070246204734, - "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_x_y_arrays[0.5-kwargs1]": 0.002177672984544188, - "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_x_y_arrays[0.8-kwargs0]": 0.0030658979958388954, - "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_x_y_arrays[0.8-kwargs1]": 0.002469450992066413, - "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_x_y_arrays_failure[0.1]": 0.0016314840177074075, - "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_x_y_arrays_failure[0.5]": 0.0017394520109519362, - "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_x_y_arrays_failure[0.8]": 0.0017109749896917492, - "tests/utils/test_dataset.py::test_creating_grouped_dataset_subsclassfrom_sklearn[0.1]": 0.003284825972514227, - "tests/utils/test_dataset.py::test_creating_grouped_dataset_subsclassfrom_sklearn[0.5]": 0.0038210980128496885, - "tests/utils/test_dataset.py::test_creating_grouped_dataset_subsclassfrom_sklearn[0.8]": 0.0023955479555297643, - "tests/utils/test_dataset.py::test_grouped_dataset_results": 0.00312941602896899, - "tests/utils/test_numeric.py::test_powerset": 0.002356015960685909, - "tests/utils/test_numeric.py::test_random_matrix_with_condition_number[0-2-ValueError]": 0.0011365640093572438, - "tests/utils/test_numeric.py::test_random_matrix_with_condition_number[1-2-ValueError]": 0.0010459299955982715, - "tests/utils/test_numeric.py::test_random_matrix_with_condition_number[10-1-ValueError]": 0.0011281229672022164, - "tests/utils/test_numeric.py::test_random_matrix_with_condition_number[10-2-None]": 0.001765107037499547, - "tests/utils/test_numeric.py::test_random_matrix_with_condition_number[2-10-None]": 0.001528021995909512, - "tests/utils/test_numeric.py::test_random_matrix_with_condition_number[4--2-ValueError]": 0.0011659429874271154, - "tests/utils/test_numeric.py::test_random_matrix_with_condition_number[7-23-None]": 0.001419320033164695, - "tests/utils/test_numeric.py::test_random_matrix_with_condition_number_reproducible[10-2]": 0.001462101994547993, - "tests/utils/test_numeric.py::test_random_matrix_with_condition_number_reproducible[2-10]": 0.001395261992001906, - "tests/utils/test_numeric.py::test_random_matrix_with_condition_number_reproducible[7-23]": 0.001416039012838155, - "tests/utils/test_numeric.py::test_random_matrix_with_condition_number_stochastic[10-2]": 0.0015627649845555425, - "tests/utils/test_numeric.py::test_random_matrix_with_condition_number_stochastic[2-10]": 0.0014263579796534032, - "tests/utils/test_numeric.py::test_random_matrix_with_condition_number_stochastic[7-23]": 0.0016800050216261297, - "tests/utils/test_numeric.py::test_random_powerset[0-1]": 0.0012409990013111383, - "tests/utils/test_numeric.py::test_random_powerset[1-10]": 0.0014637470012530684, - "tests/utils/test_numeric.py::test_random_powerset[10-1024]": 0.0079122620227281, - "tests/utils/test_numeric.py::test_random_powerset[5-128]": 0.0020825770043302327, - "tests/utils/test_numeric.py::test_random_powerset_label_min[0-10-3-1000]": 0.11152737599331886, - "tests/utils/test_numeric.py::test_random_powerset_label_min[1-10-3-1000]": 0.11375491399667226, - "tests/utils/test_numeric.py::test_random_powerset_label_min[2-10-3-1000]": 0.11396494103246368, - "tests/utils/test_numeric.py::test_random_powerset_reproducible[10-1024]": 0.013066521001746878, - "tests/utils/test_numeric.py::test_random_powerset_stochastic[10-1024]": 0.012338358006672934, - "tests/utils/test_numeric.py::test_random_subset_of_size[0-0-None]": 0.0015464180323760957, - "tests/utils/test_numeric.py::test_random_subset_of_size[0-1-ValueError]": 0.001127758005168289, - "tests/utils/test_numeric.py::test_random_subset_of_size[10-0-None]": 0.0013323969906195998, - "tests/utils/test_numeric.py::test_random_subset_of_size[10-3-None]": 0.0015970039821695536, - "tests/utils/test_numeric.py::test_random_subset_of_size[1000-40-None]": 0.001427212991984561, - "tests/utils/test_numeric.py::test_random_subset_of_size_stochastic[10-3]": 0.001142591005191207, - "tests/utils/test_numeric.py::test_random_subset_of_size_stochastic[1000-40]": 0.0012538870214484632, - "tests/utils/test_numeric.py::test_running_moments": 0.35335890398710035, - "tests/utils/test_parallel.py::test_chunkification[joblib-data0-3-expected_chunks0]": 0.0042906299931928515, - "tests/utils/test_parallel.py::test_chunkification[joblib-data1-2-expected_chunks1]": 0.004308464995119721, - "tests/utils/test_parallel.py::test_chunkification[joblib-data2-2-expected_chunks2]": 0.004244079987984151, - "tests/utils/test_parallel.py::test_chunkification[joblib-data3-3-expected_chunks3]": 0.004028873983770609, - "tests/utils/test_parallel.py::test_chunkification[joblib-data4-5-expected_chunks4]": 0.004101024009287357, - "tests/utils/test_parallel.py::test_chunkification[joblib-data5-42-expected_chunks5]": 0.004789252998307347, - "tests/utils/test_parallel.py::test_chunkification[joblib-data6-42-expected_chunks6]": 0.004256373038515449, - "tests/utils/test_parallel.py::test_chunkification[joblib-data7-4-expected_chunks7]": 0.004143773025134578, - "tests/utils/test_parallel.py::test_chunkification[joblib-data8-4-expected_chunks8]": 0.0040604640380479395, - "tests/utils/test_parallel.py::test_chunkification[ray-external-data0-3-expected_chunks0]": 0.0060307729872874916, - "tests/utils/test_parallel.py::test_chunkification[ray-external-data1-2-expected_chunks1]": 0.005929058010224253, - "tests/utils/test_parallel.py::test_chunkification[ray-external-data2-2-expected_chunks2]": 0.009121662005782127, - "tests/utils/test_parallel.py::test_chunkification[ray-external-data3-3-expected_chunks3]": 0.009956339985365048, - "tests/utils/test_parallel.py::test_chunkification[ray-external-data4-5-expected_chunks4]": 0.010149178997380659, - "tests/utils/test_parallel.py::test_chunkification[ray-external-data5-42-expected_chunks5]": 0.010347278992412612, - "tests/utils/test_parallel.py::test_chunkification[ray-external-data6-42-expected_chunks6]": 0.010047424992080778, - "tests/utils/test_parallel.py::test_chunkification[ray-external-data7-4-expected_chunks7]": 0.008645244990475476, - "tests/utils/test_parallel.py::test_chunkification[ray-external-data8-4-expected_chunks8]": 0.009245932975318283, - "tests/utils/test_parallel.py::test_chunkification[ray-local-data0-3-expected_chunks0]": 0.0045589170476887375, - "tests/utils/test_parallel.py::test_chunkification[ray-local-data1-2-expected_chunks1]": 0.004910157964332029, - "tests/utils/test_parallel.py::test_chunkification[ray-local-data2-2-expected_chunks2]": 0.004910080024274066, - "tests/utils/test_parallel.py::test_chunkification[ray-local-data3-3-expected_chunks3]": 0.0059317940031178296, - "tests/utils/test_parallel.py::test_chunkification[ray-local-data4-5-expected_chunks4]": 0.008992511982796714, - "tests/utils/test_parallel.py::test_chunkification[ray-local-data5-42-expected_chunks5]": 0.008223566022934392, - "tests/utils/test_parallel.py::test_chunkification[ray-local-data6-42-expected_chunks6]": 0.007052068045595661, - "tests/utils/test_parallel.py::test_chunkification[ray-local-data7-4-expected_chunks7]": 0.004718763986602426, - "tests/utils/test_parallel.py::test_chunkification[ray-local-data8-4-expected_chunks8]": 0.005322564014932141, - "tests/utils/test_parallel.py::test_effective_n_jobs[joblib]": 0.0014253620174713433, - "tests/utils/test_parallel.py::test_effective_n_jobs[ray-external]": 3.978927739954088, - "tests/utils/test_parallel.py::test_effective_n_jobs[ray-local]": 4.104055134986993, - "tests/utils/test_parallel.py::test_future_cancellation[joblib]": 0.005014022986870259, - "tests/utils/test_parallel.py::test_future_cancellation[ray-external]": 1.9293224809807725, - "tests/utils/test_parallel.py::test_future_cancellation[ray-local]": 0.07703918303013779, - "tests/utils/test_parallel.py::test_futures_executor_map[joblib]": 1.5601177359640133, - "tests/utils/test_parallel.py::test_futures_executor_map[ray-external]": 0.09417001300607808, - "tests/utils/test_parallel.py::test_futures_executor_map[ray-local]": 0.09271710200118832, - "tests/utils/test_parallel.py::test_futures_executor_map_with_max_workers[joblib]": 0.007176648010499775, - "tests/utils/test_parallel.py::test_futures_executor_map_with_max_workers[ray-external]": 1.090440120024141, - "tests/utils/test_parallel.py::test_futures_executor_map_with_max_workers[ray-local]": 1.095393077004701, - "tests/utils/test_parallel.py::test_futures_executor_submit[joblib]": 1.8566069509834051, - "tests/utils/test_parallel.py::test_futures_executor_submit[ray-external]": 0.04992300402955152, - "tests/utils/test_parallel.py::test_futures_executor_submit[ray-local]": 0.048481280013220385, - "tests/utils/test_parallel.py::test_map_reduce_job[joblib-1-list-indices0-expected0]": 0.0015987549850251526, - "tests/utils/test_parallel.py::test_map_reduce_job[joblib-1-list-indices1-expected1]": 0.001547530002426356, - "tests/utils/test_parallel.py::test_map_reduce_job[joblib-1-list-indices2-expected2]": 0.001560483971843496, - "tests/utils/test_parallel.py::test_map_reduce_job[joblib-1-numpy-indices4-45]": 0.00178057502489537, - "tests/utils/test_parallel.py::test_map_reduce_job[joblib-1-range-indices3-expected3]": 0.0015469170466531068, - "tests/utils/test_parallel.py::test_map_reduce_job[joblib-2-list-indices0-expected0]": 0.0018091480305884033, - "tests/utils/test_parallel.py::test_map_reduce_job[joblib-2-list-indices1-expected1]": 0.01276223495369777, - "tests/utils/test_parallel.py::test_map_reduce_job[joblib-2-list-indices2-expected2]": 0.012882986018666998, - "tests/utils/test_parallel.py::test_map_reduce_job[joblib-2-numpy-indices4-45]": 0.01399321696953848, - "tests/utils/test_parallel.py::test_map_reduce_job[joblib-2-range-indices3-expected3]": 0.012885421980172396, - "tests/utils/test_parallel.py::test_map_reduce_job[joblib-4-list-indices0-expected0]": 0.15361307095736265, - "tests/utils/test_parallel.py::test_map_reduce_job[joblib-4-list-indices1-expected1]": 0.8156346119940281, - "tests/utils/test_parallel.py::test_map_reduce_job[joblib-4-list-indices2-expected2]": 1.3068530370073859, - "tests/utils/test_parallel.py::test_map_reduce_job[joblib-4-numpy-indices4-45]": 0.01750938399345614, - "tests/utils/test_parallel.py::test_map_reduce_job[joblib-4-range-indices3-expected3]": 0.017205809010192752, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-1-list-indices0-expected0]": 0.0029827099933754653, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-1-list-indices1-expected1]": 0.0027304230316076428, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-1-list-indices2-expected2]": 0.0026203590095974505, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-1-numpy-indices4-45]": 0.003456770005868748, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-1-range-indices3-expected3]": 0.0027074709651060402, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-2-list-indices0-expected0]": 0.8282912400027271, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-2-list-indices1-expected1]": 2.2837093910493422, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-2-list-indices2-expected2]": 2.4645657170040067, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-2-numpy-indices4-45]": 2.281004316988401, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-2-range-indices3-expected3]": 2.393285626982106, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-4-list-indices0-expected0]": 1.903353853005683, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-4-list-indices1-expected1]": 2.947957994969329, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-4-list-indices2-expected2]": 3.211508878011955, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-4-numpy-indices4-45]": 3.3349247129808646, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-4-range-indices3-expected3]": 3.599037625041092, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-1-list-indices0-expected0]": 0.016201907012145966, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-1-list-indices1-expected1]": 0.013995222019730136, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-1-list-indices2-expected2]": 0.013650566979777068, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-1-numpy-indices4-45]": 0.013722714997129515, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-1-range-indices3-expected3]": 0.013983122975332662, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-2-list-indices0-expected0]": 1.5035187809844501, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-2-list-indices1-expected1]": 2.235937710967846, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-2-list-indices2-expected2]": 2.1283504489983898, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-2-numpy-indices4-45]": 2.0944344620220363, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-2-range-indices3-expected3]": 2.104675643990049, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-4-list-indices0-expected0]": 1.7145587989652995, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-4-list-indices1-expected1]": 2.772829012013972, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-4-list-indices2-expected2]": 3.1254515810287558, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-4-numpy-indices4-45]": 3.4023931239789817, - "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-4-range-indices3-expected3]": 3.7103631219943054, - "tests/utils/test_parallel.py::test_map_reduce_job_partial_map_and_reduce_func[joblib]": 0.01629631401738152, - "tests/utils/test_parallel.py::test_map_reduce_job_partial_map_and_reduce_func[ray-external]": 3.550109267991502, - "tests/utils/test_parallel.py::test_map_reduce_job_partial_map_and_reduce_func[ray-local]": 3.186494815017795, - "tests/utils/test_parallel.py::test_map_reduce_seeding[joblib-42-12]": 0.05403909899177961, - "tests/utils/test_parallel.py::test_map_reduce_seeding[ray-external-42-12]": 9.918427228025394, - "tests/utils/test_parallel.py::test_map_reduce_seeding[ray-local-42-12]": 9.834357938991161, - "tests/utils/test_parallel.py::test_wrap_function[joblib]": 0.0031614619656465948, - "tests/utils/test_parallel.py::test_wrap_function[ray-external]": 3.1981390729779378, - "tests/utils/test_parallel.py::test_wrap_function[ray-local]": 3.2998613989911973, - "tests/utils/test_score.py::test_compose_score": 0.0027295449981465936, - "tests/utils/test_score.py::test_scorer": 0.0051104900194332, - "tests/utils/test_score.py::test_squashed_r2": 0.001943372975802049, - "tests/utils/test_score.py::test_squashed_variance": 0.001487176021328196, - "tests/utils/test_status.py::test_and_status": 0.001112824014853686, - "tests/utils/test_status.py::test_not_status": 0.0010235870140604675, - "tests/utils/test_status.py::test_or_status": 0.0009352969937026501, + "tests/utils/test_caching.py::test_parallel_jobs[joblib-disk]": 0.008082594998995773, + "tests/utils/test_caching.py::test_parallel_jobs[joblib-in-memory]": 0.007858986000428558, + "tests/utils/test_caching.py::test_parallel_jobs[joblib-memcached]": 5.864486223999847, + "tests/utils/test_caching.py::test_parallel_jobs[ray-external-disk]": 0.019337756999448175, + "tests/utils/test_caching.py::test_parallel_jobs[ray-external-in-memory]": 3.8737009590004163, + "tests/utils/test_caching.py::test_parallel_jobs[ray-external-memcached]": 0.010424148002130096, + "tests/utils/test_caching.py::test_parallel_jobs[ray-local-disk]": 0.006320855998637853, + "tests/utils/test_caching.py::test_parallel_jobs[ray-local-in-memory]": 0.007159704999139649, + "tests/utils/test_caching.py::test_parallel_jobs[ray-local-memcached]": 0.010268650999933016, + "tests/utils/test_caching.py::test_parallel_repeated_training[joblib-disk-20-1-10-5]": 0.040544517996750074, + "tests/utils/test_caching.py::test_parallel_repeated_training[joblib-disk-20-1-20-10]": 0.041609834999690065, + "tests/utils/test_caching.py::test_parallel_repeated_training[joblib-disk-20-2-10-5]": 0.450297680001313, + "tests/utils/test_caching.py::test_parallel_repeated_training[joblib-disk-20-2-20-10]": 0.41885778900177684, + "tests/utils/test_caching.py::test_parallel_repeated_training[joblib-in-memory-20-1-10-5]": 0.04637932000150613, + "tests/utils/test_caching.py::test_parallel_repeated_training[joblib-in-memory-20-1-20-10]": 0.038561840998227126, + "tests/utils/test_caching.py::test_parallel_repeated_training[joblib-in-memory-20-2-10-5]": 4.16153838199898, + "tests/utils/test_caching.py::test_parallel_repeated_training[joblib-in-memory-20-2-20-10]": 0.47474137900280766, + "tests/utils/test_caching.py::test_parallel_repeated_training[joblib-memcached-20-1-10-5]": 0.03560425399882661, + "tests/utils/test_caching.py::test_parallel_repeated_training[joblib-memcached-20-1-20-10]": 0.04425754300064, + "tests/utils/test_caching.py::test_parallel_repeated_training[joblib-memcached-20-2-10-5]": 0.46746473100029107, + "tests/utils/test_caching.py::test_parallel_repeated_training[joblib-memcached-20-2-20-10]": 0.47426626100059366, + "tests/utils/test_caching.py::test_parallel_repeated_training[ray-external-disk-20-1-10-5]": 0.019769640000959043, + "tests/utils/test_caching.py::test_parallel_repeated_training[ray-external-disk-20-1-20-10]": 0.02465987799951108, + "tests/utils/test_caching.py::test_parallel_repeated_training[ray-external-disk-20-2-10-5]": 0.012952293998750974, + "tests/utils/test_caching.py::test_parallel_repeated_training[ray-external-disk-20-2-20-10]": 0.010107056999913766, + "tests/utils/test_caching.py::test_parallel_repeated_training[ray-external-in-memory-20-1-10-5]": 0.013676337999640964, + "tests/utils/test_caching.py::test_parallel_repeated_training[ray-external-in-memory-20-1-20-10]": 0.009283014000175172, + "tests/utils/test_caching.py::test_parallel_repeated_training[ray-external-in-memory-20-2-10-5]": 0.014747097000508802, + "tests/utils/test_caching.py::test_parallel_repeated_training[ray-external-in-memory-20-2-20-10]": 0.012189770999611937, + "tests/utils/test_caching.py::test_parallel_repeated_training[ray-external-memcached-20-1-10-5]": 0.014756809001482907, + "tests/utils/test_caching.py::test_parallel_repeated_training[ray-external-memcached-20-1-20-10]": 0.014543373998094467, + "tests/utils/test_caching.py::test_parallel_repeated_training[ray-external-memcached-20-2-10-5]": 0.018690378999963286, + "tests/utils/test_caching.py::test_parallel_repeated_training[ray-external-memcached-20-2-20-10]": 0.017414769001334207, + "tests/utils/test_caching.py::test_parallel_repeated_training[ray-local-disk-20-1-10-5]": 0.00978782600031991, + "tests/utils/test_caching.py::test_parallel_repeated_training[ray-local-disk-20-1-20-10]": 0.008025870998608298, + "tests/utils/test_caching.py::test_parallel_repeated_training[ray-local-disk-20-2-10-5]": 0.00932121699952404, + "tests/utils/test_caching.py::test_parallel_repeated_training[ray-local-disk-20-2-20-10]": 0.012999636999666109, + "tests/utils/test_caching.py::test_parallel_repeated_training[ray-local-in-memory-20-1-10-5]": 0.010384335999333416, + "tests/utils/test_caching.py::test_parallel_repeated_training[ray-local-in-memory-20-1-20-10]": 0.007256282997332164, + "tests/utils/test_caching.py::test_parallel_repeated_training[ray-local-in-memory-20-2-10-5]": 0.007955910998134641, + "tests/utils/test_caching.py::test_parallel_repeated_training[ray-local-in-memory-20-2-20-10]": 0.006997692000368261, + "tests/utils/test_caching.py::test_parallel_repeated_training[ray-local-memcached-20-1-10-5]": 0.008193191000827937, + "tests/utils/test_caching.py::test_parallel_repeated_training[ray-local-memcached-20-1-20-10]": 0.010128158999577863, + "tests/utils/test_caching.py::test_parallel_repeated_training[ray-local-memcached-20-2-10-5]": 0.013161438002498471, + "tests/utils/test_caching.py::test_parallel_repeated_training[ray-local-memcached-20-2-20-10]": 0.009240641998985666, + "tests/utils/test_caching.py::test_repeated_training[disk]": 1.2679626049975923, + "tests/utils/test_caching.py::test_repeated_training[in-memory]": 0.8953080740011501, + "tests/utils/test_caching.py::test_repeated_training[memcached]": 1.0694843190012762, + "tests/utils/test_caching.py::test_single_job[disk]": 0.013467190003211726, + "tests/utils/test_caching.py::test_single_job[in-memory]": 0.007606943001519539, + "tests/utils/test_caching.py::test_single_job[memcached]": 0.012050191000525956, + "tests/utils/test_caching.py::test_without_pymemcache": 0.0068226680014049634, + "tests/utils/test_dataset.py::test_creating_dataset_from_sklearn[0.1]": 0.020587041000908357, + "tests/utils/test_dataset.py::test_creating_dataset_from_sklearn[0.5]": 0.00390724699900602, + "tests/utils/test_dataset.py::test_creating_dataset_from_sklearn[0.8]": 0.00450960899979691, + "tests/utils/test_dataset.py::test_creating_dataset_from_x_y_arrays[0.1-kwargs0]": 0.0038753029984945897, + "tests/utils/test_dataset.py::test_creating_dataset_from_x_y_arrays[0.1-kwargs1]": 0.0036959019998903386, + "tests/utils/test_dataset.py::test_creating_dataset_from_x_y_arrays[0.5-kwargs0]": 0.0038168650007719407, + "tests/utils/test_dataset.py::test_creating_dataset_from_x_y_arrays[0.5-kwargs1]": 0.0037348340010794345, + "tests/utils/test_dataset.py::test_creating_dataset_from_x_y_arrays[0.8-kwargs0]": 0.003279165001004003, + "tests/utils/test_dataset.py::test_creating_dataset_from_x_y_arrays[0.8-kwargs1]": 0.003160262998790131, + "tests/utils/test_dataset.py::test_creating_dataset_subsclassfrom_sklearn[0.1]": 0.00434540000060224, + "tests/utils/test_dataset.py::test_creating_dataset_subsclassfrom_sklearn[0.5]": 0.004031194001072436, + "tests/utils/test_dataset.py::test_creating_dataset_subsclassfrom_sklearn[0.8]": 0.0037131489989405964, + "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_sklearn[0.1]": 0.0038164179986779345, + "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_sklearn[0.5]": 0.005253569997876184, + "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_sklearn[0.8]": 0.005844020997756161, + "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_sklearn_failure[0.1]": 0.003921200999684515, + "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_sklearn_failure[0.5]": 0.0038101809986983426, + "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_sklearn_failure[0.8]": 0.00419950299874472, + "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_x_y_arrays[0.1-kwargs0]": 0.0037465159985003993, + "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_x_y_arrays[0.1-kwargs1]": 0.0037122550002095522, + "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_x_y_arrays[0.5-kwargs0]": 0.003727491999597987, + "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_x_y_arrays[0.5-kwargs1]": 0.00471100999857299, + "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_x_y_arrays[0.8-kwargs0]": 0.004182996997769806, + "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_x_y_arrays[0.8-kwargs1]": 0.004742823000924545, + "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_x_y_arrays_failure[0.1]": 0.0034745570010272786, + "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_x_y_arrays_failure[0.5]": 0.0029412200001388555, + "tests/utils/test_dataset.py::test_creating_grouped_dataset_from_x_y_arrays_failure[0.8]": 0.003702544998304802, + "tests/utils/test_dataset.py::test_creating_grouped_dataset_subsclassfrom_sklearn[0.1]": 0.004099161000340246, + "tests/utils/test_dataset.py::test_creating_grouped_dataset_subsclassfrom_sklearn[0.5]": 0.004149230999246356, + "tests/utils/test_dataset.py::test_creating_grouped_dataset_subsclassfrom_sklearn[0.8]": 0.004327725000621285, + "tests/utils/test_dataset.py::test_grouped_dataset_results": 0.005107523998958641, + "tests/utils/test_numeric.py::test_powerset": 0.003924966000340646, + "tests/utils/test_numeric.py::test_random_matrix_with_condition_number[0-2-ValueError]": 0.003189409999322379, + "tests/utils/test_numeric.py::test_random_matrix_with_condition_number[1-2-ValueError]": 0.0027116169985674787, + "tests/utils/test_numeric.py::test_random_matrix_with_condition_number[10-1-ValueError]": 0.0027666500009218, + "tests/utils/test_numeric.py::test_random_matrix_with_condition_number[10-2-None]": 0.0031559840026602615, + "tests/utils/test_numeric.py::test_random_matrix_with_condition_number[2-10-None]": 0.004578909001793363, + "tests/utils/test_numeric.py::test_random_matrix_with_condition_number[4--2-ValueError]": 0.0026738769993244205, + "tests/utils/test_numeric.py::test_random_matrix_with_condition_number[7-23-None]": 0.0031755019990669098, + "tests/utils/test_numeric.py::test_random_matrix_with_condition_number_reproducible[10-2]": 0.0032696249982109293, + "tests/utils/test_numeric.py::test_random_matrix_with_condition_number_reproducible[2-10]": 0.0026570699992589653, + "tests/utils/test_numeric.py::test_random_matrix_with_condition_number_reproducible[7-23]": 0.004022232000352233, + "tests/utils/test_numeric.py::test_random_matrix_with_condition_number_stochastic[10-2]": 0.004431671000929782, + "tests/utils/test_numeric.py::test_random_matrix_with_condition_number_stochastic[2-10]": 0.003217298000890878, + "tests/utils/test_numeric.py::test_random_matrix_with_condition_number_stochastic[7-23]": 0.002955772999484907, + "tests/utils/test_numeric.py::test_random_powerset[0-1]": 0.003080959002545569, + "tests/utils/test_numeric.py::test_random_powerset[1-10]": 0.0025249310019717086, + "tests/utils/test_numeric.py::test_random_powerset[10-1024]": 0.012735986998450244, + "tests/utils/test_numeric.py::test_random_powerset[5-128]": 0.0035692419987753965, + "tests/utils/test_numeric.py::test_random_powerset_label_min[0-10-3-1000]": 0.171625541001049, + "tests/utils/test_numeric.py::test_random_powerset_label_min[1-10-3-1000]": 0.17619158500019694, + "tests/utils/test_numeric.py::test_random_powerset_label_min[2-10-3-1000]": 0.1760632390014507, + "tests/utils/test_numeric.py::test_random_powerset_reproducible[10-1024]": 0.018217550998087972, + "tests/utils/test_numeric.py::test_random_powerset_stochastic[10-1024]": 0.018896675997893908, + "tests/utils/test_numeric.py::test_random_subset_of_size[0-0-None]": 0.002780025000902242, + "tests/utils/test_numeric.py::test_random_subset_of_size[0-1-ValueError]": 0.0032452249997731997, + "tests/utils/test_numeric.py::test_random_subset_of_size[10-0-None]": 0.0033025680004357127, + "tests/utils/test_numeric.py::test_random_subset_of_size[10-3-None]": 0.002845983000952401, + "tests/utils/test_numeric.py::test_random_subset_of_size[1000-40-None]": 0.0032918939996307017, + "tests/utils/test_numeric.py::test_random_subset_of_size_stochastic[10-3]": 0.002797532002659864, + "tests/utils/test_numeric.py::test_random_subset_of_size_stochastic[1000-40]": 0.0036268280000513187, + "tests/utils/test_numeric.py::test_running_moments": 0.6145333489985205, + "tests/utils/test_parallel.py::test_chunkification[joblib-data0-3-expected_chunks0]": 0.015510658000494004, + "tests/utils/test_parallel.py::test_chunkification[joblib-data1-2-expected_chunks1]": 0.012093620000086958, + "tests/utils/test_parallel.py::test_chunkification[joblib-data2-2-expected_chunks2]": 0.011375399999451474, + "tests/utils/test_parallel.py::test_chunkification[joblib-data3-3-expected_chunks3]": 0.016111063001517323, + "tests/utils/test_parallel.py::test_chunkification[joblib-data4-5-expected_chunks4]": 0.02149817300050927, + "tests/utils/test_parallel.py::test_chunkification[joblib-data5-42-expected_chunks5]": 0.013197087000662577, + "tests/utils/test_parallel.py::test_chunkification[joblib-data6-42-expected_chunks6]": 0.017662769996604766, + "tests/utils/test_parallel.py::test_chunkification[joblib-data7-4-expected_chunks7]": 0.013664767000591382, + "tests/utils/test_parallel.py::test_chunkification[joblib-data8-4-expected_chunks8]": 0.0129568249994918, + "tests/utils/test_parallel.py::test_chunkification[ray-external-data0-3-expected_chunks0]": 0.02873299299972132, + "tests/utils/test_parallel.py::test_chunkification[ray-external-data1-2-expected_chunks1]": 0.037400651001007645, + "tests/utils/test_parallel.py::test_chunkification[ray-external-data2-2-expected_chunks2]": 0.04821507099950395, + "tests/utils/test_parallel.py::test_chunkification[ray-external-data3-3-expected_chunks3]": 0.03959165199921699, + "tests/utils/test_parallel.py::test_chunkification[ray-external-data4-5-expected_chunks4]": 0.030608711000240874, + "tests/utils/test_parallel.py::test_chunkification[ray-external-data5-42-expected_chunks5]": 0.026263547000780818, + "tests/utils/test_parallel.py::test_chunkification[ray-external-data6-42-expected_chunks6]": 0.01923054399958346, + "tests/utils/test_parallel.py::test_chunkification[ray-external-data7-4-expected_chunks7]": 0.020033368999065715, + "tests/utils/test_parallel.py::test_chunkification[ray-external-data8-4-expected_chunks8]": 0.019113988000754034, + "tests/utils/test_parallel.py::test_chunkification[ray-local-data0-3-expected_chunks0]": 0.022260648998781107, + "tests/utils/test_parallel.py::test_chunkification[ray-local-data1-2-expected_chunks1]": 0.02477619599994796, + "tests/utils/test_parallel.py::test_chunkification[ray-local-data2-2-expected_chunks2]": 0.037821603000338655, + "tests/utils/test_parallel.py::test_chunkification[ray-local-data3-3-expected_chunks3]": 0.0276968880007189, + "tests/utils/test_parallel.py::test_chunkification[ray-local-data4-5-expected_chunks4]": 0.03822717000184639, + "tests/utils/test_parallel.py::test_chunkification[ray-local-data5-42-expected_chunks5]": 0.03200487200047064, + "tests/utils/test_parallel.py::test_chunkification[ray-local-data6-42-expected_chunks6]": 0.02251517100012279, + "tests/utils/test_parallel.py::test_chunkification[ray-local-data7-4-expected_chunks7]": 0.02549016900047718, + "tests/utils/test_parallel.py::test_chunkification[ray-local-data8-4-expected_chunks8]": 0.016007507998438086, + "tests/utils/test_parallel.py::test_effective_n_jobs[joblib]": 0.005121522000990808, + "tests/utils/test_parallel.py::test_effective_n_jobs[ray-external]": 4.8416320709984575, + "tests/utils/test_parallel.py::test_effective_n_jobs[ray-local]": 6.68878685799973, + "tests/utils/test_parallel.py::test_future_cancellation[joblib]": 0.013322050999704516, + "tests/utils/test_parallel.py::test_future_cancellation[ray-external]": 6.1742852379975375, + "tests/utils/test_parallel.py::test_future_cancellation[ray-local]": 5.196579726998607, + "tests/utils/test_parallel.py::test_futures_executor_map[joblib]": 2.7167825960004848, + "tests/utils/test_parallel.py::test_futures_executor_map[ray-external]": 0.10519307000140543, + "tests/utils/test_parallel.py::test_futures_executor_map[ray-local]": 0.10775902599925757, + "tests/utils/test_parallel.py::test_futures_executor_map_with_max_workers[joblib]": 0.012954608999280026, + "tests/utils/test_parallel.py::test_futures_executor_map_with_max_workers[ray-external]": 1.1045504180019634, + "tests/utils/test_parallel.py::test_futures_executor_map_with_max_workers[ray-local]": 1.100314563000211, + "tests/utils/test_parallel.py::test_futures_executor_submit[joblib]": 3.2937196319981012, + "tests/utils/test_parallel.py::test_futures_executor_submit[ray-external]": 0.06437306899897521, + "tests/utils/test_parallel.py::test_futures_executor_submit[ray-local]": 0.05545763400186843, + "tests/utils/test_parallel.py::test_map_reduce_job[joblib-1-list-indices0-expected0]": 0.0033702880009514047, + "tests/utils/test_parallel.py::test_map_reduce_job[joblib-1-list-indices1-expected1]": 0.003624205000960501, + "tests/utils/test_parallel.py::test_map_reduce_job[joblib-1-list-indices2-expected2]": 0.0034593179989315104, + "tests/utils/test_parallel.py::test_map_reduce_job[joblib-1-numpy-indices4-45]": 0.003431146000366425, + "tests/utils/test_parallel.py::test_map_reduce_job[joblib-1-range-indices3-expected3]": 0.003291076000095927, + "tests/utils/test_parallel.py::test_map_reduce_job[joblib-2-list-indices0-expected0]": 0.0043230089995631715, + "tests/utils/test_parallel.py::test_map_reduce_job[joblib-2-list-indices1-expected1]": 0.014759305000552558, + "tests/utils/test_parallel.py::test_map_reduce_job[joblib-2-list-indices2-expected2]": 0.014669898000647663, + "tests/utils/test_parallel.py::test_map_reduce_job[joblib-2-numpy-indices4-45]": 0.014518962998408824, + "tests/utils/test_parallel.py::test_map_reduce_job[joblib-2-range-indices3-expected3]": 0.014446292998400168, + "tests/utils/test_parallel.py::test_map_reduce_job[joblib-4-list-indices0-expected0]": 0.16248785400057386, + "tests/utils/test_parallel.py::test_map_reduce_job[joblib-4-list-indices1-expected1]": 2.277719737998268, + "tests/utils/test_parallel.py::test_map_reduce_job[joblib-4-list-indices2-expected2]": 3.347688416000892, + "tests/utils/test_parallel.py::test_map_reduce_job[joblib-4-numpy-indices4-45]": 0.04604001000188873, + "tests/utils/test_parallel.py::test_map_reduce_job[joblib-4-range-indices3-expected3]": 0.057255595000242465, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-1-list-indices0-expected0]": 0.026082702997882734, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-1-list-indices1-expected1]": 0.023299047999898903, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-1-list-indices2-expected2]": 0.02191418300026271, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-1-numpy-indices4-45]": 0.02673473200047738, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-1-range-indices3-expected3]": 0.027526039999429486, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-2-list-indices0-expected0]": 3.4228467769989948, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-2-list-indices1-expected1]": 4.798353305001001, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-2-list-indices2-expected2]": 4.636959622999711, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-2-numpy-indices4-45]": 4.028821964997405, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-2-range-indices3-expected3]": 4.398552747999929, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-4-list-indices0-expected0]": 3.734075545000451, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-4-list-indices1-expected1]": 5.287959784998748, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-4-list-indices2-expected2]": 6.245923890002814, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-4-numpy-indices4-45]": 6.61028953999994, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-external-4-range-indices3-expected3]": 6.340780258999075, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-1-list-indices0-expected0]": 0.026392571999167558, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-1-list-indices1-expected1]": 0.0228169030015124, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-1-list-indices2-expected2]": 0.026224847002595197, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-1-numpy-indices4-45]": 0.02119264299835777, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-1-range-indices3-expected3]": 0.02678771700084326, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-2-list-indices0-expected0]": 2.813331847997688, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-2-list-indices1-expected1]": 4.129950463000569, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-2-list-indices2-expected2]": 4.1853057150001405, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-2-numpy-indices4-45]": 3.9139689650000946, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-2-range-indices3-expected3]": 4.066097430000809, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-4-list-indices0-expected0]": 3.626414754000507, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-4-list-indices1-expected1]": 5.354816800998378, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-4-list-indices2-expected2]": 6.589774920001219, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-4-numpy-indices4-45]": 6.373054822000995, + "tests/utils/test_parallel.py::test_map_reduce_job[ray-local-4-range-indices3-expected3]": 6.71076984499814, + "tests/utils/test_parallel.py::test_map_reduce_job_partial_map_and_reduce_func[joblib]": 0.03710782099915377, + "tests/utils/test_parallel.py::test_map_reduce_job_partial_map_and_reduce_func[ray-external]": 6.3739082100000815, + "tests/utils/test_parallel.py::test_map_reduce_job_partial_map_and_reduce_func[ray-local]": 6.171818285998597, + "tests/utils/test_parallel.py::test_map_reduce_seeding[joblib-42-12]": 0.16202725999937684, + "tests/utils/test_parallel.py::test_map_reduce_seeding[ray-external-42-12]": 19.644846438999593, + "tests/utils/test_parallel.py::test_map_reduce_seeding[ray-local-42-12]": 19.494929903998127, + "tests/utils/test_parallel.py::test_wrap_function[joblib]": 0.010273419000441208, + "tests/utils/test_parallel.py::test_wrap_function[ray-external]": 4.3178896000026725, + "tests/utils/test_parallel.py::test_wrap_function[ray-local]": 4.386876819999088, + "tests/utils/test_score.py::test_compose_score": 0.003188072001648834, + "tests/utils/test_score.py::test_scorer": 0.006043704999683541, + "tests/utils/test_score.py::test_squashed_r2": 0.00286291600241384, + "tests/utils/test_score.py::test_squashed_variance": 0.002624727998409071, + "tests/utils/test_status.py::test_and_status": 0.0023914820012578275, + "tests/utils/test_status.py::test_not_status": 0.0024304439994011773, + "tests/utils/test_status.py::test_or_status": 0.0031306429991673212, "tests/utils/test_utility.py::test_cache[2-0-8]": 0.00677607100806199, - "tests/utils/test_utility.py::test_data_utility_learning_wrapper[10-2-0-8]": 0.004311377968406305, - "tests/utils/test_utility.py::test_data_utility_learning_wrapper[2-2-0-8]": 0.0040499519964214414, + "tests/utils/test_utility.py::test_data_utility_learning_wrapper[10-2-0-8]": 0.007143015998735791, + "tests/utils/test_utility.py::test_data_utility_learning_wrapper[2-2-0-8]": 0.008842511999318958, "tests/utils/test_utility.py::test_different_cache_signature[model_kwargs0-2-0-8]": 0.0038117940130177885, "tests/utils/test_utility.py::test_different_cache_signature[model_kwargs1-2-0-8]": 0.0034867670328821987, - "tests/utils/test_utility.py::test_utility_show_warnings[4-4-False]": 0.00734079402172938, - "tests/utils/test_utility.py::test_utility_show_warnings[4-4-True]": 0.007422954018693417, + "tests/utils/test_utility.py::test_different_utility_with_same_cache[2-0-8]": 0.00974041799963743, + "tests/utils/test_utility.py::test_utility_serialization[False-2-0-8]": 0.004299543001252459, + "tests/utils/test_utility.py::test_utility_serialization[True-2-0-8]": 0.004922002000967041, + "tests/utils/test_utility.py::test_utility_show_warnings[4-4-False]": 0.018307410000488744, + "tests/utils/test_utility.py::test_utility_show_warnings[4-4-True]": 0.009923514002366574, + "tests/utils/test_utility.py::test_utility_with_cache[2-0-8]": 0.010860190002858872, + "tests/value/least_core/test_common.py::test_lc_solve_problems[test_game0]": 6.664896995000163, "tests/value/least_core/test_common.py::test_lc_solve_problems[test_utility0]": 3.0655845460132696, + "tests/value/least_core/test_montecarlo.py::test_montecarlo_least_core[False--1-test_game0-0.1-128]": 0.10254659299971536, + "tests/value/least_core/test_montecarlo.py::test_montecarlo_least_core[False--1-test_game1-0.2-10000]": 0.95324419499957, "tests/value/least_core/test_montecarlo.py::test_montecarlo_least_core[False--1-test_utility0-0.1-128]": 0.05090764199849218, "tests/value/least_core/test_montecarlo.py::test_montecarlo_least_core[False--1-test_utility1-0.2-10000]": 0.39550038598827086, + "tests/value/least_core/test_montecarlo.py::test_montecarlo_least_core[False-1-test_game0-0.1-128]": 0.11610117799864383, + "tests/value/least_core/test_montecarlo.py::test_montecarlo_least_core[False-1-test_game1-0.2-10000]": 1.9240173660018627, "tests/value/least_core/test_montecarlo.py::test_montecarlo_least_core[False-1-test_utility0-0.1-128]": 0.054777625045971945, "tests/value/least_core/test_montecarlo.py::test_montecarlo_least_core[False-1-test_utility1-0.2-10000]": 0.7125970929628238, + "tests/value/least_core/test_montecarlo.py::test_montecarlo_least_core[True--1-test_game0-0.1-128]": 12.35835815199971, + "tests/value/least_core/test_montecarlo.py::test_montecarlo_least_core[True--1-test_game1-0.2-10000]": 1.27118392400007, "tests/value/least_core/test_montecarlo.py::test_montecarlo_least_core[True--1-test_utility0-0.1-128]": 6.515727574034827, "tests/value/least_core/test_montecarlo.py::test_montecarlo_least_core[True--1-test_utility1-0.2-10000]": 0.6112625639943872, + "tests/value/least_core/test_montecarlo.py::test_montecarlo_least_core[True-1-test_game0-0.1-128]": 0.13497778700002527, + "tests/value/least_core/test_montecarlo.py::test_montecarlo_least_core[True-1-test_game1-0.2-10000]": 2.054010283000025, "tests/value/least_core/test_montecarlo.py::test_montecarlo_least_core[True-1-test_utility0-0.1-128]": 0.07473104700329714, "tests/value/least_core/test_montecarlo.py::test_montecarlo_least_core[True-1-test_utility1-0.2-10000]": 0.7888634809933137, + "tests/value/least_core/test_naive.py::test_naive_least_core[False-test_game0]": 0.056533884000600665, + "tests/value/least_core/test_naive.py::test_naive_least_core[False-test_game1]": 0.05103961900022114, + "tests/value/least_core/test_naive.py::test_naive_least_core[False-test_game2]": 0.04528383999968355, + "tests/value/least_core/test_naive.py::test_naive_least_core[False-test_game3]": 0.04622581199873821, + "tests/value/least_core/test_naive.py::test_naive_least_core[False-test_game4]": 0.04450138000174775, "tests/value/least_core/test_naive.py::test_naive_least_core[False-test_utility0]": 0.024124946998199448, "tests/value/least_core/test_naive.py::test_naive_least_core[False-test_utility1]": 0.02425819096970372, "tests/value/least_core/test_naive.py::test_naive_least_core[False-test_utility2]": 0.023533977015176788, "tests/value/least_core/test_naive.py::test_naive_least_core[False-test_utility3]": 0.023558928980492055, "tests/value/least_core/test_naive.py::test_naive_least_core[False-test_utility4]": 0.024587185034761205, + "tests/value/least_core/test_naive.py::test_naive_least_core[True-test_game0]": 0.055623405996811925, + "tests/value/least_core/test_naive.py::test_naive_least_core[True-test_game1]": 0.05625994600086415, + "tests/value/least_core/test_naive.py::test_naive_least_core[True-test_game2]": 0.05063546000201313, + "tests/value/least_core/test_naive.py::test_naive_least_core[True-test_game3]": 0.05257723800241365, + "tests/value/least_core/test_naive.py::test_naive_least_core[True-test_game4]": 0.055973189997530426, "tests/value/least_core/test_naive.py::test_naive_least_core[True-test_utility0]": 0.025446541025303304, "tests/value/least_core/test_naive.py::test_naive_least_core[True-test_utility1]": 0.026494102989090607, "tests/value/least_core/test_naive.py::test_naive_least_core[True-test_utility2]": 0.02477889700094238, "tests/value/least_core/test_naive.py::test_naive_least_core[True-test_utility3]": 0.026450325007317588, "tests/value/least_core/test_naive.py::test_naive_least_core[True-test_utility4]": 0.026973432017257437, - "tests/value/loo/test_loo.py::test_loo[100]": 3.7793434759951197, - "tests/value/loo/test_loo.py::test_loo[10]": 3.8455980509752408, - "tests/value/shapley/test_classwise.py::test_classwise_scorer_accuracies_left_right_margins[101-0.3-0.4]": 0.004718418029369786, - "tests/value/shapley/test_classwise.py::test_classwise_scorer_accuracies_manual_derivation": 0.022209248010767624, - "tests/value/shapley/test_classwise.py::test_classwise_scorer_is_symmetric[101-0.3-0.4]": 0.0053302829910535365, - "tests/value/shapley/test_classwise.py::test_classwise_scorer_representation": 0.002573036035755649, - "tests/value/shapley/test_classwise.py::test_classwise_scorer_utility[101-0.3-0.4]": 0.00688477698713541, - "tests/value/shapley/test_classwise.py::test_classwise_shapley[classwise_shapley_exact_solution-n_resample_complement_sets=1-n_samples=500]": 6.088012945023365, - "tests/value/shapley/test_classwise.py::test_classwise_shapley[classwise_shapley_exact_solution_no_default-n_resample_complement_sets=1-n_samples=500]": 6.90557194603025, - "tests/value/shapley/test_classwise.py::test_classwise_shapley[classwise_shapley_exact_solution_no_default_allow_empty_set-n_resample_complement_sets=1-n_samples=500]": 6.456796451995615, - "tests/value/shapley/test_classwise.py::test_classwise_shapley[classwise_shapley_exact_solution_normalized-n_resample_complement_sets=1-n_samples=500]": 5.917300594970584, - "tests/value/shapley/test_classwise.py::test_closed_form_linear_classifier": 0.004191815009107813, - "tests/value/shapley/test_knn.py::test_knn_montecarlo_match": 6.380129672033945, + "tests/value/loo/test_loo.py::test_loo[100]": 6.34605625200129, + "tests/value/loo/test_loo.py::test_loo[10]": 6.683512068999335, + "tests/value/shapley/test_classwise.py::test_classwise_scorer_accuracies_left_right_margins[101-0.3-0.4]": 0.014495325998723274, + "tests/value/shapley/test_classwise.py::test_classwise_scorer_accuracies_manual_derivation": 0.059531668999625253, + "tests/value/shapley/test_classwise.py::test_classwise_scorer_is_symmetric[101-0.3-0.4]": 0.017718389000947354, + "tests/value/shapley/test_classwise.py::test_classwise_scorer_representation": 0.00893844900019758, + "tests/value/shapley/test_classwise.py::test_classwise_scorer_utility[101-0.3-0.4]": 0.02120917100182851, + "tests/value/shapley/test_classwise.py::test_classwise_shapley[classwise_shapley_exact_solution-n_resample_complement_sets=1-n_samples=500]": 11.03723036699921, + "tests/value/shapley/test_classwise.py::test_classwise_shapley[classwise_shapley_exact_solution_no_default-n_resample_complement_sets=1-n_samples=500]": 12.916025546999663, + "tests/value/shapley/test_classwise.py::test_classwise_shapley[classwise_shapley_exact_solution_no_default_allow_empty_set-n_resample_complement_sets=1-n_samples=500]": 12.068119810999633, + "tests/value/shapley/test_classwise.py::test_classwise_shapley[classwise_shapley_exact_solution_normalized-n_resample_complement_sets=1-n_samples=500]": 10.891289137000058, + "tests/value/shapley/test_classwise.py::test_closed_form_linear_classifier": 0.01344082000105118, + "tests/value/shapley/test_knn.py::test_knn_montecarlo_match": 11.906123751998166, "tests/value/shapley/test_montecarlo.py::test_analytic_montecarlo_shapley[12-owen-0.1-0.0001-kwargs2]": 0.6999966300209053, "tests/value/shapley/test_montecarlo.py::test_analytic_montecarlo_shapley[12-owen_antithetic-0.1-0.0001-kwargs3]": 1.3923712590476498, "tests/value/shapley/test_montecarlo.py::test_analytic_montecarlo_shapley[12-permutation_montecarlo-0.1-1e-05-kwargs0]": 4.533932764985366, "tests/value/shapley/test_montecarlo.py::test_analytic_montecarlo_shapley[3-group_testing-0.1-0.01-kwargs4]": 2.874565462989267, "tests/value/shapley/test_montecarlo.py::test_analytic_montecarlo_shapley[8-combinatorial_montecarlo-0.2-0.0001-kwargs1]": 4.175152084033471, - "tests/value/shapley/test_montecarlo.py::test_grouped_linear_montecarlo_shapley[permutation_montecarlo-kwargs0-scorer0-0.1-2-0-21-2]": 5.129105891013751, - "tests/value/shapley/test_montecarlo.py::test_hoeffding_bound_montecarlo[combinatorial_montecarlo-6-0.1-0.1]": 4.910673014004715, - "tests/value/shapley/test_montecarlo.py::test_hoeffding_bound_montecarlo[permutation_montecarlo-6-0.1-0.1]": 52.25644952899893, + "tests/value/shapley/test_montecarlo.py::test_games[combinatorial_montecarlo-0.2-0.0001-kwargs1-test_game0]": 8.304236846999629, + "tests/value/shapley/test_montecarlo.py::test_games[combinatorial_montecarlo-0.2-0.0001-kwargs1-test_game1]": 8.651754697999422, + "tests/value/shapley/test_montecarlo.py::test_games[group_testing-0.1-0.01-kwargs4-test_game0]": 4.506434214001274, + "tests/value/shapley/test_montecarlo.py::test_games[group_testing-0.1-0.01-kwargs4-test_game1]": 5.184473866002008, + "tests/value/shapley/test_montecarlo.py::test_games[owen-0.2-0.0001-kwargs2-test_game0]": 0.695304662000126, + "tests/value/shapley/test_montecarlo.py::test_games[owen-0.2-0.0001-kwargs2-test_game1]": 0.754036617001475, + "tests/value/shapley/test_montecarlo.py::test_games[owen_antithetic-0.1-0.0001-kwargs3-test_game0]": 1.3446016939979017, + "tests/value/shapley/test_montecarlo.py::test_games[owen_antithetic-0.1-0.0001-kwargs3-test_game1]": 1.7906026460022986, + "tests/value/shapley/test_montecarlo.py::test_games[permutation_montecarlo-0.2-0.0001-kwargs0-test_game0]": 9.640759977000926, + "tests/value/shapley/test_montecarlo.py::test_games[permutation_montecarlo-0.2-0.0001-kwargs0-test_game1]": 9.149135870000464, + "tests/value/shapley/test_montecarlo.py::test_grouped_linear_montecarlo_shapley[permutation_montecarlo-kwargs0-scorer0-0.1-2-0-21-2]": 11.869230333000814, + "tests/value/shapley/test_montecarlo.py::test_hoeffding_bound_montecarlo[combinatorial_montecarlo-6-0.1-0.1]": 12.159375920000457, + "tests/value/shapley/test_montecarlo.py::test_hoeffding_bound_montecarlo[permutation_montecarlo-6-0.1-0.1]": 121.21386299999904, "tests/value/shapley/test_montecarlo.py::test_linear_montecarlo_shapley[combinatorial_montecarlo-kwargs1-scorer0-0.25-2-0-21]": 17.78464582102606, "tests/value/shapley/test_montecarlo.py::test_linear_montecarlo_shapley[group_testing-kwargs4-scorer0-0.25-2-0-21]": 29.239474696019897, "tests/value/shapley/test_montecarlo.py::test_linear_montecarlo_shapley[owen-kwargs2-scorer0-0.25-2-0-21]": 4.124498174991459, "tests/value/shapley/test_montecarlo.py::test_linear_montecarlo_shapley[owen_antithetic-kwargs3-scorer0-0.25-2-0-21]": 7.887545032019261, "tests/value/shapley/test_montecarlo.py::test_linear_montecarlo_shapley[permutation_montecarlo-kwargs0-scorer0-0.25-2-0-21]": 5.8485472809989005, - "tests/value/shapley/test_montecarlo.py::test_linear_montecarlo_with_outlier[group_testing-kwargs3-scorer0-0.2-2-0-21]": 30.232708652998554, - "tests/value/shapley/test_montecarlo.py::test_linear_montecarlo_with_outlier[owen-kwargs1-scorer0-0.2-2-0-21]": 13.355578221991891, - "tests/value/shapley/test_montecarlo.py::test_linear_montecarlo_with_outlier[owen_antithetic-kwargs2-scorer0-0.2-2-0-21]": 20.621750775026157, - "tests/value/shapley/test_montecarlo.py::test_linear_montecarlo_with_outlier[permutation_montecarlo-kwargs0-scorer0-0.2-2-0-21]": 5.888187222008128, + "tests/value/shapley/test_montecarlo.py::test_linear_montecarlo_with_outlier[group_testing-kwargs3-scorer0-0.2-2-0-21]": 105.57146695700249, + "tests/value/shapley/test_montecarlo.py::test_linear_montecarlo_with_outlier[owen-kwargs1-scorer0-0.2-2-0-21]": 46.293949323999186, + "tests/value/shapley/test_montecarlo.py::test_linear_montecarlo_with_outlier[owen_antithetic-kwargs2-scorer0-0.2-2-0-21]": 75.77437868900051, + "tests/value/shapley/test_montecarlo.py::test_linear_montecarlo_with_outlier[permutation_montecarlo-kwargs0-scorer0-0.2-2-0-21]": 14.84272324000085, "tests/value/shapley/test_montecarlo.py::test_montecarlo_shapley_housing_dataset[12-3-12-combinatorial_montecarlo-kwargs0]": 0.16786966001382098, "tests/value/shapley/test_montecarlo.py::test_montecarlo_shapley_housing_dataset[12-3-12-owen-kwargs1]": 17.011920137971174, "tests/value/shapley/test_montecarlo.py::test_montecarlo_shapley_housing_dataset[12-3-12-owen_antithetic-kwargs2]": 35.88025256394758, "tests/value/shapley/test_montecarlo.py::test_montecarlo_shapley_housing_dataset[12-3-4-group_testing-kwargs3]": 0.25901710899779573, + "tests/value/shapley/test_montecarlo.py::test_seed[combinatorial_montecarlo-kwargs0-test_game0]": 0.10237690700159874, + "tests/value/shapley/test_montecarlo.py::test_seed[group_testing-kwargs3-test_game0]": 1.3946212869996089, + "tests/value/shapley/test_montecarlo.py::test_seed[owen-kwargs1-test_game0]": 2.984055114999137, + "tests/value/shapley/test_montecarlo.py::test_seed[owen_antithetic-kwargs2-test_game0]": 5.702334433002761, "tests/value/shapley/test_naive.py::test_analytic_exact_shapley[12-combinatorial_exact_shapley-0.01-1e-05]": 2.798590613005217, "tests/value/shapley/test_naive.py::test_analytic_exact_shapley[6-permutation_exact_shapley-0.01-1e-05]": 0.34537768000154756, - "tests/value/shapley/test_naive.py::test_grouped_linear[2-0-50-3-r2]": 0.057835308980429545, - "tests/value/shapley/test_naive.py::test_grouped_linear[2-1-100-5-explained_variance]": 1.2154581100330688, - "tests/value/shapley/test_naive.py::test_grouped_linear[2-1-100-5-r2]": 1.1950475970224943, + "tests/value/shapley/test_naive.py::test_games[combinatorial_exact_shapley-test_game0-0.1-1e-05]": 0.035801175001324737, + "tests/value/shapley/test_naive.py::test_games[combinatorial_exact_shapley-test_game1-0.1-1e-05]": 0.020296718997997232, + "tests/value/shapley/test_naive.py::test_games[combinatorial_exact_shapley-test_game2-0.1-1e-05]": 0.026713223998740432, + "tests/value/shapley/test_naive.py::test_games[combinatorial_exact_shapley-test_game3-0.1-1e-05]": 0.024250888998722075, + "tests/value/shapley/test_naive.py::test_games[combinatorial_exact_shapley-test_game4-0.1-1e-05]": 0.08578255800057377, + "tests/value/shapley/test_naive.py::test_games[permutation_exact_shapley-test_game0-0.1-1e-05]": 0.0334680340019986, + "tests/value/shapley/test_naive.py::test_games[permutation_exact_shapley-test_game1-0.1-1e-05]": 0.02248540199798299, + "tests/value/shapley/test_naive.py::test_games[permutation_exact_shapley-test_game2-0.1-1e-05]": 0.021266358000502805, + "tests/value/shapley/test_naive.py::test_games[permutation_exact_shapley-test_game3-0.1-1e-05]": 0.02347195299989835, + "tests/value/shapley/test_naive.py::test_games[permutation_exact_shapley-test_game4-0.1-1e-05]": 0.9876527700016595, + "tests/value/shapley/test_naive.py::test_grouped_linear[2-0-50-3-r2]": 0.19884431500031496, + "tests/value/shapley/test_naive.py::test_grouped_linear[2-1-100-5-explained_variance]": 3.9915946569999505, + "tests/value/shapley/test_naive.py::test_grouped_linear[2-1-100-5-r2]": 3.9885682109998015, "tests/value/shapley/test_naive.py::test_linear[2-0-10-r2]": 0.05533879197901115, "tests/value/shapley/test_naive.py::test_linear[2-1-10-explained_variance]": 0.058987755968701094, "tests/value/shapley/test_naive.py::test_linear[2-1-10-neg_median_absolute_error]": 0.05515471697435714, "tests/value/shapley/test_naive.py::test_linear[2-1-10-r2]": 0.05683578198659234, - "tests/value/shapley/test_naive.py::test_linear_with_outlier[2-0-20-r2]": 7.4271527160017285, - "tests/value/shapley/test_naive.py::test_linear_with_outlier[2-1-20-explained_variance]": 7.752014733996475, - "tests/value/shapley/test_naive.py::test_linear_with_outlier[2-1-20-neg_median_absolute_error]": 7.2494586749817245, - "tests/value/shapley/test_naive.py::test_linear_with_outlier[2-1-20-r2]": 7.528596303978702, - "tests/value/shapley/test_naive.py::test_polynomial[coefficients0-r2]": 0.10091358600766398, - "tests/value/shapley/test_naive.py::test_polynomial[coefficients1-neg_median_absolute_error]": 0.09756919997744262, - "tests/value/shapley/test_naive.py::test_polynomial[coefficients2-explained_variance]": 0.10092617000918835, - "tests/value/shapley/test_naive.py::test_polynomial_with_outlier[coefficients0-r2]": 0.05707916300161742, - "tests/value/shapley/test_naive.py::test_polynomial_with_outlier[coefficients1-neg_median_absolute_error]": 0.058802402985747904, - "tests/value/shapley/test_naive.py::test_polynomial_with_outlier[coefficients2-explained_variance]": 0.06408755297889002, + "tests/value/shapley/test_naive.py::test_linear_with_outlier[2-0-20-r2]": 25.743576199000017, + "tests/value/shapley/test_naive.py::test_linear_with_outlier[2-1-20-explained_variance]": 26.06965675200081, + "tests/value/shapley/test_naive.py::test_linear_with_outlier[2-1-20-neg_median_absolute_error]": 25.645237798999005, + "tests/value/shapley/test_naive.py::test_linear_with_outlier[2-1-20-r2]": 25.97635805399841, + "tests/value/shapley/test_naive.py::test_polynomial[coefficients0-r2]": 0.20116403300016827, + "tests/value/shapley/test_naive.py::test_polynomial[coefficients1-neg_median_absolute_error]": 0.20279847600068024, + "tests/value/shapley/test_naive.py::test_polynomial[coefficients2-explained_variance]": 0.20646126699830347, + "tests/value/shapley/test_naive.py::test_polynomial_with_outlier[coefficients0-r2]": 0.15503699600049003, + "tests/value/shapley/test_naive.py::test_polynomial_with_outlier[coefficients1-neg_median_absolute_error]": 0.15186486699894886, + "tests/value/shapley/test_naive.py::test_polynomial_with_outlier[coefficients2-explained_variance]": 0.1560443580001447, + "tests/value/shapley/test_truncated.py::test_games[done0-NoTruncation-truncation_kwargs0-test_game0]": 8.864981821001493, + "tests/value/shapley/test_truncated.py::test_games[done0-NoTruncation-truncation_kwargs0-test_game1]": 8.904717276998781, + "tests/value/shapley/test_truncated.py::test_games[done1-FixedTruncation-truncation_kwargs1-test_game0]": 8.893666212001335, + "tests/value/shapley/test_truncated.py::test_games[done1-FixedTruncation-truncation_kwargs1-test_game1]": 8.871429693997925, "tests/value/shapley/test_truncated.py::test_tmcs_analytic_montecarlo_shapley[12-truncated_montecarlo-0.1-1e-05-kwargs0]": 5.025441929989029, "tests/value/shapley/test_truncated.py::test_tmcs_linear_montecarlo_shapley[truncated_montecarlo-kwargs0-scorer0-0.25-2-0-21]": 5.633914494974306, - "tests/value/shapley/test_truncated.py::test_tmcs_linear_montecarlo_with_outlier[truncated_montecarlo-kwargs0-scorer0-0.2-2-0-21]": 3.523623990971828, - "tests/value/test_sampler.py::test_chunkify[AntitheticSampler]": 0.0012030639918521047, - "tests/value/test_sampler.py::test_chunkify[DeterministicUniformSampler]": 0.0011419990041758865, - "tests/value/test_sampler.py::test_chunkify[RandomHierarchicalSampler]": 0.0011900250101462007, - "tests/value/test_sampler.py::test_chunkify[UniformSampler]": 0.0013321389851626009, - "tests/value/test_sampler.py::test_chunkify_permutation[DeterministicPermutationSampler]": 0.0010862670314963907, - "tests/value/test_sampler.py::test_chunkify_permutation[PermutationSampler]": 0.001125522016081959, - "tests/value/test_sampler.py::test_proper[indices0-AntitheticSampler]": 0.0011964229634031653, - "tests/value/test_sampler.py::test_proper[indices0-DeterministicPermutationSampler]": 0.0013584279513452202, - "tests/value/test_sampler.py::test_proper[indices0-DeterministicUniformSampler]": 0.0013845030043739825, - "tests/value/test_sampler.py::test_proper[indices0-PermutationSampler]": 0.0012692750024143606, - "tests/value/test_sampler.py::test_proper[indices0-RandomHierarchicalSampler]": 0.0011780599888879806, - "tests/value/test_sampler.py::test_proper[indices0-UniformSampler]": 0.0012423349835444242, - "tests/value/test_sampler.py::test_proper[indices1-AntitheticSampler]": 0.001568679028423503, - "tests/value/test_sampler.py::test_proper[indices1-DeterministicPermutationSampler]": 0.0013892220158595592, - "tests/value/test_sampler.py::test_proper[indices1-DeterministicUniformSampler]": 0.0014415960176847875, - "tests/value/test_sampler.py::test_proper[indices1-PermutationSampler]": 0.0012552720145322382, - "tests/value/test_sampler.py::test_proper[indices1-RandomHierarchicalSampler]": 0.0017029709706548601, - "tests/value/test_sampler.py::test_proper[indices1-UniformSampler]": 0.0015911830123513937, - "tests/value/test_sampler.py::test_proper_reproducible[indices0-AntitheticSampler]": 0.0014955719816498458, - "tests/value/test_sampler.py::test_proper_reproducible[indices0-PermutationSampler]": 0.0017780059715732932, - "tests/value/test_sampler.py::test_proper_reproducible[indices0-RandomHierarchicalSampler]": 0.0015286150155588984, - "tests/value/test_sampler.py::test_proper_reproducible[indices0-UniformSampler]": 0.0013392769906204194, - "tests/value/test_sampler.py::test_proper_reproducible[indices1-AntitheticSampler]": 0.005814862961415201, - "tests/value/test_sampler.py::test_proper_reproducible[indices1-PermutationSampler]": 0.0022604400001000613, - "tests/value/test_sampler.py::test_proper_reproducible[indices1-RandomHierarchicalSampler]": 0.01281771101639606, - "tests/value/test_sampler.py::test_proper_reproducible[indices1-UniformSampler]": 0.006939170008990914, - "tests/value/test_sampler.py::test_proper_stochastic[indices0-AntitheticSampler]": 0.001301849988522008, - "tests/value/test_sampler.py::test_proper_stochastic[indices0-PermutationSampler]": 0.0013378779985941947, - "tests/value/test_sampler.py::test_proper_stochastic[indices0-RandomHierarchicalSampler]": 0.0014513320056721568, - "tests/value/test_sampler.py::test_proper_stochastic[indices0-UniformSampler]": 0.0014353079604916275, - "tests/value/test_sampler.py::test_proper_stochastic[indices1-AntitheticSampler]": 0.006029498006682843, - "tests/value/test_sampler.py::test_proper_stochastic[indices1-PermutationSampler]": 0.0019644349522423, - "tests/value/test_sampler.py::test_proper_stochastic[indices1-RandomHierarchicalSampler]": 0.012361108005279675, - "tests/value/test_sampler.py::test_proper_stochastic[indices1-UniformSampler]": 0.006347205984639004, - "tests/value/test_semivalues.py::test_banzhaf[AntitheticPermutationSampler-5]": 10.714197647990659, - "tests/value/test_semivalues.py::test_banzhaf[AntitheticSampler-5]": 4.695468286023242, - "tests/value/test_semivalues.py::test_banzhaf[DeterministicPermutationSampler-5]": 6.074063064996153, - "tests/value/test_semivalues.py::test_banzhaf[DeterministicUniformSampler-5]": 4.212341544014635, - "tests/value/test_semivalues.py::test_banzhaf[PermutationSampler-5]": 8.149094285006868, - "tests/value/test_semivalues.py::test_banzhaf[UniformSampler-5]": 4.764893947984092, - "tests/value/test_semivalues.py::test_coefficients[banzhaf_coefficient-100]": 0.003842581994831562, - "tests/value/test_semivalues.py::test_coefficients[banzhaf_coefficient-10]": 0.0032151709601748735, - "tests/value/test_semivalues.py::test_coefficients[beta_coefficient_w0-100]": 0.004444399964995682, - "tests/value/test_semivalues.py::test_coefficients[beta_coefficient_w0-10]": 0.003756532969418913, - "tests/value/test_semivalues.py::test_coefficients[beta_coefficient_w1-100]": 0.004344976012362167, - "tests/value/test_semivalues.py::test_coefficients[beta_coefficient_w1-10]": 0.003551592002622783, - "tests/value/test_semivalues.py::test_coefficients[beta_coefficient_w2-100]": 0.004556107014650479, - "tests/value/test_semivalues.py::test_coefficients[beta_coefficient_w2-10]": 0.0035066070267930627, - "tests/value/test_semivalues.py::test_coefficients[shapley_coefficient-100]": 0.0047601540281903, - "tests/value/test_semivalues.py::test_coefficients[shapley_coefficient-10]": 0.0030498180130962282, + "tests/value/shapley/test_truncated.py::test_tmcs_linear_montecarlo_with_outlier[truncated_montecarlo-kwargs0-scorer0-0.2-2-0-21]": 7.1438663650005765, + "tests/value/test_sampler.py::test_chunkify[AntitheticSampler]": 0.002635386001202278, + "tests/value/test_sampler.py::test_chunkify[DeterministicUniformSampler]": 0.002136322002115776, + "tests/value/test_sampler.py::test_chunkify[RandomHierarchicalSampler]": 0.0024412720013060607, + "tests/value/test_sampler.py::test_chunkify[UniformSampler]": 0.0022573409987671766, + "tests/value/test_sampler.py::test_chunkify_permutation[DeterministicPermutationSampler]": 0.0024367070000153035, + "tests/value/test_sampler.py::test_chunkify_permutation[PermutationSampler]": 0.002322892001757282, + "tests/value/test_sampler.py::test_proper[indices0-AntitheticSampler]": 0.003334062997964793, + "tests/value/test_sampler.py::test_proper[indices0-DeterministicPermutationSampler]": 0.002626270001201192, + "tests/value/test_sampler.py::test_proper[indices0-DeterministicUniformSampler]": 0.002812078997521894, + "tests/value/test_sampler.py::test_proper[indices0-PermutationSampler]": 0.002539194001656142, + "tests/value/test_sampler.py::test_proper[indices0-RandomHierarchicalSampler]": 0.0026362519984104438, + "tests/value/test_sampler.py::test_proper[indices0-UniformSampler]": 0.0024412409984506667, + "tests/value/test_sampler.py::test_proper[indices1-AntitheticSampler]": 0.0027277339995634975, + "tests/value/test_sampler.py::test_proper[indices1-DeterministicPermutationSampler]": 0.002861182998458389, + "tests/value/test_sampler.py::test_proper[indices1-DeterministicUniformSampler]": 0.004058188998897094, + "tests/value/test_sampler.py::test_proper[indices1-PermutationSampler]": 0.0026329000011173775, + "tests/value/test_sampler.py::test_proper[indices1-RandomHierarchicalSampler]": 0.003700332001244533, + "tests/value/test_sampler.py::test_proper[indices1-UniformSampler]": 0.003620775998570025, + "tests/value/test_sampler.py::test_proper_reproducible[indices0-AntitheticSampler]": 0.0028454019975470146, + "tests/value/test_sampler.py::test_proper_reproducible[indices0-PermutationSampler]": 0.0024918920007621637, + "tests/value/test_sampler.py::test_proper_reproducible[indices0-RandomHierarchicalSampler]": 0.0020272490019124234, + "tests/value/test_sampler.py::test_proper_reproducible[indices0-UniformSampler]": 0.0027337100000295322, + "tests/value/test_sampler.py::test_proper_reproducible[indices1-AntitheticSampler]": 0.009103345002586138, + "tests/value/test_sampler.py::test_proper_reproducible[indices1-PermutationSampler]": 0.003312619001007988, + "tests/value/test_sampler.py::test_proper_reproducible[indices1-RandomHierarchicalSampler]": 0.017666732001089258, + "tests/value/test_sampler.py::test_proper_reproducible[indices1-UniformSampler]": 0.010906160998274572, + "tests/value/test_sampler.py::test_proper_stochastic[indices0-AntitheticSampler]": 0.0025616729999455856, + "tests/value/test_sampler.py::test_proper_stochastic[indices0-PermutationSampler]": 0.0034559460000309628, + "tests/value/test_sampler.py::test_proper_stochastic[indices0-RandomHierarchicalSampler]": 0.0029194710004958324, + "tests/value/test_sampler.py::test_proper_stochastic[indices0-UniformSampler]": 0.0028906579991598846, + "tests/value/test_sampler.py::test_proper_stochastic[indices1-AntitheticSampler]": 0.011208809999516234, + "tests/value/test_sampler.py::test_proper_stochastic[indices1-PermutationSampler]": 0.003227124001568882, + "tests/value/test_sampler.py::test_proper_stochastic[indices1-RandomHierarchicalSampler]": 0.020847252999374177, + "tests/value/test_sampler.py::test_proper_stochastic[indices1-UniformSampler]": 0.01049548499941011, + "tests/value/test_semivalues.py::test_banzhaf[AntitheticPermutationSampler-5]": 19.099751196999932, + "tests/value/test_semivalues.py::test_banzhaf[AntitheticSampler-5]": 8.640272729999197, + "tests/value/test_semivalues.py::test_banzhaf[DeterministicPermutationSampler-5]": 11.046467014999507, + "tests/value/test_semivalues.py::test_banzhaf[DeterministicUniformSampler-5]": 7.140763282997796, + "tests/value/test_semivalues.py::test_banzhaf[PermutationSampler-5]": 16.536335553000754, + "tests/value/test_semivalues.py::test_banzhaf[UniformSampler-5]": 8.56469571100206, + "tests/value/test_semivalues.py::test_coefficients[banzhaf_coefficient-100]": 0.01005963700117718, + "tests/value/test_semivalues.py::test_coefficients[banzhaf_coefficient-10]": 0.008440342002359102, + "tests/value/test_semivalues.py::test_coefficients[beta_coefficient_w0-100]": 0.01072616300007212, + "tests/value/test_semivalues.py::test_coefficients[beta_coefficient_w0-10]": 0.010928496998531045, + "tests/value/test_semivalues.py::test_coefficients[beta_coefficient_w1-100]": 0.012177771001006477, + "tests/value/test_semivalues.py::test_coefficients[beta_coefficient_w1-10]": 0.00821317400004773, + "tests/value/test_semivalues.py::test_coefficients[beta_coefficient_w2-100]": 0.010945971000182908, + "tests/value/test_semivalues.py::test_coefficients[beta_coefficient_w2-10]": 0.008208530998672359, + "tests/value/test_semivalues.py::test_coefficients[shapley_coefficient-100]": 0.019708362000528723, + "tests/value/test_semivalues.py::test_coefficients[shapley_coefficient-10]": 0.007813238997187, + "tests/value/test_semivalues.py::test_games_shapley[beta_coefficient_w-AntitheticPermutationSampler-test_game0]": 22.607437191998542, + "tests/value/test_semivalues.py::test_games_shapley[beta_coefficient_w-AntitheticPermutationSampler-test_game1]": 19.905466008996882, + "tests/value/test_semivalues.py::test_games_shapley[beta_coefficient_w-AntitheticSampler-test_game0]": 22.902231953998125, + "tests/value/test_semivalues.py::test_games_shapley[beta_coefficient_w-AntitheticSampler-test_game1]": 20.254530511001576, + "tests/value/test_semivalues.py::test_games_shapley[beta_coefficient_w-PermutationSampler-test_game0]": 22.228997524001898, + "tests/value/test_semivalues.py::test_games_shapley[beta_coefficient_w-PermutationSampler-test_game1]": 19.948070817999906, + "tests/value/test_semivalues.py::test_games_shapley[beta_coefficient_w-UniformSampler-test_game0]": 23.313307015001556, + "tests/value/test_semivalues.py::test_games_shapley[beta_coefficient_w-UniformSampler-test_game1]": 20.214418551000563, + "tests/value/test_semivalues.py::test_games_shapley[shapley_coefficient-AntitheticPermutationSampler-test_game0]": 16.339908187999754, + "tests/value/test_semivalues.py::test_games_shapley[shapley_coefficient-AntitheticPermutationSampler-test_game1]": 14.935287896998489, + "tests/value/test_semivalues.py::test_games_shapley[shapley_coefficient-AntitheticSampler-test_game0]": 16.71660759900078, + "tests/value/test_semivalues.py::test_games_shapley[shapley_coefficient-AntitheticSampler-test_game1]": 15.118247157999576, + "tests/value/test_semivalues.py::test_games_shapley[shapley_coefficient-PermutationSampler-test_game0]": 16.669900056000188, + "tests/value/test_semivalues.py::test_games_shapley[shapley_coefficient-PermutationSampler-test_game1]": 14.85890512199876, + "tests/value/test_semivalues.py::test_games_shapley[shapley_coefficient-UniformSampler-test_game0]": 16.9996823649999, + "tests/value/test_semivalues.py::test_games_shapley[shapley_coefficient-UniformSampler-test_game1]": 15.419395829998393, + "tests/value/test_semivalues.py::test_games_shapley_deterministic[beta_coefficient_w-DeterministicPermutationSampler-test_game0]": 7.571815403000073, + "tests/value/test_semivalues.py::test_games_shapley_deterministic[beta_coefficient_w-DeterministicPermutationSampler-test_game1]": 6.795873736999056, + "tests/value/test_semivalues.py::test_games_shapley_deterministic[beta_coefficient_w-DeterministicPermutationSampler-test_game2]": 6.49785933900057, + "tests/value/test_semivalues.py::test_games_shapley_deterministic[beta_coefficient_w-DeterministicPermutationSampler-test_game3]": 7.046587265998824, + "tests/value/test_semivalues.py::test_games_shapley_deterministic[beta_coefficient_w-DeterministicUniformSampler-test_game0]": 6.9995765299991035, + "tests/value/test_semivalues.py::test_games_shapley_deterministic[beta_coefficient_w-DeterministicUniformSampler-test_game1]": 7.470778629000051, + "tests/value/test_semivalues.py::test_games_shapley_deterministic[beta_coefficient_w-DeterministicUniformSampler-test_game2]": 6.813381661997482, + "tests/value/test_semivalues.py::test_games_shapley_deterministic[beta_coefficient_w-DeterministicUniformSampler-test_game3]": 7.335269874001824, + "tests/value/test_semivalues.py::test_games_shapley_deterministic[shapley_coefficient-DeterministicPermutationSampler-test_game0]": 8.675189851999676, + "tests/value/test_semivalues.py::test_games_shapley_deterministic[shapley_coefficient-DeterministicPermutationSampler-test_game1]": 6.932035337997149, + "tests/value/test_semivalues.py::test_games_shapley_deterministic[shapley_coefficient-DeterministicPermutationSampler-test_game2]": 6.9341853499990975, + "tests/value/test_semivalues.py::test_games_shapley_deterministic[shapley_coefficient-DeterministicPermutationSampler-test_game3]": 6.737996050998845, + "tests/value/test_semivalues.py::test_games_shapley_deterministic[shapley_coefficient-DeterministicUniformSampler-test_game0]": 4.491834778002158, + "tests/value/test_semivalues.py::test_games_shapley_deterministic[shapley_coefficient-DeterministicUniformSampler-test_game1]": 6.446436399000959, + "tests/value/test_semivalues.py::test_games_shapley_deterministic[shapley_coefficient-DeterministicUniformSampler-test_game2]": 6.968900550000399, + "tests/value/test_semivalues.py::test_games_shapley_deterministic[shapley_coefficient-DeterministicUniformSampler-test_game3]": 6.659720210998785, + "tests/value/test_semivalues.py::test_marginal_batch_size[PermutationSampler-beta_coefficient_w-5-test_game0]": 0.004239154999595485, "tests/value/test_semivalues.py::test_shapley[beta_coefficient_w-AntitheticPermutationSampler-5]": 5.1298250389809255, "tests/value/test_semivalues.py::test_shapley[beta_coefficient_w-AntitheticSampler-5]": 21.97495059997891, "tests/value/test_semivalues.py::test_shapley[beta_coefficient_w-DeterministicPermutationSampler-5]": 5.294114143965999, @@ -460,18 +835,20 @@ "tests/value/test_semivalues.py::test_shapley[shapley_coefficient-DeterministicUniformSampler-5]": 3.263753114035353, "tests/value/test_semivalues.py::test_shapley[shapley_coefficient-PermutationSampler-5]": 4.766259174008155, "tests/value/test_semivalues.py::test_shapley[shapley_coefficient-UniformSampler-5]": 8.919797526003094, + "tests/value/test_semivalues.py::test_shapley_batch_size[1-PermutationSampler-beta_coefficient_w-5-test_game0]": 9.699354351001602, + "tests/value/test_semivalues.py::test_shapley_batch_size[2-PermutationSampler-beta_coefficient_w-5-test_game0]": 11.229309665000983, "tests/value/test_semivalues.py::test_shapley_batch_size[5-PermutationSampler-beta_coefficient_w-5]": 9.19877936199191, - "tests/value/test_stopping.py::test_history_deviation[0.01-100]": 0.7586702810076531, - "tests/value/test_stopping.py::test_history_deviation[0.01-1]": 0.01646678801625967, - "tests/value/test_stopping.py::test_history_deviation[0.01-42]": 0.35505866500898264, - "tests/value/test_stopping.py::test_history_deviation[0.05-100]": 0.15892104100203142, - "tests/value/test_stopping.py::test_history_deviation[0.05-1]": 0.003904131968738511, - "tests/value/test_stopping.py::test_history_deviation[0.05-42]": 0.06365110300248489, - "tests/value/test_stopping.py::test_make_criterion": 0.0067943750182166696, - "tests/value/test_stopping.py::test_max_checks": 0.0022287879837676883, - "tests/value/test_stopping.py::test_max_time": 0.30431480798870325, - "tests/value/test_stopping.py::test_minmax_updates": 0.003805230953730643, - "tests/value/test_stopping.py::test_standard_error": 0.003371614031493664, - "tests/value/test_stopping.py::test_stopping_criterion": 0.004461375967366621, - "tests/value/test_stopping.py::test_stopping_criterion_composition": 0.007468684023479 + "tests/value/test_stopping.py::test_history_deviation[0.01-100]": 1.7738857549993554, + "tests/value/test_stopping.py::test_history_deviation[0.01-1]": 0.029810868998538353, + "tests/value/test_stopping.py::test_history_deviation[0.01-42]": 0.7947784120024153, + "tests/value/test_stopping.py::test_history_deviation[0.05-100]": 0.3636526160007634, + "tests/value/test_stopping.py::test_history_deviation[0.05-1]": 0.010319109000192839, + "tests/value/test_stopping.py::test_history_deviation[0.05-42]": 0.16107529900000372, + "tests/value/test_stopping.py::test_make_criterion": 0.016543962998184725, + "tests/value/test_stopping.py::test_max_checks": 0.006280684001467307, + "tests/value/test_stopping.py::test_max_time": 0.30847623600129737, + "tests/value/test_stopping.py::test_minmax_updates": 0.012927236997711589, + "tests/value/test_stopping.py::test_standard_error": 0.007960140001159743, + "tests/value/test_stopping.py::test_stopping_criterion": 0.011265246001130436, + "tests/value/test_stopping.py::test_stopping_criterion_composition": 0.019021763000637293 } \ No newline at end of file From 023040fb1999c3a3c6e67d1912230d7a3372c946 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 23 Jan 2024 12:05:10 +0100 Subject: [PATCH 70/87] [skip ci] Add bugfix to changelog --- CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7cb23b437..1b9483834 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,6 +17,8 @@ for single dimensional arrays [PR #485](https://github.com/aai-institute/pyDVL/pull/485) - Fix implementations of `to` methods of `TorchInfluenceFunctionModel` implementations [PR #487](https://github.com/aai-institute/pyDVL/pull/487) +- Fixed bug with checking for converged values in semivalues + [PR #341](https://github.com/appliedAI-Initiative/pyDVL/pull/341) ## 0.8.0 - 🆕 New interfaces, scaling computation, bug fixes and improvements 🎁 From 516f5cf5e410564b7b5c38fbf114b9c5e29fae2c Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 23 Jan 2024 19:56:00 +0100 Subject: [PATCH 71/87] Bump mkdocs and mkdocs-material versions, use mkdocs-material cards instead of neoteroi-mkdocs --- docs/css/extra.css | 1 + docs/css/grid-cards.css | 23 +++++++++++++++ docs/css/neoteroi.css | 1 - docs/getting-started/first-steps.md | 8 +++--- docs/index.md | 43 +++++++++++++++++++---------- requirements-docs.txt | 5 ++-- 6 files changed, 58 insertions(+), 23 deletions(-) create mode 100644 docs/css/grid-cards.css delete mode 100644 docs/css/neoteroi.css diff --git a/docs/css/extra.css b/docs/css/extra.css index 0a74470ce..4354e03e9 100644 --- a/docs/css/extra.css +++ b/docs/css/extra.css @@ -69,6 +69,7 @@ a.autorefs-external:hover::after { .nt-card-image:focus { filter: invert(32%) sepia(93%) saturate(1535%) hue-rotate(220deg) brightness(102%) contrast(99%); } + .md-header__button.md-logo { padding: 0; } diff --git a/docs/css/grid-cards.css b/docs/css/grid-cards.css new file mode 100644 index 000000000..5980834cf --- /dev/null +++ b/docs/css/grid-cards.css @@ -0,0 +1,23 @@ +/* Shadow */ +.grid.cards > ul > li { + box-shadow: 0 2px 2px 0 rgb(0 0 0 / 14%), 0 3px 1px -2px rgb(0 0 0 / 20%), 0 1px 5px 0 rgb(0 0 0 / 12%); + + &:hover { + box-shadow: 0 2px 2px 0 rgb(0 0 0 / 24%), 0 3px 1px -2px rgb(0 0 0 / 30%), 0 1px 5px 0 rgb(0 0 0 / 22%); + } +} + +[data-md-color-scheme="slate"] { + .grid.cards > ul > li { + box-shadow: 0 2px 2px 0 rgb(4 40 33 / 14%), 0 3px 1px -2px rgb(40 86 94 / 47%), 0 1px 5px 0 rgb(139 252 255 / 64%); + + &:hover { + box-shadow: 0 2px 2px 0 rgb(0 255 206 / 14%), 0 3px 1px -2px rgb(33 156 177 / 47%), 0 1px 5px 0 rgb(96 251 255 / 64%); + } + } +} + +/* Hover */ +.grid.cards > ul > li:hover p:first-child { + color: var(--md-accent-fg-color); +} diff --git a/docs/css/neoteroi.css b/docs/css/neoteroi.css deleted file mode 100644 index 363c9229a..000000000 --- a/docs/css/neoteroi.css +++ /dev/null @@ -1 +0,0 @@ -:root{--nt-color-0: #CD853F;--nt-color-1: #B22222;--nt-color-2: #000080;--nt-color-3: #4B0082;--nt-color-4: #3CB371;--nt-color-5: #D2B48C;--nt-color-6: #FF00FF;--nt-color-7: #98FB98;--nt-color-8: #FFEBCD;--nt-color-9: #2E8B57;--nt-color-10: #6A5ACD;--nt-color-11: #48D1CC;--nt-color-12: #FFA500;--nt-color-13: #F4A460;--nt-color-14: #A52A2A;--nt-color-15: #FFE4C4;--nt-color-16: #FF4500;--nt-color-17: #AFEEEE;--nt-color-18: #FA8072;--nt-color-19: #2F4F4F;--nt-color-20: #FFDAB9;--nt-color-21: #BC8F8F;--nt-color-22: #FFC0CB;--nt-color-23: #00FA9A;--nt-color-24: #F0FFF0;--nt-color-25: #FFFACD;--nt-color-26: #F5F5F5;--nt-color-27: #FF6347;--nt-color-28: #FFFFF0;--nt-color-29: #7FFFD4;--nt-color-30: #E9967A;--nt-color-31: #7B68EE;--nt-color-32: #FFF8DC;--nt-color-33: #0000CD;--nt-color-34: #D2691E;--nt-color-35: #708090;--nt-color-36: #5F9EA0;--nt-color-37: #008080;--nt-color-38: #008000;--nt-color-39: #FFE4E1;--nt-color-40: #FFFF00;--nt-color-41: #FFFAF0;--nt-color-42: #DCDCDC;--nt-color-43: #ADFF2F;--nt-color-44: #ADD8E6;--nt-color-45: #8B008B;--nt-color-46: #7FFF00;--nt-color-47: #800000;--nt-color-48: #20B2AA;--nt-color-49: #556B2F;--nt-color-50: #778899;--nt-color-51: #E6E6FA;--nt-color-52: #FFFAFA;--nt-color-53: #FF7F50;--nt-color-54: #FF0000;--nt-color-55: #F5DEB3;--nt-color-56: #008B8B;--nt-color-57: #66CDAA;--nt-color-58: #808000;--nt-color-59: #FAF0E6;--nt-color-60: #00BFFF;--nt-color-61: #C71585;--nt-color-62: #00FFFF;--nt-color-63: #8B4513;--nt-color-64: #F0F8FF;--nt-color-65: #FAEBD7;--nt-color-66: #8B0000;--nt-color-67: #4682B4;--nt-color-68: #F0E68C;--nt-color-69: #BDB76B;--nt-color-70: #A0522D;--nt-color-71: #FAFAD2;--nt-color-72: #FFD700;--nt-color-73: #DEB887;--nt-color-74: #E0FFFF;--nt-color-75: #8A2BE2;--nt-color-76: #32CD32;--nt-color-77: #87CEFA;--nt-color-78: #00CED1;--nt-color-79: #696969;--nt-color-80: #DDA0DD;--nt-color-81: #EE82EE;--nt-color-82: #FFB6C1;--nt-color-83: #8FBC8F;--nt-color-84: #D8BFD8;--nt-color-85: #9400D3;--nt-color-86: #A9A9A9;--nt-color-87: #FFFFE0;--nt-color-88: #FFF5EE;--nt-color-89: #FFF0F5;--nt-color-90: #FFDEAD;--nt-color-91: #800080;--nt-color-92: #B0E0E6;--nt-color-93: #9932CC;--nt-color-94: #DAA520;--nt-color-95: #F0FFFF;--nt-color-96: #40E0D0;--nt-color-97: #00FF7F;--nt-color-98: #006400;--nt-color-99: #808080;--nt-color-100: #87CEEB;--nt-color-101: #0000FF;--nt-color-102: #6495ED;--nt-color-103: #FDF5E6;--nt-color-104: #B8860B;--nt-color-105: #BA55D3;--nt-color-106: #C0C0C0;--nt-color-107: #000000;--nt-color-108: #F08080;--nt-color-109: #B0C4DE;--nt-color-110: #00008B;--nt-color-111: #6B8E23;--nt-color-112: #FFE4B5;--nt-color-113: #FFA07A;--nt-color-114: #9ACD32;--nt-color-115: #FFFFFF;--nt-color-116: #F5F5DC;--nt-color-117: #90EE90;--nt-color-118: #1E90FF;--nt-color-119: #7CFC00;--nt-color-120: #FF69B4;--nt-color-121: #F8F8FF;--nt-color-122: #F5FFFA;--nt-color-123: #00FF00;--nt-color-124: #D3D3D3;--nt-color-125: #DB7093;--nt-color-126: #DA70D6;--nt-color-127: #FF1493;--nt-color-128: #228B22;--nt-color-129: #FFEFD5;--nt-color-130: #4169E1;--nt-color-131: #191970;--nt-color-132: #9370DB;--nt-color-133: #483D8B;--nt-color-134: #FF8C00;--nt-color-135: #EEE8AA;--nt-color-136: #CD5C5C;--nt-color-137: #DC143C}:root{--nt-group-0-main: #000000;--nt-group-0-dark: #FFFFFF;--nt-group-0-light: #000000;--nt-group-0-main-bg: #F44336;--nt-group-0-dark-bg: #BA000D;--nt-group-0-light-bg: #FF7961;--nt-group-1-main: #000000;--nt-group-1-dark: #FFFFFF;--nt-group-1-light: #000000;--nt-group-1-main-bg: #E91E63;--nt-group-1-dark-bg: #B0003A;--nt-group-1-light-bg: #FF6090;--nt-group-2-main: #FFFFFF;--nt-group-2-dark: #FFFFFF;--nt-group-2-light: #000000;--nt-group-2-main-bg: #9C27B0;--nt-group-2-dark-bg: #6A0080;--nt-group-2-light-bg: #D05CE3;--nt-group-3-main: #FFFFFF;--nt-group-3-dark: #FFFFFF;--nt-group-3-light: #000000;--nt-group-3-main-bg: #673AB7;--nt-group-3-dark-bg: #320B86;--nt-group-3-light-bg: #9A67EA;--nt-group-4-main: #FFFFFF;--nt-group-4-dark: #FFFFFF;--nt-group-4-light: #000000;--nt-group-4-main-bg: #3F51B5;--nt-group-4-dark-bg: #002984;--nt-group-4-light-bg: #757DE8;--nt-group-5-main: #000000;--nt-group-5-dark: #FFFFFF;--nt-group-5-light: #000000;--nt-group-5-main-bg: #2196F3;--nt-group-5-dark-bg: #0069C0;--nt-group-5-light-bg: #6EC6FF;--nt-group-6-main: #000000;--nt-group-6-dark: #FFFFFF;--nt-group-6-light: #000000;--nt-group-6-main-bg: #03A9F4;--nt-group-6-dark-bg: #007AC1;--nt-group-6-light-bg: #67DAFF;--nt-group-7-main: #000000;--nt-group-7-dark: #000000;--nt-group-7-light: #000000;--nt-group-7-main-bg: #00BCD4;--nt-group-7-dark-bg: #008BA3;--nt-group-7-light-bg: #62EFFF;--nt-group-8-main: #000000;--nt-group-8-dark: #FFFFFF;--nt-group-8-light: #000000;--nt-group-8-main-bg: #009688;--nt-group-8-dark-bg: #00675B;--nt-group-8-light-bg: #52C7B8;--nt-group-9-main: #000000;--nt-group-9-dark: #FFFFFF;--nt-group-9-light: #000000;--nt-group-9-main-bg: #4CAF50;--nt-group-9-dark-bg: #087F23;--nt-group-9-light-bg: #80E27E;--nt-group-10-main: #000000;--nt-group-10-dark: #000000;--nt-group-10-light: #000000;--nt-group-10-main-bg: #8BC34A;--nt-group-10-dark-bg: #5A9216;--nt-group-10-light-bg: #BEF67A;--nt-group-11-main: #000000;--nt-group-11-dark: #000000;--nt-group-11-light: #000000;--nt-group-11-main-bg: #CDDC39;--nt-group-11-dark-bg: #99AA00;--nt-group-11-light-bg: #FFFF6E;--nt-group-12-main: #000000;--nt-group-12-dark: #000000;--nt-group-12-light: #000000;--nt-group-12-main-bg: #FFEB3B;--nt-group-12-dark-bg: #C8B900;--nt-group-12-light-bg: #FFFF72;--nt-group-13-main: #000000;--nt-group-13-dark: #000000;--nt-group-13-light: #000000;--nt-group-13-main-bg: #FFC107;--nt-group-13-dark-bg: #C79100;--nt-group-13-light-bg: #FFF350;--nt-group-14-main: #000000;--nt-group-14-dark: #000000;--nt-group-14-light: #000000;--nt-group-14-main-bg: #FF9800;--nt-group-14-dark-bg: #C66900;--nt-group-14-light-bg: #FFC947;--nt-group-15-main: #000000;--nt-group-15-dark: #FFFFFF;--nt-group-15-light: #000000;--nt-group-15-main-bg: #FF5722;--nt-group-15-dark-bg: #C41C00;--nt-group-15-light-bg: #FF8A50;--nt-group-16-main: #FFFFFF;--nt-group-16-dark: #FFFFFF;--nt-group-16-light: #000000;--nt-group-16-main-bg: #795548;--nt-group-16-dark-bg: #4B2C20;--nt-group-16-light-bg: #A98274;--nt-group-17-main: #000000;--nt-group-17-dark: #FFFFFF;--nt-group-17-light: #000000;--nt-group-17-main-bg: #9E9E9E;--nt-group-17-dark-bg: #707070;--nt-group-17-light-bg: #CFCFCF;--nt-group-18-main: #000000;--nt-group-18-dark: #FFFFFF;--nt-group-18-light: #000000;--nt-group-18-main-bg: #607D8B;--nt-group-18-dark-bg: #34515E;--nt-group-18-light-bg: #8EACBB}.nt-pastello{--nt-group-0-main: #000000;--nt-group-0-dark: #000000;--nt-group-0-light: #000000;--nt-group-0-main-bg: #EF9A9A;--nt-group-0-dark-bg: #BA6B6C;--nt-group-0-light-bg: #FFCCCB;--nt-group-1-main: #000000;--nt-group-1-dark: #000000;--nt-group-1-light: #000000;--nt-group-1-main-bg: #F48FB1;--nt-group-1-dark-bg: #BF5F82;--nt-group-1-light-bg: #FFC1E3;--nt-group-2-main: #000000;--nt-group-2-dark: #000000;--nt-group-2-light: #000000;--nt-group-2-main-bg: #CE93D8;--nt-group-2-dark-bg: #9C64A6;--nt-group-2-light-bg: #FFC4FF;--nt-group-3-main: #000000;--nt-group-3-dark: #000000;--nt-group-3-light: #000000;--nt-group-3-main-bg: #B39DDB;--nt-group-3-dark-bg: #836FA9;--nt-group-3-light-bg: #E6CEFF;--nt-group-4-main: #000000;--nt-group-4-dark: #000000;--nt-group-4-light: #000000;--nt-group-4-main-bg: #9FA8DA;--nt-group-4-dark-bg: #6F79A8;--nt-group-4-light-bg: #D1D9FF;--nt-group-5-main: #000000;--nt-group-5-dark: #000000;--nt-group-5-light: #000000;--nt-group-5-main-bg: #90CAF9;--nt-group-5-dark-bg: #5D99C6;--nt-group-5-light-bg: #C3FDFF;--nt-group-6-main: #000000;--nt-group-6-dark: #000000;--nt-group-6-light: #000000;--nt-group-6-main-bg: #81D4FA;--nt-group-6-dark-bg: #4BA3C7;--nt-group-6-light-bg: #B6FFFF;--nt-group-7-main: #000000;--nt-group-7-dark: #000000;--nt-group-7-light: #000000;--nt-group-7-main-bg: #80DEEA;--nt-group-7-dark-bg: #4BACB8;--nt-group-7-light-bg: #B4FFFF;--nt-group-8-main: #000000;--nt-group-8-dark: #000000;--nt-group-8-light: #000000;--nt-group-8-main-bg: #80CBC4;--nt-group-8-dark-bg: #4F9A94;--nt-group-8-light-bg: #B2FEF7;--nt-group-9-main: #000000;--nt-group-9-dark: #000000;--nt-group-9-light: #000000;--nt-group-9-main-bg: #A5D6A7;--nt-group-9-dark-bg: #75A478;--nt-group-9-light-bg: #D7FFD9;--nt-group-10-main: #000000;--nt-group-10-dark: #000000;--nt-group-10-light: #000000;--nt-group-10-main-bg: #C5E1A5;--nt-group-10-dark-bg: #94AF76;--nt-group-10-light-bg: #F8FFD7;--nt-group-11-main: #000000;--nt-group-11-dark: #000000;--nt-group-11-light: #000000;--nt-group-11-main-bg: #E6EE9C;--nt-group-11-dark-bg: #B3BC6D;--nt-group-11-light-bg: #FFFFCE;--nt-group-12-main: #000000;--nt-group-12-dark: #000000;--nt-group-12-light: #000000;--nt-group-12-main-bg: #FFF59D;--nt-group-12-dark-bg: #CBC26D;--nt-group-12-light-bg: #FFFFCF;--nt-group-13-main: #000000;--nt-group-13-dark: #000000;--nt-group-13-light: #000000;--nt-group-13-main-bg: #FFE082;--nt-group-13-dark-bg: #CAAE53;--nt-group-13-light-bg: #FFFFB3;--nt-group-14-main: #000000;--nt-group-14-dark: #000000;--nt-group-14-light: #000000;--nt-group-14-main-bg: #FFCC80;--nt-group-14-dark-bg: #CA9B52;--nt-group-14-light-bg: #FFFFB0;--nt-group-15-main: #000000;--nt-group-15-dark: #000000;--nt-group-15-light: #000000;--nt-group-15-main-bg: #FFAB91;--nt-group-15-dark-bg: #C97B63;--nt-group-15-light-bg: #FFDDC1;--nt-group-16-main: #000000;--nt-group-16-dark: #000000;--nt-group-16-light: #000000;--nt-group-16-main-bg: #BCAAA4;--nt-group-16-dark-bg: #8C7B75;--nt-group-16-light-bg: #EFDCD5;--nt-group-17-main: #000000;--nt-group-17-dark: #000000;--nt-group-17-light: #000000;--nt-group-17-main-bg: #EEEEEE;--nt-group-17-dark-bg: #BCBCBC;--nt-group-17-light-bg: #FFFFFF;--nt-group-18-main: #000000;--nt-group-18-dark: #000000;--nt-group-18-light: #000000;--nt-group-18-main-bg: #B0BEC5;--nt-group-18-dark-bg: #808E95;--nt-group-18-light-bg: #E2F1F8}.nt-group-0 .nt-plan-group-summary,.nt-group-0 .nt-timeline-dot{color:var(--nt-group-0-dark);background-color:var(--nt-group-0-dark-bg)}.nt-group-0 .period{color:var(--nt-group-0-main);background-color:var(--nt-group-0-main-bg)}.nt-group-1 .nt-plan-group-summary,.nt-group-1 .nt-timeline-dot{color:var(--nt-group-1-dark);background-color:var(--nt-group-1-dark-bg)}.nt-group-1 .period{color:var(--nt-group-1-main);background-color:var(--nt-group-1-main-bg)}.nt-group-2 .nt-plan-group-summary,.nt-group-2 .nt-timeline-dot{color:var(--nt-group-2-dark);background-color:var(--nt-group-2-dark-bg)}.nt-group-2 .period{color:var(--nt-group-2-main);background-color:var(--nt-group-2-main-bg)}.nt-group-3 .nt-plan-group-summary,.nt-group-3 .nt-timeline-dot{color:var(--nt-group-3-dark);background-color:var(--nt-group-3-dark-bg)}.nt-group-3 .period{color:var(--nt-group-3-main);background-color:var(--nt-group-3-main-bg)}.nt-group-4 .nt-plan-group-summary,.nt-group-4 .nt-timeline-dot{color:var(--nt-group-4-dark);background-color:var(--nt-group-4-dark-bg)}.nt-group-4 .period{color:var(--nt-group-4-main);background-color:var(--nt-group-4-main-bg)}.nt-group-5 .nt-plan-group-summary,.nt-group-5 .nt-timeline-dot{color:var(--nt-group-5-dark);background-color:var(--nt-group-5-dark-bg)}.nt-group-5 .period{color:var(--nt-group-5-main);background-color:var(--nt-group-5-main-bg)}.nt-group-6 .nt-plan-group-summary,.nt-group-6 .nt-timeline-dot{color:var(--nt-group-6-dark);background-color:var(--nt-group-6-dark-bg)}.nt-group-6 .period{color:var(--nt-group-6-main);background-color:var(--nt-group-6-main-bg)}.nt-group-7 .nt-plan-group-summary,.nt-group-7 .nt-timeline-dot{color:var(--nt-group-7-dark);background-color:var(--nt-group-7-dark-bg)}.nt-group-7 .period{color:var(--nt-group-7-main);background-color:var(--nt-group-7-main-bg)}.nt-group-8 .nt-plan-group-summary,.nt-group-8 .nt-timeline-dot{color:var(--nt-group-8-dark);background-color:var(--nt-group-8-dark-bg)}.nt-group-8 .period{color:var(--nt-group-8-main);background-color:var(--nt-group-8-main-bg)}.nt-group-9 .nt-plan-group-summary,.nt-group-9 .nt-timeline-dot{color:var(--nt-group-9-dark);background-color:var(--nt-group-9-dark-bg)}.nt-group-9 .period{color:var(--nt-group-9-main);background-color:var(--nt-group-9-main-bg)}.nt-group-10 .nt-plan-group-summary,.nt-group-10 .nt-timeline-dot{color:var(--nt-group-10-dark);background-color:var(--nt-group-10-dark-bg)}.nt-group-10 .period{color:var(--nt-group-10-main);background-color:var(--nt-group-10-main-bg)}.nt-group-11 .nt-plan-group-summary,.nt-group-11 .nt-timeline-dot{color:var(--nt-group-11-dark);background-color:var(--nt-group-11-dark-bg)}.nt-group-11 .period{color:var(--nt-group-11-main);background-color:var(--nt-group-11-main-bg)}.nt-group-12 .nt-plan-group-summary,.nt-group-12 .nt-timeline-dot{color:var(--nt-group-12-dark);background-color:var(--nt-group-12-dark-bg)}.nt-group-12 .period{color:var(--nt-group-12-main);background-color:var(--nt-group-12-main-bg)}.nt-group-13 .nt-plan-group-summary,.nt-group-13 .nt-timeline-dot{color:var(--nt-group-13-dark);background-color:var(--nt-group-13-dark-bg)}.nt-group-13 .period{color:var(--nt-group-13-main);background-color:var(--nt-group-13-main-bg)}.nt-group-14 .nt-plan-group-summary,.nt-group-14 .nt-timeline-dot{color:var(--nt-group-14-dark);background-color:var(--nt-group-14-dark-bg)}.nt-group-14 .period{color:var(--nt-group-14-main);background-color:var(--nt-group-14-main-bg)}.nt-group-15 .nt-plan-group-summary,.nt-group-15 .nt-timeline-dot{color:var(--nt-group-15-dark);background-color:var(--nt-group-15-dark-bg)}.nt-group-15 .period{color:var(--nt-group-15-main);background-color:var(--nt-group-15-main-bg)}.nt-group-16 .nt-plan-group-summary,.nt-group-16 .nt-timeline-dot{color:var(--nt-group-16-dark);background-color:var(--nt-group-16-dark-bg)}.nt-group-16 .period{color:var(--nt-group-16-main);background-color:var(--nt-group-16-main-bg)}.nt-group-17 .nt-plan-group-summary,.nt-group-17 .nt-timeline-dot{color:var(--nt-group-17-dark);background-color:var(--nt-group-17-dark-bg)}.nt-group-17 .period{color:var(--nt-group-17-main);background-color:var(--nt-group-17-main-bg)}.nt-group-18 .nt-plan-group-summary,.nt-group-18 .nt-timeline-dot{color:var(--nt-group-18-dark);background-color:var(--nt-group-18-dark-bg)}.nt-group-18 .period{color:var(--nt-group-18-main);background-color:var(--nt-group-18-main-bg)}.nt-error{border:2px dashed darkred;padding:0 1rem;background:#faf9ba;color:darkred}.nt-timeline{margin-top:30px}.nt-timeline .nt-timeline-title{font-size:1.1rem;margin-top:0}.nt-timeline .nt-timeline-sub-title{margin-top:0}.nt-timeline .nt-timeline-content{font-size:.8rem;border-bottom:2px dashed #ccc;padding-bottom:1.2rem}.nt-timeline.horizontal .nt-timeline-items{flex-direction:row;overflow-x:scroll}.nt-timeline.horizontal .nt-timeline-items>div{min-width:400px;margin-right:50px}.nt-timeline.horizontal.reverse .nt-timeline-items{flex-direction:row-reverse}.nt-timeline.horizontal.center .nt-timeline-before{background-image:linear-gradient(rgba(252, 70, 107, 0) 0%, rgb(252, 70, 107) 100%);background-repeat:no-repeat;background-size:100% 2px;background-position:0 center}.nt-timeline.horizontal.center .nt-timeline-after{background-image:linear-gradient(180deg, rgb(252, 70, 107) 0%, rgba(252, 70, 107, 0) 100%);background-repeat:no-repeat;background-size:100% 2px;background-position:0 center}.nt-timeline.horizontal.center .nt-timeline-items{background-image:radial-gradient(circle, rgb(63, 94, 251) 0%, rgb(252, 70, 107) 100%);background-repeat:no-repeat;background-size:100% 2px;background-position:0 center}.nt-timeline.horizontal .nt-timeline-dot{left:50%}.nt-timeline.horizontal .nt-timeline-dot:not(.bigger){top:calc(50% - 4px)}.nt-timeline.horizontal .nt-timeline-dot.bigger{top:calc(50% - 15px)}.nt-timeline.vertical .nt-timeline-items{flex-direction:column}.nt-timeline.vertical.reverse .nt-timeline-items{flex-direction:column-reverse}.nt-timeline.vertical.center .nt-timeline-before{background:linear-gradient(rgba(252, 70, 107, 0) 0%, rgb(252, 70, 107) 100%) no-repeat center/2px 100%}.nt-timeline.vertical.center .nt-timeline-after{background:linear-gradient(rgb(252, 70, 107) 0%, rgba(252, 70, 107, 0) 100%) no-repeat center/2px 100%}.nt-timeline.vertical.center .nt-timeline-items{background:radial-gradient(circle, rgb(63, 94, 251) 0%, rgb(252, 70, 107) 100%) no-repeat center/2px 100%}.nt-timeline.vertical.center .nt-timeline-dot{left:calc(50% - 10px)}.nt-timeline.vertical.center .nt-timeline-dot:not(.bigger){top:10px}.nt-timeline.vertical.center .nt-timeline-dot.bigger{left:calc(50% - 20px)}.nt-timeline.vertical.left{padding-left:100px}.nt-timeline.vertical.left .nt-timeline-item{padding-left:70px}.nt-timeline.vertical.left .nt-timeline-sub-title{left:-100px;width:100px}.nt-timeline.vertical.left .nt-timeline-before{background:linear-gradient(rgba(252, 70, 107, 0) 0%, rgb(252, 70, 107) 100%) no-repeat 30px/2px 100%}.nt-timeline.vertical.left .nt-timeline-after{background:linear-gradient(rgb(252, 70, 107) 0%, rgba(252, 70, 107, 0) 100%) no-repeat 30px/2px 100%}.nt-timeline.vertical.left .nt-timeline-items{background:radial-gradient(circle, rgb(63, 94, 251) 0%, rgb(252, 70, 107) 100%) no-repeat 30px/2px 100%}.nt-timeline.vertical.left .nt-timeline-dot{left:21px;top:8px}.nt-timeline.vertical.left .nt-timeline-dot.bigger{top:0px;left:10px}.nt-timeline.vertical.right{padding-right:100px}.nt-timeline.vertical.right .nt-timeline-sub-title{right:-100px;text-align:left;width:100px}.nt-timeline.vertical.right .nt-timeline-item{padding-right:70px}.nt-timeline.vertical.right .nt-timeline-before{background:linear-gradient(rgba(252, 70, 107, 0) 0%, rgb(252, 70, 107) 100%) no-repeat calc(100% - 30px)/2px 100%}.nt-timeline.vertical.right .nt-timeline-after{background:linear-gradient(rgb(252, 70, 107) 0%, rgba(252, 70, 107, 0) 100%) no-repeat calc(100% - 30px)/2px 100%}.nt-timeline.vertical.right .nt-timeline-items{background:radial-gradient(circle, rgb(63, 94, 251) 0%, rgb(252, 70, 107) 100%) no-repeat calc(100% - 30px)/2px 100%}.nt-timeline.vertical.right .nt-timeline-dot{right:21px;top:8px}.nt-timeline.vertical.right .nt-timeline-dot.bigger{top:10px;right:10px}.nt-timeline-items{display:flex;position:relative}.nt-timeline-items>div{min-height:100px;padding-top:2px;padding-bottom:20px}.nt-timeline-before{content:"";height:15px}.nt-timeline-after{content:"";height:60px;margin-bottom:20px}.nt-timeline-sub-title{position:absolute;width:50%;top:4px;font-size:18px;color:var(--nt-color-50)}[data-md-color-scheme=slate] .nt-timeline-sub-title{color:var(--nt-color-51)}.nt-timeline-item{position:relative}.nt-timeline.vertical.center:not(.alternate) .nt-timeline-item{padding-left:calc(50% + 40px)}.nt-timeline.vertical.center:not(.alternate) .nt-timeline-item .nt-timeline-sub-title{left:0;padding-right:40px;text-align:right}.nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(odd){padding-left:calc(50% + 40px)}.nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(odd) .nt-timeline-sub-title{left:0;padding-right:40px;text-align:right}.nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(even){text-align:right;padding-right:calc(50% + 40px)}.nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(even) .nt-timeline-sub-title{right:0;padding-left:40px;text-align:left}.nt-timeline-dot{position:relative;width:20px;height:20px;border-radius:100%;background-color:#fc5b5b;position:absolute;top:0px;z-index:2;display:flex;justify-content:center;align-items:center;box-shadow:0 2px 1px -1px rgba(0,0,0,.2),0 1px 1px 0 rgba(0,0,0,.14),0 1px 3px 0 rgba(0,0,0,.12);border:3px solid #fff}.nt-timeline-dot:not(.bigger) .icon{font-size:10px}.nt-timeline-dot.bigger{width:40px;height:40px;padding:3px}.nt-timeline-dot .icon{color:#fff}@supports not (-moz-appearance: none){details .nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(odd) .nt-timeline-sub-title,details .nt-timeline.vertical.center:not(.alternate) .nt-timeline-item .nt-timeline-sub-title{left:-40px}details .nt-timeline.vertical.center.alternate .nt-timeline-item:nth-child(even) .nt-timeline-sub-title{right:-40px}details .nt-timeline.vertical.center .nt-timeline-dot{left:calc(50% - 12px)}details .nt-timeline-dot.bigger{font-size:1rem !important}}.nt-timeline-item:nth-child(0) .nt-timeline-dot{background-color:var(--nt-color-0)}.nt-timeline-item:nth-child(1) .nt-timeline-dot{background-color:var(--nt-color-1)}.nt-timeline-item:nth-child(2) .nt-timeline-dot{background-color:var(--nt-color-2)}.nt-timeline-item:nth-child(3) .nt-timeline-dot{background-color:var(--nt-color-3)}.nt-timeline-item:nth-child(4) .nt-timeline-dot{background-color:var(--nt-color-4)}.nt-timeline-item:nth-child(5) .nt-timeline-dot{background-color:var(--nt-color-5)}.nt-timeline-item:nth-child(6) .nt-timeline-dot{background-color:var(--nt-color-6)}.nt-timeline-item:nth-child(7) .nt-timeline-dot{background-color:var(--nt-color-7)}.nt-timeline-item:nth-child(8) .nt-timeline-dot{background-color:var(--nt-color-8)}.nt-timeline-item:nth-child(9) .nt-timeline-dot{background-color:var(--nt-color-9)}.nt-timeline-item:nth-child(10) .nt-timeline-dot{background-color:var(--nt-color-10)}.nt-timeline-item:nth-child(11) .nt-timeline-dot{background-color:var(--nt-color-11)}.nt-timeline-item:nth-child(12) .nt-timeline-dot{background-color:var(--nt-color-12)}.nt-timeline-item:nth-child(13) .nt-timeline-dot{background-color:var(--nt-color-13)}.nt-timeline-item:nth-child(14) .nt-timeline-dot{background-color:var(--nt-color-14)}.nt-timeline-item:nth-child(15) .nt-timeline-dot{background-color:var(--nt-color-15)}.nt-timeline-item:nth-child(16) .nt-timeline-dot{background-color:var(--nt-color-16)}.nt-timeline-item:nth-child(17) .nt-timeline-dot{background-color:var(--nt-color-17)}.nt-timeline-item:nth-child(18) .nt-timeline-dot{background-color:var(--nt-color-18)}.nt-timeline-item:nth-child(19) .nt-timeline-dot{background-color:var(--nt-color-19)}.nt-timeline-item:nth-child(20) .nt-timeline-dot{background-color:var(--nt-color-20)}:root{--nt-scrollbar-color: #2751b0;--nt-plan-actions-height: 24px;--nt-units-background: #ff9800;--nt-months-background: #2751b0;--nt-plan-vertical-line-color: #a3a3a3ad}.nt-pastello{--nt-scrollbar-color: #9fb8f4;--nt-units-background: #f5dc82;--nt-months-background: #5b7fd1}[data-md-color-scheme=slate]{--nt-units-background: #003773}[data-md-color-scheme=slate] .nt-pastello{--nt-units-background: #3f4997}.nt-plan-root{min-height:200px;scrollbar-width:20px;scrollbar-color:var(--nt-scrollbar-color);display:flex}.nt-plan-root ::-webkit-scrollbar{width:20px}.nt-plan-root ::-webkit-scrollbar-track{box-shadow:inset 0 0 5px gray;border-radius:10px}.nt-plan-root ::-webkit-scrollbar-thumb{background:var(--nt-scrollbar-color);border-radius:10px}.nt-plan-root .nt-plan{flex:80%}.nt-plan-root.no-groups .nt-plan-periods{padding-left:0}.nt-plan-root.no-groups .nt-plan-group-summary{display:none}.nt-plan-root .nt-timeline-dot.bigger{top:-10px}.nt-plan-root .nt-timeline-dot.bigger[title]{cursor:help}.nt-plan{white-space:nowrap;overflow-x:auto;display:flex}.nt-plan .ug-timeline-dot{left:368px;top:-8px;cursor:help}.months{display:flex}.month{flex:auto;display:inline-block;box-shadow:rgba(0,0,0,.2) 0px 3px 1px -2px,rgba(0,0,0,.14) 0px 2px 2px 0px,rgba(0,0,0,.12) 0px 1px 5px 0px inset;background-color:var(--nt-months-background);color:#fff;text-transform:uppercase;font-family:Roboto,Helvetica,Arial,sans-serif;padding:2px 5px;font-size:12px;border:1px solid #000;width:150px;border-radius:8px}.nt-plan-group-activities{flex:auto;position:relative}.nt-vline{border-left:1px dashed var(--nt-plan-vertical-line-color);height:100%;left:0;position:absolute;margin-left:-0.5px;top:0;-webkit-transition:all .5s linear !important;-moz-transition:all .5s linear !important;-ms-transition:all .5s linear !important;-o-transition:all .5s linear !important;transition:all .5s linear !important;z-index:-2}.nt-plan-activity{display:flex;margin:2px 0;background-color:rgba(187,187,187,.2509803922)}.actions{height:var(--nt-plan-actions-height)}.actions{position:relative}.period{display:inline-block;height:var(--nt-plan-actions-height);width:120px;position:absolute;left:0px;background:#1da1f2;border-radius:5px;transition:all .5s;cursor:help;-webkit-transition:width 1s ease-in-out;-moz-transition:width 1s ease-in-out;-o-transition:width 1s ease-in-out;transition:width 1s ease-in-out}.period .nt-tooltip{display:none;top:30px;position:relative;padding:1rem;text-align:center;font-size:12px}.period:hover .nt-tooltip{display:inline-block}.period-0{left:340px;visibility:visible;background-color:#456165}.period-1{left:40px;visibility:visible;background-color:green}.period-2{left:120px;visibility:visible;background-color:pink;width:80px}.period-3{left:190px;visibility:visible;background-color:darkred;width:150px}.weeks>span,.days>span{height:25px}.weeks>span{display:inline-block;margin:0;padding:0;font-weight:bold}.weeks>span .week-text{font-size:10px;position:absolute;display:inline-block;padding:3px 4px}.days{z-index:-2;position:relative}.day-text{font-size:10px;position:absolute;display:inline-block;padding:3px 4px}.period span{font-size:12px;vertical-align:top;margin-left:4px;color:#000;background:rgba(255,255,255,.6588235294);border-radius:6px;padding:0 4px}.weeks,.days{height:20px;display:flex;box-sizing:content-box}.months{display:flex}.week,.day{height:20px;position:relative;border:1;flex:auto;border:2px solid #fff;border-radius:4px;background-color:var(--nt-units-background);cursor:help}.years{display:flex}.year{text-align:center;border-right:1px solid var(--nt-plan-vertical-line-color);font-weight:bold}.year:first-child{border-left:1px solid var(--nt-plan-vertical-line-color)}.year:first-child:last-child{width:100%}.quarters{display:flex}.quarter{width:12.5%;text-align:center;border-right:1px solid var(--nt-plan-vertical-line-color);font-weight:bold}.quarter:first-child{border-left:1px solid var(--nt-plan-vertical-line-color)}.nt-plan-group{margin:20px 0;position:relative}.nt-plan-group{display:flex}.nt-plan-group-summary{background:#2751b0;width:150px;white-space:normal;padding:.1rem .5rem;border-radius:5px;color:#fff;z-index:3}.nt-plan-group-summary p{margin:0;padding:0;font-size:.6rem;color:#fff}.nt-plan-group-summary,.month,.period,.week,.day,.nt-tooltip{border:3px solid #fff;box-shadow:0 2px 3px -1px rgba(0,0,0,.2),0 3px 3px 0 rgba(0,0,0,.14),0 1px 5px 0 rgba(0,0,0,.12)}.nt-plan-periods{padding-left:150px}.months{z-index:2;position:relative}.weeks{position:relative;top:-2px;z-index:0}.month,.quarter,.year,.week,.day,.nt-tooltip{font-family:Roboto,Helvetica,Arial,sans-serif;box-sizing:border-box}.nt-cards.nt-grid{display:grid;grid-auto-columns:1fr;gap:.5rem;max-width:100vw;overflow-x:auto;padding:1px}.nt-cards.nt-grid.cols-1{grid-template-columns:repeat(1, 1fr)}.nt-cards.nt-grid.cols-2{grid-template-columns:repeat(2, 1fr)}.nt-cards.nt-grid.cols-3{grid-template-columns:repeat(3, 1fr)}.nt-cards.nt-grid.cols-4{grid-template-columns:repeat(4, 1fr)}.nt-cards.nt-grid.cols-5{grid-template-columns:repeat(5, 1fr)}.nt-cards.nt-grid.cols-6{grid-template-columns:repeat(6, 1fr)}@media only screen and (max-width: 400px){.nt-cards.nt-grid{grid-template-columns:repeat(1, 1fr) !important}}.nt-card{box-shadow:0 2px 2px 0 rgba(0,0,0,.14),0 3px 1px -2px rgba(0,0,0,.2),0 1px 5px 0 rgba(0,0,0,.12)}.nt-card:hover{box-shadow:0 2px 2px 0 rgba(0,0,0,.24),0 3px 1px -2px rgba(0,0,0,.3),0 1px 5px 0 rgba(0,0,0,.22)}[data-md-color-scheme=slate] .nt-card{box-shadow:0 2px 2px 0 rgba(4,40,33,.14),0 3px 1px -2px rgba(40,86,94,.47),0 1px 5px 0 rgba(139,252,255,.64)}[data-md-color-scheme=slate] .nt-card:hover{box-shadow:0 2px 2px 0 rgba(0,255,206,.14),0 3px 1px -2px rgba(33,156,177,.47),0 1px 5px 0 rgba(96,251,255,.64)}.nt-card>a{color:var(--md-default-fg-color)}.nt-card>a>div{cursor:pointer}.nt-card{padding:5px;margin-bottom:.5rem}.nt-card-title{font-size:1rem;font-weight:bold;margin:4px 0 8px 0;line-height:22px}.nt-card-content{padding:.4rem .8rem .8rem .8rem}.nt-card-text{font-size:14px;padding:0;margin:0}.nt-card .nt-card-image{text-align:center;border-radius:2px;background-position:center center;background-size:cover;background-repeat:no-repeat;min-height:120px}.nt-card .nt-card-image.tags img{margin-top:12px}.nt-card .nt-card-image img{height:105px;margin-top:5px}.nt-card a:hover,.nt-card a:focus{color:var(--md-accent-fg-color)}.nt-card h2{margin:0}.span-table-wrapper table{border-collapse:collapse;margin-bottom:2rem;border-radius:.1rem}.span-table td,.span-table th{padding:.2rem;background-color:var(--md-default-bg-color);font-size:.64rem;max-width:100%;overflow:auto;touch-action:auto;border-top:.05rem solid var(--md-typeset-table-color);padding:.9375em 1.25em;vertical-align:top}.span-table tr:first-child td{font-weight:700;min-width:5rem;padding:.9375em 1.25em;vertical-align:top}.span-table td:first-child{border-left:.05rem solid var(--md-typeset-table-color)}.span-table td:last-child{border-right:.05rem solid var(--md-typeset-table-color)}.span-table tr:last-child{border-bottom:.05rem solid var(--md-typeset-table-color)}.span-table [colspan],.span-table [rowspan]{font-weight:bold;border:.05rem solid var(--md-typeset-table-color)}.span-table tr:not(:first-child):hover td:not([colspan]):not([rowspan]),.span-table td[colspan]:hover,.span-table td[rowspan]:hover{background-color:rgba(0,0,0,.035);box-shadow:0 .05rem 0 var(--md-default-bg-color) inset;transition:background-color 125ms}.nt-contribs{margin-top:2rem;font-size:small;border-top:1px dotted #d3d3d3;padding-top:.5rem}.nt-contribs .nt-contributors{padding-top:.5rem;display:flex;flex-wrap:wrap}.nt-contribs .nt-contributor{background:#d3d3d3;background-size:cover;width:40px;height:40px;border-radius:100%;margin:0 6px 6px 0;cursor:help;opacity:.7}.nt-contribs .nt-contributor:hover{opacity:1}.nt-contribs .nt-initials{text-transform:uppercase;font-size:24px;text-align:center;width:40px;height:40px;display:inline-block;vertical-align:middle;position:relative;top:2px;color:inherit;font-weight:bold}.nt-contribs .nt-group-0{background-color:var(--nt-color-0)}.nt-contribs .nt-group-1{background-color:var(--nt-color-1)}.nt-contribs .nt-group-2{background-color:var(--nt-color-2)}.nt-contribs .nt-group-3{background-color:var(--nt-color-3)}.nt-contribs .nt-group-4{background-color:var(--nt-color-4)}.nt-contribs .nt-group-5{background-color:var(--nt-color-5)}.nt-contribs .nt-group-6{background-color:var(--nt-color-6)}.nt-contribs .nt-group-7{color:#000;background-color:var(--nt-color-7)}.nt-contribs .nt-group-8{color:#000;background-color:var(--nt-color-8)}.nt-contribs .nt-group-9{background-color:var(--nt-color-9)}.nt-contribs .nt-group-10{background-color:var(--nt-color-10)}.nt-contribs .nt-group-11{background-color:var(--nt-color-11)}.nt-contribs .nt-group-12{background-color:var(--nt-color-12)}.nt-contribs .nt-group-13{background-color:var(--nt-color-13)}.nt-contribs .nt-group-14{background-color:var(--nt-color-14)}.nt-contribs .nt-group-15{color:#000;background-color:var(--nt-color-15)}.nt-contribs .nt-group-16{background-color:var(--nt-color-16)}.nt-contribs .nt-group-17{color:#000;background-color:var(--nt-color-17)}.nt-contribs .nt-group-18{background-color:var(--nt-color-18)}.nt-contribs .nt-group-19{background-color:var(--nt-color-19)}.nt-contribs .nt-group-20{color:#000;background-color:var(--nt-color-20)}.nt-contribs .nt-group-21{color:#000;background-color:var(--nt-color-21)}.nt-contribs .nt-group-22{color:#000;background-color:var(--nt-color-22)}.nt-contribs .nt-group-23{color:#000;background-color:var(--nt-color-23)}.nt-contribs .nt-group-24{color:#000;background-color:var(--nt-color-24)}.nt-contribs .nt-group-25{color:#000;background-color:var(--nt-color-25)}.nt-contribs .nt-group-26{color:#000;background-color:var(--nt-color-26)}.nt-contribs .nt-group-27{background-color:var(--nt-color-27)}.nt-contribs .nt-group-28{color:#000;background-color:var(--nt-color-28)}.nt-contribs .nt-group-29{color:#000;background-color:var(--nt-color-29)}.nt-contribs .nt-group-30{background-color:var(--nt-color-30)}.nt-contribs .nt-group-31{background-color:var(--nt-color-31)}.nt-contribs .nt-group-32{color:#000;background-color:var(--nt-color-32)}.nt-contribs .nt-group-33{background-color:var(--nt-color-33)}.nt-contribs .nt-group-34{background-color:var(--nt-color-34)}.nt-contribs .nt-group-35{background-color:var(--nt-color-35)}.nt-contribs .nt-group-36{background-color:var(--nt-color-36)}.nt-contribs .nt-group-37{background-color:var(--nt-color-37)}.nt-contribs .nt-group-38{background-color:var(--nt-color-38)}.nt-contribs .nt-group-39{color:#000;background-color:var(--nt-color-39)}.nt-contribs .nt-group-40{color:#000;background-color:var(--nt-color-40)}.nt-contribs .nt-group-41{color:#000;background-color:var(--nt-color-41)}.nt-contribs .nt-group-42{color:#000;background-color:var(--nt-color-42)}.nt-contribs .nt-group-43{color:#000;background-color:var(--nt-color-43)}.nt-contribs .nt-group-44{color:#000;background-color:var(--nt-color-44)}.nt-contribs .nt-group-45{background-color:var(--nt-color-45)}.nt-contribs .nt-group-46{color:#000;background-color:var(--nt-color-46)}.nt-contribs .nt-group-47{background-color:var(--nt-color-47)}.nt-contribs .nt-group-48{background-color:var(--nt-color-48)}.nt-contribs .nt-group-49{background-color:var(--nt-color-49)} \ No newline at end of file diff --git a/docs/getting-started/first-steps.md b/docs/getting-started/first-steps.md index 403724362..9793cbf4a 100644 --- a/docs/getting-started/first-steps.md +++ b/docs/getting-started/first-steps.md @@ -1,11 +1,11 @@ --- -title: Getting Started +title: First Steps alias: - name: getting-started - text: Getting Started + name: first-steps + text: First Steps --- -# Getting started +# First Steps !!! Warning Make sure you have read [[installation]] before using the library. diff --git a/docs/index.md b/docs/index.md index fb6408b9e..c77b2c980 100644 --- a/docs/index.md +++ b/docs/index.md @@ -9,26 +9,39 @@ It runs most of them in parallel either locally or in a cluster and supports distributed caching of results. If you're a first time user of pyDVL, we recommend you to go through the -[[getting-started]] and [[installation]] guides. +[[installation]] and [[first-steps]] guides in the Getting Started section. -::cards:: cols=2 +
-- title: Installation - content: Steps to install and requirements - url: getting-started/installation.md +- :fontawesome-solid-toolbox:{ .lg .middle } __Installation__ + + --- + Steps to install and requirements + + [[installation|:octicons-arrow-right-24: Installation]] + +- :fontawesome-solid-scale-unbalanced:{ .lg .middle } __Data valuation__ + + --- -- title: Data valuation - content: > Basics of data valuation and description of the main algorithms - url: value/ -- title: Influence Function - content: > + [[data-valuation|:octicons-arrow-right-24: Data Valuation]] + +- :fontawesome-solid-scale-unbalanced-flip:{ .lg .middle } __Influence Function__ + + --- + An introduction to the influence function and its computation with pyDVL - url: influence/ -- title: Browse the API - content: Full documentation of the API - url: api/pydvl/ + [[influence-values|:octicons-arrow-right-24: Influence Values]] + +- :fontawesome-regular-file-code:{ .lg .middle } __API Reference__ + + --- + + Full documentation of the API + + [:octicons-arrow-right-24: API Reference](api/pydvl/) -::/cards:: +
diff --git a/requirements-docs.txt b/requirements-docs.txt index a4e0b016e..ca554638c 100644 --- a/requirements-docs.txt +++ b/requirements-docs.txt @@ -1,6 +1,6 @@ mike markdown-captions -mkdocs==1.5.2 +mkdocs==1.5.3 mkdocstrings[python]>=0.18 mkdocs-alias-plugin>=0.6.0 mkdocs-autorefs @@ -11,10 +11,9 @@ mkdocs-glightbox mknotebooks>=0.8.0 pygments mkdocs-literate-nav -mkdocs-material +mkdocs-material>=9.5.0 mkdocs-section-index mkdocs-macros-plugin -neoteroi-mkdocs # Needed for card grid on home page pypandoc; sys_platform == 'darwin' pypandoc_binary; sys_platform != 'darwin' GitPython From fd063f45aab53ee96556342b36542683462bc3bf Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 23 Jan 2024 19:56:33 +0100 Subject: [PATCH 72/87] Add contributing guide to the documentation --- CONTRIBUTING.md | 24 +++---- build_scripts/copy_contributing_guide.py | 38 ++++++++++ mkdocs.yml | 89 +++++++++++++----------- 3 files changed, 100 insertions(+), 51 deletions(-) create mode 100644 build_scripts/copy_contributing_guide.py diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 3d1bd0dc9..ad8038705 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -23,7 +23,7 @@ to make your life easier. Run the following to set up the pre-commit git hook to run before pushes: -```shell script +```shell pre-commit install --hook-type pre-push ``` @@ -32,7 +32,7 @@ pre-commit install --hook-type pre-push We strongly suggest using some form of virtual environment for working with the library. E.g. with venv: -```shell script +```shell python -m venv ./venv . venv/bin/activate # `venv\Scripts\activate` in windows pip install -r requirements-dev.txt -r requirements-docs.txt @@ -40,7 +40,7 @@ pip install -r requirements-dev.txt -r requirements-docs.txt With conda: -```shell script +```shell conda create -n pydvl python=3.8 conda activate pydvl pip install -r requirements-dev.txt -r requirements-docs.txt @@ -49,7 +49,7 @@ pip install -r requirements-dev.txt -r requirements-docs.txt A very convenient way of working with your library during development is to install it in editable mode into your environment by running -```shell script +```shell pip install -e . ``` @@ -58,7 +58,7 @@ suite) [pandoc](https://pandoc.org/) is required. Except for OSX, it should be i automatically as a dependency with `requirements-docs.txt`. Under OSX you can install pandoc (you'll need at least version 2.11) with: -```shell script +```shell brew install pandoc ``` @@ -152,11 +152,11 @@ Two important markers are: To test the notebooks separately, run (see [below](#notebooks) for details): ```shell -tox -e tests -- notebooks/ +tox -e notebook-tests ``` To create a package locally, run: -```shell script +```shell python setup.py sdist bdist_wheel ``` @@ -517,13 +517,13 @@ Then, a new release can be created using the script `bumpversion` automatically derive the next release version by bumping the patch part): -```shell script +```shell build_scripts/release-version.sh 0.1.6 ``` To find out how to use the script, pass the `-h` or `--help` flags: -```shell script +```shell build_scripts/release-version.sh --help ``` @@ -549,7 +549,7 @@ create a new release manually by following these steps: 2. When ready to release: From the develop branch create the release branch and perform release activities (update changelog, news, ...). For your own convenience, define an env variable for the release version - ```shell script + ```shell export RELEASE_VERSION="vX.Y.Z" git checkout develop git branch release/${RELEASE_VERSION} && git checkout release/${RELEASE_VERSION} @@ -560,7 +560,7 @@ create a new release manually by following these steps: (the `release` part is ignored but required by bumpversion :rolling_eyes:). 4. Merge the release branch into `master`, tag the merge commit, and push back to the repo. The CI pipeline publishes the package based on the tagged commit. - ```shell script + ```shell git checkout master git merge --no-ff release/${RELEASE_VERSION} git tag -a ${RELEASE_VERSION} -m"Release ${RELEASE_VERSION}" @@ -571,7 +571,7 @@ create a new release manually by following these steps: always strictly more recent than the last published release version from `master`. 6. Merge the release branch into `develop`: - ```shell script + ```shell git checkout develop git merge --no-ff release/${RELEASE_VERSION} git push origin develop diff --git a/build_scripts/copy_contributing_guide.py b/build_scripts/copy_contributing_guide.py new file mode 100644 index 000000000..0c4b2fbf2 --- /dev/null +++ b/build_scripts/copy_contributing_guide.py @@ -0,0 +1,38 @@ +import logging +import os +from pathlib import Path + +import mkdocs.plugins + +logger = logging.getLogger(__name__) + +root_dir = Path(__file__).parent.parent +docs_dir = root_dir / "docs" +contributing_file = root_dir / "CONTRIBUTING.md" +target_filepath = docs_dir / contributing_file.name + + +@mkdocs.plugins.event_priority(100) +def on_pre_build(config): + logger.info("Temporarily copying contributing guide to docs directory") + try: + if os.path.getmtime(contributing_file) <= os.path.getmtime(target_filepath): + logger.info( + f"Contributing guide '{os.fspath(contributing_file)}' hasn't been updated, skipping." + ) + return + except FileNotFoundError: + pass + logger.info( + f"Creating symbolic link for '{os.fspath(contributing_file)}' " + f"at '{os.fspath(target_filepath)}'" + ) + target_filepath.symlink_to(contributing_file) + + logger.info("Finished copying contributing guide to docs directory") + + +@mkdocs.plugins.event_priority(-100) +def on_shutdown(): + logger.info("Removing temporary contributing guide in docs directory") + target_filepath.unlink() diff --git a/mkdocs.yml b/mkdocs.yml index dace2fa73..927a07076 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -6,6 +6,38 @@ repo_url: "https://github.com/aai-institute/pyDVL" copyright: "Copyright © AppliedAI Institute gGmbH" remote_branch: gh-pages +nav: + - Home: index.md + - Getting Started: + - Installation: getting-started/installation.md + - First steps: getting-started/first-steps.md + - Data Valuation: + - Introduction: value/index.md + - Notation: value/notation.md + - Shapley values: value/shapley.md + - Semi-values: value/semi-values.md + - The core: value/the-core.md + - Classwise Shapley: value/classwise-shapley.md + - Examples: + - Shapley values: examples/shapley_basic_spotify.ipynb + - KNN Shapley: examples/shapley_knn_flowers.ipynb + - Data utility learning: examples/shapley_utility_learning.ipynb + - Least Core: examples/least_core_basic.ipynb + - Data OOB: examples/data_oob.ipynb + - The Influence Function: + - Introduction: influence/index.md + - Influence Function Model: influence/influence_function_model.md + - Scaling Computation: influence/scaling_computation.md + - Examples: + - For CNNs: examples/influence_imagenet.ipynb + - For mislabeled data: examples/influence_synthetic.ipynb + - For outlier detection: examples/influence_wine.ipynb + - For sentiment analysis: examples/influence_sentiment_analysis.ipynb + - Code: + - API Reference: api/pydvl/ + - Changelog: CHANGELOG.md + - Development Guidelines: CONTRIBUTING.md + watch: - src/pydvl - notebooks @@ -13,6 +45,7 @@ watch: hooks: - build_scripts/copy_notebooks.py - build_scripts/copy_changelog.py + - build_scripts/copy_contributing_guide.py - build_scripts/modify_binder_link.py plugins: @@ -106,18 +139,26 @@ theme: - content.code.annotate - content.code.copy - navigation.footer -# - content.tooltips # insiders only + - content.tooltips # - navigation.indexes - navigation.instant - navigation.path -# - navigation.sections + - navigation.sections # - navigation.tabs - navigation.top - navigation.tracking - search.suggest - search.highlight - toc.follow - palette: # Palette toggle for light mode + palette: + # Palette toggle for automatic mode + - media: "(prefers-color-scheme)" + scheme: default + primary: teal + toggle: + icon: material/brightness-auto + name: Switch to light mode + # Palette toggle for light mode - media: "(prefers-color-scheme: light)" scheme: default primary: teal @@ -130,11 +171,12 @@ theme: primary: teal toggle: icon: material/brightness-4 - name: Switch to light mode + name: Switch to system preference extra_css: - css/extra.css - css/neoteroi.css + - css/grid-cards.css extra_javascript: - javascripts/mathjax.js @@ -143,8 +185,8 @@ extra_javascript: extra: transferlab: - website: https://transferlab.appliedai.de - data_valuation_review: https://transferlab.appliedai.de/reviews/data-valuation + website: https://transferlab.ai/ + data_valuation_review: https://transferlab.ai/reviews/data-valuation copyright_link: https://appliedai-institute.de version: provider: mike @@ -174,8 +216,8 @@ markdown_extensions: - pymdownx.tabbed: alternate_style: true - pymdownx.emoji: - emoji_index: !!python/name:materialx.emoji.twemoji - emoji_generator: !!python/name:materialx.emoji.to_svg + emoji_index: !!python/name:material.extensions.emoji.twemoji + emoji_generator: !!python/name:material.extensions.emoji.to_svg - pymdownx.highlight: anchor_linenums: true pygments_lang_class: true @@ -188,34 +230,3 @@ markdown_extensions: - docs_includes/abbreviations.md - pymdownx.superfences - pymdownx.details - -nav: - - Home: index.md - - Getting Started: - - Installation: getting-started/installation.md - - First steps: getting-started/first-steps.md - - Data Valuation: - - Introduction: value/index.md - - Notation: value/notation.md - - Shapley values: value/shapley.md - - Semi-values: value/semi-values.md - - The core: value/the-core.md - - Classwise Shapley: value/classwise-shapley.md - - Examples: - - Shapley values: examples/shapley_basic_spotify.ipynb - - KNN Shapley: examples/shapley_knn_flowers.ipynb - - Data utility learning: examples/shapley_utility_learning.ipynb - - Least Core: examples/least_core_basic.ipynb - - Data OOB: examples/data_oob.ipynb - - The Influence Function: - - Introduction: influence/index.md - - Influence Function Model: influence/influence_function_model.md - - Scaling Computation: influence/scaling_computation.md - - Examples: - - For CNNs: examples/influence_imagenet.ipynb - - For mislabeled data: examples/influence_synthetic.ipynb - - For outlier detection: examples/influence_wine.ipynb - - For sentiment analysis: examples/influence_sentiment_analysis.ipynb - - Code: - - Changelog: CHANGELOG.md - - API: api/pydvl/ From 9ae99a81963b0b554eae78ad1d44e4d180092b5e Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 23 Jan 2024 19:57:03 +0100 Subject: [PATCH 73/87] Use ray, influence and memcached extras for all test environments --- tox.ini | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/tox.ini b/tox.ini index 666a5760c..095729e2c 100644 --- a/tox.ini +++ b/tox.ini @@ -9,16 +9,13 @@ deps = extras = ray influence + memcached setenv = COVERAGE_FILE = {env:COVERAGE_FILE:{toxinidir}/.coverage.{envname}} passenv = CI [testenv:tests] -extras = - ray - influence - memcached commands = pytest -n auto --dist worksteal --cov "{envsitepackagesdir}/pydvl" {posargs} From 8458165eba488fc73837f9a67b45a893b0c62e8f Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Tue, 23 Jan 2024 20:02:59 +0100 Subject: [PATCH 74/87] Remove leftover deprecated code --- src/pydvl/value/least_core/__init__.py | 15 +-------------- src/pydvl/value/least_core/common.py | 15 --------------- src/pydvl/value/least_core/montecarlo.py | 15 --------------- src/pydvl/value/least_core/naive.py | 15 --------------- 4 files changed, 1 insertion(+), 59 deletions(-) diff --git a/src/pydvl/value/least_core/__init__.py b/src/pydvl/value/least_core/__init__.py index abf34c623..39c764fef 100644 --- a/src/pydvl/value/least_core/__init__.py +++ b/src/pydvl/value/least_core/__init__.py @@ -47,6 +47,7 @@ def compute_least_core_values( mode: LeastCoreMode = LeastCoreMode.MonteCarlo, non_negative_subsidy: bool = False, solver_options: Optional[dict] = None, + progress: bool = False, **kwargs, ) -> ValuationResult: """Umbrella method to compute Least Core values with any of the available @@ -80,20 +81,6 @@ def compute_least_core_values( !!! tip "New in version 0.5.0" """ - progress: bool = kwargs.pop("progress", False) - - # TODO: remove this before releasing version 0.7.0 - if kwargs: - warnings.warn( - DeprecationWarning( - "Passing solver options as kwargs was deprecated in 0.6.0, will " - "be removed in 0.7.0. `Use solver_options` instead." - ) - ) - if solver_options is None: - solver_options = kwargs - else: - solver_options.update(kwargs) if mode == LeastCoreMode.MonteCarlo: # TODO fix progress showing in remote case diff --git a/src/pydvl/value/least_core/common.py b/src/pydvl/value/least_core/common.py index 2de8e7e3a..984930217 100644 --- a/src/pydvl/value/least_core/common.py +++ b/src/pydvl/value/least_core/common.py @@ -34,7 +34,6 @@ def lc_solve_problem( algorithm: str, non_negative_subsidy: bool = False, solver_options: Optional[dict] = None, - **options, ) -> ValuationResult: """Solves a linear problem as prepared by [mclc_prepare_problem()][pydvl.value.least_core.montecarlo.mclc_prepare_problem]. @@ -55,20 +54,6 @@ def lc_solve_problem( RuntimeWarning, ) - # TODO: remove this before releasing version 0.7.0 - if options: - warnings.warn( - DeprecationWarning( - "Passing solver options as kwargs was deprecated in " - "0.6.0, will be removed in 0.7.0. `Use solver_options` " - "instead." - ) - ) - if solver_options is None: - solver_options = options - else: - solver_options.update(options) - if solver_options is None: solver_options = {} diff --git a/src/pydvl/value/least_core/montecarlo.py b/src/pydvl/value/least_core/montecarlo.py index 88dc11ded..70a23b12d 100644 --- a/src/pydvl/value/least_core/montecarlo.py +++ b/src/pydvl/value/least_core/montecarlo.py @@ -27,7 +27,6 @@ def montecarlo_least_core( config: ParallelConfig = ParallelConfig(), non_negative_subsidy: bool = False, solver_options: Optional[dict] = None, - options: Optional[dict] = None, progress: bool = False, seed: Optional[Seed] = None, ) -> ValuationResult: @@ -68,20 +67,6 @@ def montecarlo_least_core( Returns: Object with the data values and the least core value. """ - # TODO: remove this before releasing version 0.7.0 - if options: - warnings.warn( - DeprecationWarning( - "Passing solver options as kwargs was deprecated in " - "0.6.0, will be removed in 0.7.0. `Use solver_options` " - "instead." - ) - ) - if solver_options is None: - solver_options = options - else: - solver_options.update(options) - problem = mclc_prepare_problem( u, n_iterations, n_jobs=n_jobs, config=config, progress=progress, seed=seed ) diff --git a/src/pydvl/value/least_core/naive.py b/src/pydvl/value/least_core/naive.py index f97021678..08bb34efe 100644 --- a/src/pydvl/value/least_core/naive.py +++ b/src/pydvl/value/least_core/naive.py @@ -20,7 +20,6 @@ def exact_least_core( *, non_negative_subsidy: bool = False, solver_options: Optional[dict] = None, - options: Optional[dict] = None, progress: bool = True, ) -> ValuationResult: r"""Computes the exact Least Core values. @@ -63,20 +62,6 @@ def exact_least_core( if n > 20: # Arbitrary choice, will depend on time required, caching, etc. warnings.warn(f"Large dataset! Computation requires 2^{n} calls to model.fit()") - # TODO: remove this before releasing version 0.7.0 - if options: - warnings.warn( - DeprecationWarning( - "Passing solver options as kwargs was deprecated in " - "0.6.0, will " - "be removed in 0.7.0. `Use solver_options` instead." - ) - ) - if solver_options is None: - solver_options = options - else: - solver_options.update(options) - problem = lc_prepare_problem(u, progress=progress) return lc_solve_problem( problem=problem, From 7691bfa1806e4593c2f42a1fb0f073f4cd0649cf Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 24 Jan 2024 11:59:22 +0100 Subject: [PATCH 75/87] Make cards grow and change color on hover --- docs/css/grid-cards.css | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/docs/css/grid-cards.css b/docs/css/grid-cards.css index 5980834cf..8be3dcbb8 100644 --- a/docs/css/grid-cards.css +++ b/docs/css/grid-cards.css @@ -1,9 +1,11 @@ -/* Shadow */ +/* Shadow and Hover */ .grid.cards > ul > li { box-shadow: 0 2px 2px 0 rgb(0 0 0 / 14%), 0 3px 1px -2px rgb(0 0 0 / 20%), 0 1px 5px 0 rgb(0 0 0 / 12%); &:hover { - box-shadow: 0 2px 2px 0 rgb(0 0 0 / 24%), 0 3px 1px -2px rgb(0 0 0 / 30%), 0 1px 5px 0 rgb(0 0 0 / 22%); + transform: scale(1.05); + z-index: 999; + background-color: rgba(0, 0, 0, 0.05); } } @@ -12,12 +14,9 @@ box-shadow: 0 2px 2px 0 rgb(4 40 33 / 14%), 0 3px 1px -2px rgb(40 86 94 / 47%), 0 1px 5px 0 rgb(139 252 255 / 64%); &:hover { - box-shadow: 0 2px 2px 0 rgb(0 255 206 / 14%), 0 3px 1px -2px rgb(33 156 177 / 47%), 0 1px 5px 0 rgb(96 251 255 / 64%); + transform: scale(1.05); + z-index: 999; + background-color: rgba(139, 252, 255, 0.05); } } } - -/* Hover */ -.grid.cards > ul > li:hover p:first-child { - color: var(--md-accent-fg-color); -} From e102ee49256df1fb8f55b64a4bbf84b43b5673ae Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 24 Jan 2024 11:59:59 +0100 Subject: [PATCH 76/87] Use AI to add a shorter version of the applications of data valuation blog post --- docs/value/applications.md | 84 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 84 insertions(+) create mode 100644 docs/value/applications.md diff --git a/docs/value/applications.md b/docs/value/applications.md new file mode 100644 index 000000000..9a60a6bc2 --- /dev/null +++ b/docs/value/applications.md @@ -0,0 +1,84 @@ +--- +title: Applications of valuation +--- + +# Applications of valuation + +Data valuation methods hold promise for improving various aspects +of data engineering and machine learning workflows. When applied judiciously, +these methods can enhance data quality, model performance, and cost-effectiveness. + +While still an evolving field requiring careful use, data valuation has demonstrated +utility across a range of data engineering tasks. + +For a more comprehensive overview of applications, along with concrete examples, +please refer to the [Transferlab blog post]({{ transferlab.website }}blog/data-valuation-applications/) +on this topic. + +## Data Engineering + +While still an emerging field, judicious use of data valuation techniques +has the potential to enhance data quality, model performance, +and the cost-effectiveness of data workflows in many applications. +Some of the promising applications in data engineering include: + +- Removing low-value data points can reduce noise and increase model performance. + However, care is needed to avoid overfitting when iteratively retraining on pruned datasets. +- Pruning redundant samples enables more efficient training of large models. + Value-based metrics can determine which data to discard for optimal efficiency gains. +- Computing value scores for unlabeled data points supports efficient active learning. + High-value points can be prioritized for labeling to maximize gains in model performance. +- Analyzing high- and low-value data provides insights to guide targeted data collection + and improve upstream data processes. Low-value points may reveal data issues to address. +- Data value metrics can also help identify irrelevant or duplicated data + when evaluating offerings from data providers. + +## Model development + +Data valuation techniques can provide insights for model debugging and interpretation. +Some of the useful applications include: + +- Interpretation and debugging: Analyzing the most or least valuable samples + for a class can reveal cases where the model relies on confounding features + instead of true signal. Investigating influential points for misclassified examples + highlights limitations to address. +- Sensitivity/robustness analysis: Prior work shows removing a small fraction + of highly influential data can completely flip model conclusions. + This reveals potential issues with the modeling approach, data collection process, + or intrinsic difficulty of the problem that require further inspection. + + Robust models require many points removed before conclusions meaningfully shift. + High sensitivity means conclusions heavily depend on small subsets of data, + indicating deeper problems to resolve. +- Monitoring changes in data value during training provides insights into + model convergence and overfitting. + +## Attacks + +Data valuation techniques have applications in detecting data manipulation and contamination: + +- Watermark removal: Points with low value on a correct validation set may be + part of a watermarking mechanism. Removing them can strip a model of its fingerprints. +- Poisoning attacks: Influential points can be shifted to induce large changes + in model estimators. However, the feasibility of such attacks is limited, + and their value for adversarial training is unclear. + +Overall, while data valuation techniques show promise for identifying anomalous +or manipulated data, more research is needed to develop robust methods suited +for security applications. + +## Data markets + +Data valuation techniques have potential applications in emerging data markets +connecting data providers and consumers: + +- Market pricing depends on the value addition for buyers + (e.g. improved model performance) and costs/privacy concerns for sellers. +- Game-theoretic valuation methods like Shapley values can help assign fair prices, + but have limitations around handling duplicates or adversarial data. +- Approaches like LAVA[@just_lava_2023] and CRAIG are suited for markets where the buyer's model + is unknown, a common real-world constraint. + +Overall, valuation methods show promise for equitable pricing and curbing +adversarial behavior in data markets. But more research is still needed +on robust techniques suited for diverse real-world scenarios. From b4c8c93dbb9c97994d4be4be83835b334193de50 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 24 Jan 2024 12:00:17 +0100 Subject: [PATCH 77/87] Move all examples to their own section --- mkdocs.yml | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/mkdocs.yml b/mkdocs.yml index 927a07076..8e23bd4b9 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -13,22 +13,24 @@ nav: - First steps: getting-started/first-steps.md - Data Valuation: - Introduction: value/index.md + - Applications: value/applications.md - Notation: value/notation.md - Shapley values: value/shapley.md - Semi-values: value/semi-values.md - - The core: value/the-core.md + - The Core: value/the-core.md - Classwise Shapley: value/classwise-shapley.md - - Examples: - - Shapley values: examples/shapley_basic_spotify.ipynb - - KNN Shapley: examples/shapley_knn_flowers.ipynb - - Data utility learning: examples/shapley_utility_learning.ipynb - - Least Core: examples/least_core_basic.ipynb - - Data OOB: examples/data_oob.ipynb - The Influence Function: - Introduction: influence/index.md - Influence Function Model: influence/influence_function_model.md - Scaling Computation: influence/scaling_computation.md - - Examples: + - Examples: + - Data Valuation: + - Shapley values: examples/shapley_basic_spotify.ipynb + - KNN Shapley: examples/shapley_knn_flowers.ipynb + - Data utility learning: examples/shapley_utility_learning.ipynb + - Least Core: examples/least_core_basic.ipynb + - Data OOB: examples/data_oob.ipynb + - Influence Function: - For CNNs: examples/influence_imagenet.ipynb - For mislabeled data: examples/influence_synthetic.ipynb - For outlier detection: examples/influence_wine.ipynb From 6b9c8acd32cff5a41fba15c020839a0727d7945e Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 24 Jan 2024 12:08:47 +0100 Subject: [PATCH 78/87] Update changelog --- CHANGELOG.md | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 1b9483834..c97101260 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -20,6 +20,12 @@ - Fixed bug with checking for converged values in semivalues [PR #341](https://github.com/appliedAI-Initiative/pyDVL/pull/341) +### Docs + +- Add applications of data valuation section, display examples more prominently, + make all sections visible in table of contents, use mkdocs material cards + in the home page [PR #492](https://github.com/aai-institute/pyDVL/pull/492) + ## 0.8.0 - 🆕 New interfaces, scaling computation, bug fixes and improvements 🎁 ### Added From c908504923d57ad080742117da21d62dc76cdab3 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 24 Jan 2024 12:21:12 +0100 Subject: [PATCH 79/87] Remove neoteroi from mkdocs.yml --- mkdocs.yml | 2 -- 1 file changed, 2 deletions(-) diff --git a/mkdocs.yml b/mkdocs.yml index 8e23bd4b9..69d6b6045 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -177,7 +177,6 @@ theme: extra_css: - css/extra.css - - css/neoteroi.css - css/grid-cards.css extra_javascript: @@ -210,7 +209,6 @@ markdown_extensions: - footnotes - markdown_captions - md_in_html - - neoteroi.cards - codehilite - toc: permalink: True From 9c304e132709477f6cba88dd444114b91e71a83d Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 24 Jan 2024 14:12:20 +0100 Subject: [PATCH 80/87] Apply suggestions from code review Co-authored-by: Miguel de Benito Delgado --- docs/value/applications.md | 13 +++++++------ mkdocs.yml | 1 - 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/docs/value/applications.md b/docs/value/applications.md index 9a60a6bc2..5af7637a4 100644 --- a/docs/value/applications.md +++ b/docs/value/applications.md @@ -8,12 +8,10 @@ Data valuation methods hold promise for improving various aspects of data engineering and machine learning workflows. When applied judiciously, these methods can enhance data quality, model performance, and cost-effectiveness. -While still an evolving field requiring careful use, data valuation has demonstrated -utility across a range of data engineering tasks. - -For a more comprehensive overview of applications, along with concrete examples, -please refer to the [Transferlab blog post]({{ transferlab.website }}blog/data-valuation-applications/) -on this topic. +While still an evolving field with methods requiring careful use, data valuation can +be applied across a wide range of data engineering tasks. For a comprehensive +overview, along with concrete examples, please refer to the [Transferlab blog +post]({{ transferlab.website }}blog/data-valuation-applications/) on this topic. ## Data Engineering @@ -52,6 +50,9 @@ Some of the useful applications include: indicating deeper problems to resolve. - Monitoring changes in data value during training provides insights into model convergence and overfitting. +- Continual learning: in order to avoid forgetting when training on new data, + a subset of previously seen data is presented again. Data valuation helps + in the selection of highly influential samples. ## Attacks diff --git a/mkdocs.yml b/mkdocs.yml index 69d6b6045..7ae01a1cb 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -187,7 +187,6 @@ extra_javascript: extra: transferlab: website: https://transferlab.ai/ - data_valuation_review: https://transferlab.ai/reviews/data-valuation copyright_link: https://appliedai-institute.de version: provider: mike From a003c0eb2de38bde586024aa5c0f64ca35f53982 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 24 Jan 2024 15:56:12 +0100 Subject: [PATCH 81/87] Skip notebook cells longer than 30s during testing --- tox.ini | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tox.ini b/tox.ini index 095729e2c..d62cfe481 100644 --- a/tox.ini +++ b/tox.ini @@ -24,7 +24,7 @@ deps = {[testenv]deps} -r requirements-notebooks.txt commands = - pytest --nbmake -n 0 --cov "{envsitepackagesdir}/pydvl" notebooks/ {posargs} + pytest --nbmake --nbmake-timeout=30 -n 0 --cov "{envsitepackagesdir}/pydvl" notebooks/ {posargs} [testenv:linting] skip_install = true From 9bac1bb5827d8eb596e10708495d43fc422e63db Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 24 Jan 2024 18:03:21 +0100 Subject: [PATCH 82/87] Apply suggestions from code review Co-authored-by: Miguel de Benito Delgado --- docs/value/applications.md | 1 - 1 file changed, 1 deletion(-) diff --git a/docs/value/applications.md b/docs/value/applications.md index 5af7637a4..b73bc9463 100644 --- a/docs/value/applications.md +++ b/docs/value/applications.md @@ -44,7 +44,6 @@ Some of the useful applications include: of highly influential data can completely flip model conclusions. This reveals potential issues with the modeling approach, data collection process, or intrinsic difficulty of the problem that require further inspection. - Robust models require many points removed before conclusions meaningfully shift. High sensitivity means conclusions heavily depend on small subsets of data, indicating deeper problems to resolve. From 0abb293b825dc0af15976e90595f335033bfa324 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 24 Jan 2024 18:25:20 +0100 Subject: [PATCH 83/87] Combine applications of data valuation sections into one --- docs/value/applications.md | 33 ++++++++++++++++++++------------- docs/value/index.md | 27 --------------------------- src/pydvl/value/loo/naive.py | 19 ------------------- 3 files changed, 20 insertions(+), 59 deletions(-) delete mode 100644 src/pydvl/value/loo/naive.py diff --git a/docs/value/applications.md b/docs/value/applications.md index b73bc9463..cf07e8cc5 100644 --- a/docs/value/applications.md +++ b/docs/value/applications.md @@ -1,13 +1,19 @@ --- -title: Applications of valuation +title: Applications of data valuation --- -# Applications of valuation +# Applications of data valuation Data valuation methods hold promise for improving various aspects of data engineering and machine learning workflows. When applied judiciously, these methods can enhance data quality, model performance, and cost-effectiveness. +However, the results can be inconsistent. Values have a strong dependency +on the training procedure and the performance metric used. For instance, +accuracy is a poor metric for imbalanced sets and this has a stark effect +on data values. Some models exhibit great variance in some regimes +and this again has a detrimental effect on values. + While still an evolving field with methods requiring careful use, data valuation can be applied across a wide range of data engineering tasks. For a comprehensive overview, along with concrete examples, please refer to the [Transferlab blog @@ -69,16 +75,17 @@ for security applications. ## Data markets -Data valuation techniques have potential applications in emerging data markets -connecting data providers and consumers: +Additionally, one of the motivating applications for the whole field is that of +data markets: a marketplace where data owners can sell their data to interested +parties. In this setting, data valuation can be key component to determine the +price of data. Market pricing depends on the value addition for buyers +(e.g. improved model performance) and costs/privacy concerns for sellers. -- Market pricing depends on the value addition for buyers - (e.g. improved model performance) and costs/privacy concerns for sellers. -- Game-theoretic valuation methods like Shapley values can help assign fair prices, - but have limitations around handling duplicates or adversarial data. -- Approaches like LAVA[@just_lava_2023] and CRAIG are suited for markets where the buyer's model - is unknown, a common real-world constraint. +Game-theoretic valuation methods like Shapley values can help assign fair prices, +but have limitations around handling duplicates or adversarial data. +Model-free methods like LAVA [@just_lava_2023] and CRAIG are +particularly well suited for this, as they use the Wasserstein distance between +a vendor's data and the buyer's to determine the value of the former. -Overall, valuation methods show promise for equitable pricing and curbing -adversarial behavior in data markets. But more research is still needed -on robust techniques suited for diverse real-world scenarios. +However, this is a complex problem which can face practical banal problems like +the fact that data owners may not wish to disclose their data for valuation. diff --git a/docs/value/index.md b/docs/value/index.md index 2440428d3..ac87a977f 100644 --- a/docs/value/index.md +++ b/docs/value/index.md @@ -83,33 +83,6 @@ among all samples, failing to identify repeated ones as unnecessary, with e.g. a zero value. -## Applications of data valuation - -Many applications are touted for data valuation, but the results can be -inconsistent. Values have a strong dependency on the training procedure and the -performance metric used. For instance, accuracy is a poor metric for imbalanced -sets and this has a stark effect on data values. Some models exhibit great -variance in some regimes and this again has a detrimental effect on values. - -Nevertheless, some of the most promising applications are: - -* Cleaning of corrupted data. -* Pruning unnecessary or irrelevant data. -* Repairing mislabeled data. -* Guiding data acquisition and annotation (active learning). -* Anomaly detection and model debugging and interpretation. - -Additionally, one of the motivating applications for the whole field is that of -data markets: a marketplace where data owners can sell their data to interested -parties. In this setting, data valuation can be key component to determine the -price of data. Algorithm-agnostic methods like LAVA [@just_lava_2023] are -particularly well suited for this, as they use the Wasserstein distance between -a vendor's data and the buyer's to determine the value of the former. - -However, this is a complex problem which can face practical banal problems like -the fact that data owners may not wish to disclose their data for valuation. - - ## Computing data values Using pyDVL to compute data values is a simple process that can be broken down diff --git a/src/pydvl/value/loo/naive.py b/src/pydvl/value/loo/naive.py deleted file mode 100644 index 82c12c730..000000000 --- a/src/pydvl/value/loo/naive.py +++ /dev/null @@ -1,19 +0,0 @@ -from deprecate import deprecated - -from pydvl.utils import Utility -from pydvl.value.result import ValuationResult - -from .loo import compute_loo - -__all__ = ["naive_loo"] - - -@deprecated( - target=compute_loo, - deprecated_in="0.7.0", - remove_in="0.8.0", - args_extra=dict(n_jobs=1), -) -def naive_loo(u: Utility, *, progress: bool = True, **kwargs) -> ValuationResult: # type: ignore - """Deprecated. Use [compute_loo][pydvl.value.loo.compute_loo] instead.""" - pass From 9a42b38e610704dbaeebf5929dcec45424de0eec Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 24 Jan 2024 18:25:44 +0100 Subject: [PATCH 84/87] Remove more deprecated code and warnings --- src/pydvl/parallel/futures/ray.py | 7 ---- src/pydvl/value/least_core/montecarlo.py | 2 - src/pydvl/value/least_core/naive.py | 4 +- src/pydvl/value/loo/__init__.py | 1 - src/pydvl/value/result.py | 13 ++----- src/pydvl/value/sampler.py | 9 ----- src/pydvl/value/shapley/montecarlo.py | 15 ++------ src/pydvl/value/shapley/truncated.py | 49 ------------------------ src/pydvl/value/stopping.py | 18 --------- 9 files changed, 8 insertions(+), 110 deletions(-) diff --git a/src/pydvl/parallel/futures/ray.py b/src/pydvl/parallel/futures/ray.py index 1a9658744..b15eef9e0 100644 --- a/src/pydvl/parallel/futures/ray.py +++ b/src/pydvl/parallel/futures/ray.py @@ -9,7 +9,6 @@ from weakref import WeakSet, ref import ray -from deprecate import deprecated from pydvl.parallel.config import ParallelConfig @@ -44,12 +43,6 @@ class RayExecutor(Executor): any. See [CancellationPolicy][pydvl.parallel.backend.CancellationPolicy] """ - @deprecated( - target=True, - deprecated_in="0.7.0", - remove_in="0.8.0", - args_mapping={"cancel_futures_on_exit": "cancel_futures"}, - ) def __init__( self, max_workers: Optional[int] = None, diff --git a/src/pydvl/value/least_core/montecarlo.py b/src/pydvl/value/least_core/montecarlo.py index 70a23b12d..5a7a3c883 100644 --- a/src/pydvl/value/least_core/montecarlo.py +++ b/src/pydvl/value/least_core/montecarlo.py @@ -59,8 +59,6 @@ def montecarlo_least_core( and to configure it. Refer to [cvxpy's documentation](https://www.cvxpy.org/tutorial/advanced/index.html#setting-solver-options) for all possible options. - options: (Deprecated) Dictionary of solver options. Use solver_options - instead. progress: If True, shows a tqdm progress bar seed: Either an instance of a numpy random number generator or a seed for it. diff --git a/src/pydvl/value/least_core/naive.py b/src/pydvl/value/least_core/naive.py index 08bb34efe..713298234 100644 --- a/src/pydvl/value/least_core/naive.py +++ b/src/pydvl/value/least_core/naive.py @@ -45,14 +45,12 @@ def exact_least_core( Args: u: Utility object with model, data, and scoring function - non_negative_subsidy: If True, the least core subsidy $e$ is constrained + non_negative_subsidy: If True, the least core subsidy $e$ is constrained to be non-negative. solver_options: Dictionary of options that will be used to select a solver and to configure it. Refer to the [cvxpy's documentation](https://www.cvxpy.org/tutorial/advanced/index.html#setting-solver-options) for all possible options. - options: (Deprecated) Dictionary of solver options. Use `solver_options` - instead. progress: If True, shows a tqdm progress bar Returns: diff --git a/src/pydvl/value/loo/__init__.py b/src/pydvl/value/loo/__init__.py index 6b9e972fc..93b927272 100644 --- a/src/pydvl/value/loo/__init__.py +++ b/src/pydvl/value/loo/__init__.py @@ -1,2 +1 @@ from .loo import * -from .naive import * diff --git a/src/pydvl/value/result.py b/src/pydvl/value/result.py index 20def1390..2773f9452 100644 --- a/src/pydvl/value/result.py +++ b/src/pydvl/value/result.py @@ -63,7 +63,6 @@ ) import numpy as np -from deprecate import deprecated from numpy.typing import NDArray from pydvl.utils.dataset import Dataset @@ -735,14 +734,6 @@ def from_random( return cls(**options) # type: ignore @classmethod - @deprecated( - target=True, - deprecated_in="0.6.0", - remove_in="0.8.0", - args_mapping=dict(indices=None, data_names=None, n_samples=None), - template_mgs="`%(source_name)s` is deprecated for generating zero-filled " - "results, use `ValuationResult.zeros()` instead.", - ) def empty( cls, algorithm: str = "", @@ -757,6 +748,10 @@ def empty( Args: algorithm: Name of the algorithm used to compute the values + indices: Optional sequence or array of indices. + data_names: Optional sequences or array of names for the data points. + Defaults to index numbers if not set. + n_samples: Number of valuation result entries. Returns: Object with the results. diff --git a/src/pydvl/value/sampler.py b/src/pydvl/value/sampler.py index ff360d154..08cabe372 100644 --- a/src/pydvl/value/sampler.py +++ b/src/pydvl/value/sampler.py @@ -65,7 +65,6 @@ ) import numpy as np -from deprecate import deprecated, void from numpy.typing import NDArray from pydvl.utils.numeric import powerset, random_subset, random_subset_of_size @@ -313,14 +312,6 @@ def weight(cls, n: int, subset_len: int) -> float: return float(2 ** (n - 1)) if n > 0 else 1.0 -class DeterministicCombinatorialSampler(DeterministicUniformSampler[IndexT]): - @deprecated( - target=DeterministicUniformSampler, deprecated_in="0.6.0", remove_in="0.8.0" - ) - def __init__(self, indices: NDArray[IndexT], *args, **kwargs): - void(indices, args, kwargs) - - class AntitheticSampler(StochasticSamplerMixin, PowersetSampler[IndexT]): """An iterator to perform uniform random sampling of subsets, and their complements. diff --git a/src/pydvl/value/shapley/montecarlo.py b/src/pydvl/value/shapley/montecarlo.py index aabc2d813..0811e648b 100644 --- a/src/pydvl/value/shapley/montecarlo.py +++ b/src/pydvl/value/shapley/montecarlo.py @@ -16,9 +16,9 @@ Alternatively, employing another reformulation of the expression above as a sum over permutations, one has the implementation in -[permutation_montecarlo_shapley()][pydvl.value.shapley.montecarlo.permutation_montecarlo_shapley], -or using an early stopping strategy to reduce computation -[truncated_montecarlo_shapley()][pydvl.value.shapley.truncated.truncated_montecarlo_shapley]. +[permutation_montecarlo_shapley()][pydvl.value.shapley.montecarlo.permutation_montecarlo_shapley] +with the option to pass an early stopping strategy to reduce computation +as done in Truncated MonteCarlo Shapley (TMCS). !!! info "Also see" It is also possible to use [group_testing_shapley()][pydvl.value.shapley.gt.group_testing_shapley] @@ -50,7 +50,6 @@ from typing import Optional, Sequence, Union import numpy as np -from deprecate import deprecated from numpy.random import SeedSequence from numpy.typing import NDArray from tqdm.auto import tqdm @@ -125,14 +124,6 @@ def _permutation_montecarlo_one_step( return result -@deprecated( - target=True, - deprecated_in="0.7.0", - remove_in="0.8.0", - args_mapping=dict( - coordinator_update_period=None, worker_update_period=None, progress=None - ), -) def permutation_montecarlo_shapley( u: Utility, done: StoppingCriterion, diff --git a/src/pydvl/value/shapley/truncated.py b/src/pydvl/value/shapley/truncated.py index 43327db0b..d62f625fa 100644 --- a/src/pydvl/value/shapley/truncated.py +++ b/src/pydvl/value/shapley/truncated.py @@ -11,7 +11,6 @@ from typing import Optional, cast import numpy as np -from deprecate import deprecated from pydvl.parallel.config import ParallelConfig from pydvl.utils import Utility, running_moments @@ -24,7 +23,6 @@ "FixedTruncation", "BootstrapTruncation", "RelativeTruncation", - "truncated_montecarlo_shapley", ] @@ -186,50 +184,3 @@ def _check(self, idx: int, score: float) -> bool: def reset(self, u: Optional[Utility] = None): self.count = 0 self.variance = self.mean = 0 - - -@deprecated( - target=True, - deprecated_in="0.7.0", - remove_in="0.8.0", - args_mapping=dict(coordinator_update_period=None, worker_update_period=None), -) -def truncated_montecarlo_shapley( - u: Utility, - *, - done: StoppingCriterion, - truncation: TruncationPolicy, - config: ParallelConfig = ParallelConfig(), - n_jobs: int = 1, - coordinator_update_period: int = 10, - worker_update_period: int = 5, -) -> ValuationResult: - """ - !!! Warning - This method is deprecated and only a wrapper for - [permutation_montecarlo_shapley][pydvl.value.shapley.montecarlo.permutation_montecarlo_shapley]. - - !!! Todo - Think of how to add Robin-Gelman or some other more principled stopping - criterion. - - Args: - u: Utility object with model, data, and scoring function - done: Check on the results which decides when to stop sampling - permutations. - truncation: callable that decides whether to stop computing marginals - for a given permutation. - config: Object configuring parallel computation, with cluster address, - number of cpus, etc. - n_jobs: Number of permutation monte carlo jobs to run concurrently. - Returns: - Object with the data values. - """ - from pydvl.value.shapley.montecarlo import permutation_montecarlo_shapley - - return cast( - ValuationResult, - permutation_montecarlo_shapley( - u, done=done, truncation=truncation, config=config, n_jobs=n_jobs - ), - ) diff --git a/src/pydvl/value/stopping.py b/src/pydvl/value/stopping.py index 4ce4b27e8..206cf630c 100644 --- a/src/pydvl/value/stopping.py +++ b/src/pydvl/value/stopping.py @@ -125,7 +125,6 @@ from typing import Callable, Optional, Protocol, Type import numpy as np -from deprecate import deprecated, void from numpy.typing import NDArray from pydvl.utils import Status @@ -135,7 +134,6 @@ "make_criterion", "AbsoluteStandardError", "StoppingCriterion", - "StandardError", "MaxChecks", "MaxUpdates", "MinUpdates", @@ -243,16 +241,6 @@ def converged(self) -> NDArray[np.bool_]: """ return self._converged - @property - def name(self): - log = logging.getLogger(__name__) - # This string for the benefit of deprecation searches: - # remove_in="0.8.0" - log.warning( - "The `name` attribute of `StoppingCriterion` is deprecated and will be removed in 0.8.0. " - ) - return getattr(self, "_name", type(self).__name__) - def __str__(self): return type(self).__name__ @@ -389,12 +377,6 @@ def __str__(self): return f"AbsoluteStandardError(threshold={self.threshold}, fraction={self.fraction}, burn_in={self.burn_in})" -class StandardError(AbsoluteStandardError): - @deprecated(target=AbsoluteStandardError, deprecated_in="0.6.0", remove_in="0.8.0") - def __init__(self, *args, **kwargs): - void(*args, **kwargs) - - class MaxChecks(StoppingCriterion): """Terminate as soon as the number of checks exceeds the threshold. From 67c5fb242d0319409ed20ca1b299cdab4903f670 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Wed, 24 Jan 2024 18:45:49 +0100 Subject: [PATCH 85/87] Adapt tests --- tests/test_results.py | 5 ----- tests/value/test_stopping.py | 18 +++++++++--------- 2 files changed, 9 insertions(+), 14 deletions(-) diff --git a/tests/test_results.py b/tests/test_results.py index 01870ec94..0b42fb48d 100644 --- a/tests/test_results.py +++ b/tests/test_results.py @@ -430,8 +430,3 @@ def test_empty(n): v2 = ValuationResult(values=np.arange(n)) v += v2 assert len(v2) == n - - -def test_empty_deprecation(): - with pytest.warns(DeprecationWarning): - v3 = ValuationResult.empty(indices=[1, 2, 3]) diff --git a/tests/value/test_stopping.py b/tests/value/test_stopping.py index 7399dc9c3..efebac9c4 100644 --- a/tests/value/test_stopping.py +++ b/tests/value/test_stopping.py @@ -62,10 +62,10 @@ def _check(self, result: ValuationResult) -> Status: assert (C() & C() & C())(v) == c assert (P() | P() | P())(v) == p - assert (C() & P()).name == "Composite StoppingCriterion: C AND P" - assert (C() | P()).name == "Composite StoppingCriterion: C OR P" - assert (~C()).name == "Composite StoppingCriterion: NOT C" - assert (~P()).name == "Composite StoppingCriterion: NOT P" + assert str(C() & P()) == "Composite StoppingCriterion: C AND P" + assert str(C() | P()) == "Composite StoppingCriterion: C OR P" + assert str(~C()) == "Composite StoppingCriterion: NOT C" + assert str(~P()) == "Composite StoppingCriterion: NOT P" def test_make_criterion(): @@ -88,9 +88,9 @@ def always_failed(result: ValuationResult) -> Status: assert P()(v) == Status.Pending assert F()(v) == Status.Failed - assert C().name == "always_converged" - assert P().name == "always_pending" - assert F().name == "always_failed" + assert str(C()) == "always_converged" + assert str(P()) == "always_pending" + assert str(F()) == "always_failed" assert (~C())(v) == Status.Failed assert (~P())(v) == Status.Converged @@ -104,7 +104,7 @@ def always_failed(result: ValuationResult) -> Status: def test_minmax_updates(): maxstop = MaxUpdates(10) - assert maxstop.name == "MaxUpdates" + assert str(maxstop) == "MaxUpdates(n_updates=10)" v = ValuationResult.from_random(5) v._counts = np.zeros(5) assert maxstop(v) == Status.Pending @@ -114,7 +114,7 @@ def test_minmax_updates(): assert maxstop(v) == Status.Converged minstop = MinUpdates(10) - assert minstop.name == "MinUpdates" + assert str(minstop) == "MinUpdates(n_updates=10)" v._counts = np.zeros(5) assert minstop(v) == Status.Pending v._counts += np.ones(5) * 9 From 9bac5c364e2119f441c611943e489e8a3dcb1731 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Fri, 26 Jan 2024 10:17:10 +0100 Subject: [PATCH 86/87] Update Changelog for release --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index c97101260..7b895d234 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,6 @@ # Changelog -## Unreleased +## 0.8.1 - 🆕 🏗 New method and noteboo, Games with exact shapley values, bug fixes and cleanup ### Added From 63753a230e9f74b87f5f30cd60d2b3c22c831864 Mon Sep 17 00:00:00 2001 From: Anes Benmerzoug Date: Fri, 26 Jan 2024 10:17:11 +0100 Subject: [PATCH 87/87] =?UTF-8?q?Bump=20version:=200.8.1.dev0=20=E2=86=92?= =?UTF-8?q?=200.8.1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .bumpversion.cfg | 2 +- setup.py | 2 +- src/pydvl/__init__.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.bumpversion.cfg b/.bumpversion.cfg index e6cb651b4..6d0944b7e 100644 --- a/.bumpversion.cfg +++ b/.bumpversion.cfg @@ -1,5 +1,5 @@ [bumpversion] -current_version = 0.8.1.dev0 +current_version = 0.8.1 commit = False tag = False allow_dirty = False diff --git a/setup.py b/setup.py index 37631787e..fd5d22229 100644 --- a/setup.py +++ b/setup.py @@ -12,7 +12,7 @@ package_data={"pydvl": ["py.typed"]}, packages=find_packages(where="src"), include_package_data=True, - version="0.8.1.dev0", + version="0.8.1", description="The Python Data Valuation Library", install_requires=[ line diff --git a/src/pydvl/__init__.py b/src/pydvl/__init__.py index 370991569..adcd959a3 100644 --- a/src/pydvl/__init__.py +++ b/src/pydvl/__init__.py @@ -7,4 +7,4 @@ The two main modules you will want to look at are [value][pydvl.value] and [influence][pydvl.influence]. """ -__version__ = "0.8.1.dev0" +__version__ = "0.8.1"