From ce6a83c98e5ad96f88ec5aa1aac8048d685e652f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cristian=20Mu=C3=B1oz?= <cristian.munoz@holisticai.com>
Date: Tue, 19 Nov 2024 10:11:50 -0500
Subject: [PATCH 01/34] Update Main Branch (#279)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* chore: update files for new gitflow (#227)

Bumps [actions/checkout](https://github.com/actions/checkout) from 4.1.7 to 4.2.2.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/v4.1.7...v4.2.2)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* chore(deps): bump actions/setup-python from 5.2.0 to 5.3.0 (#251)

Bumps [actions/setup-python](https://github.com/actions/setup-python) from 5.2.0 to 5.3.0.
- [Release notes](https://github.com/actions/setup-python/releases)
- [Commits](https://github.com/actions/setup-python/compare/v5.2.0...v5.3.0)

---
updated-dependencies:
- dependency-name: actions/setup-python
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* feat: New Robustness Regression Attacker: Ridge Poissoner (#241)

---------

Co-authored-by: Cristian Muñoz <cristian.munoz@holisticai.com>

* feat: new xai metrics based on globa feature importance, local feature importance and surrogate  (#255)
---------

Co-authored-by: Kleyton da Costa <kleyton.vsc@gmail.com>

* chore: Improve Accuracy Degradation Profile Documentation  (#249)

---------

Co-authored-by: crismunoz <crisstrink@gmail.com>

* docs:update tutorials (#257)

---------

Co-authored-by: crismunoz <crisstrink@gmail.com>

* add: bias tradeoff example (#266)

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: Kleyton da Costa <44351707+Kleyt0n@users.noreply.github.com>
Co-authored-by: andrelfnovaes <40208986+andrelfnovaes@users.noreply.github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Franklin Cardenoso <44931423+fracarfer5@users.noreply.github.com>
Co-authored-by: Kleyton da Costa <kleyton.vsc@gmail.com>
---
 docs/source/getting_started/datasets.rst     |    6 +-
 docs/source/getting_started/raw_datasets.csv |   27 +-
 docs/source/reference/datasets.rst           |    6 +-
 paper/paper.ipynb                            | 1604 ------------------
 pyproject.toml                               |    2 +
 src/holisticai/datasets/__init__.py          |   32 +-
 src/holisticai/datasets/_dataloaders.py      |  164 +-
 src/holisticai/datasets/_load_dataset.py     |  229 ++-
 8 files changed, 222 insertions(+), 1848 deletions(-)
 delete mode 100644 paper/paper.ipynb

diff --git a/docs/source/getting_started/datasets.rst b/docs/source/getting_started/datasets.rst
index 3656d8ab..ee732993 100644
--- a/docs/source/getting_started/datasets.rst
+++ b/docs/source/getting_started/datasets.rst
@@ -22,9 +22,9 @@ For example, if we want to load the Adult dataset, we can use the following code
 
 .. code-block:: python
 
-   from holisticai.datasets import load_adult
+    from holisticai.datasets import load_hai_datasets
     
-    data, target = load_adult(return_X_y=True)
+    data, target = load_hai_datasets(dataset_name="adult")
 
 .. _processed_datasets:
 
@@ -49,4 +49,4 @@ You can use this processed datasets using the function load_dataset from holisti
 
    from holisticai.datasets import load_dataset
     
-    dataset = load_dataset(dataset_name="adult", processed=True, protected_attribute="sex")
\ No newline at end of file
+    dataset = load_dataset(dataset_name="adult", preprocessed=True, protected_attribute="sex")
\ No newline at end of file
diff --git a/docs/source/getting_started/raw_datasets.csv b/docs/source/getting_started/raw_datasets.csv
index fab6c5bb..c9e5b02c 100644
--- a/docs/source/getting_started/raw_datasets.csv
+++ b/docs/source/getting_started/raw_datasets.csv
@@ -1,13 +1,14 @@
-Student,load_student,"Student performance dataset, used to predict students' grades based on various features."
-Adult,load_adult,"Adult dataset, used for income classification tasks based on census data."
-Law School,load_law_school,"Law school admission dataset, used to predict law school admission based on various features."
-Last FM,load_last_fm,"Last FM dataset, used for music recommendation tasks based on user listening history."
-US Crime,load_us_crime,"US Crime dataset, used to analyze and predict crime rates based on various socio-economic factors."
-Heart,load_heart,"Heart failure clinical records dataset, used to predict heart failure events based on clinical features."
-German Credit,load_german_credit,"German Credit dataset, used for credit risk classification based on financial and demographic factors."
-Census KDD,load_census_kdd,"Census KDD dataset, used for income prediction based on detailed census data."
-Bank Marketing,load_bank_marketing,"Bank Marketing dataset, used to predict whether a client will subscribe to a term deposit based on direct marketing campaigns."
-Compas,load_compas_two_year_recid/load_compas_is_recid,"COMPAS dataset, used for recidivism prediction and analyzing bias in criminal justice algorithms."
-Diabetes,load_diabetes,"Diabetes dataset, used for predicting the onset of diabetes based on health features."
-ACS Income,load_acsincome,"American Community Survey Income dataset, used to predict income levels based on demographic and socioeconomic data."
-ACS Public Coverage,load_acspublic,"American Community Survey Public Coverage dataset, used to analyze public health insurance coverage based on demographic data."
\ No newline at end of file
+Student,load_hai_dataset("student"),"Student performance dataset, used to predict students' grades based on various features."
+Adult,load_hai_dataset("adult"),"Adult dataset, used for income classification tasks based on census data."
+Law School,load_hai_dataset("law_school"),"Law school admission dataset, used to predict law school admission based on various features."
+Last FM,load_hai_dataset("lastfm"),"Last FM dataset, used for music recommendation tasks based on user listening history."
+US Crime,load_hai_dataset("us_crime"),"US Crime dataset, used to analyze and predict crime rates based on various socio-economic factors."
+Clinical Records,load_hai_dataset("clinical_records"),"Heart failure clinical records dataset, used to predict heart failure events based on clinical features."
+German Credit,load_hai_dataset("german_credit"),"German Credit dataset, used for credit risk classification based on financial and demographic factors."
+Census KDD,load_hai_dataset("census_kdd"),"Census KDD dataset, used for income prediction based on detailed census data."
+Bank Marketing,load_hai_dataset("bank_marketing"),"Bank Marketing dataset, used to predict whether a client will subscribe to a term deposit based on direct marketing campaigns."
+Compas,load_hai_dataset("compas_two_year_recid"),"COMPAS dataset, used for recidivism prediction and analyzing bias in criminal justice algorithms."
+Compas,load_hai_dataset("compas_is_recid"),"COMPAS dataset, used for recidivism prediction and analyzing bias in criminal justice algorithms."
+Diabetes,load_hai_dataset("diabetes"),"Diabetes dataset, used for predicting the onset of diabetes based on health features."
+ACS Income,load_hai_dataset("acsincome"),"American Community Survey Income dataset, used to predict income levels based on demographic and socioeconomic data."
+ACS Public Coverage,load_hai_dataset("acspublic"),"American Community Survey Public Coverage dataset, used to analyze public health insurance coverage based on demographic data."
\ No newline at end of file
diff --git a/docs/source/reference/datasets.rst b/docs/source/reference/datasets.rst
index ba5be5d6..b296070f 100644
--- a/docs/source/reference/datasets.rst
+++ b/docs/source/reference/datasets.rst
@@ -33,8 +33,4 @@
     :template: function.rst
     :toctree: .generated/
 
-    load_adult
-    load_last_fm
-    load_law_school
-    load_student
-    load_us_crime
\ No newline at end of file
+    load_hai_datasets
\ No newline at end of file
diff --git a/paper/paper.ipynb b/paper/paper.ipynb
deleted file mode 100644
index 3dec1ed5..00000000
--- a/paper/paper.ipynb
+++ /dev/null
@@ -1,1604 +0,0 @@
-{
-    "cells": [
-        {
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "# Regression"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 1,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "import sys\n",
-                "\n",
-                "sys.path.insert(0, \"/home/kleyton/hai/holisticai/src\")"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 2,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "from holisticai.datasets import load_dataset\n",
-                "from sklearn.metrics import mean_squared_error\n",
-                "\n",
-                "dataset = load_dataset('us_crime', preprocessed=False)\n",
-                "dataset = dataset.train_test_split(test_size=0.2, random_state=42)\n",
-                "train = dataset['train']\n",
-                "test = dataset['test']\n",
-                "\n",
-                "from sklearn.compose import ColumnTransformer\n",
-                "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n",
-                "from sklearn.pipeline import Pipeline\n",
-                "from sklearn.impute import SimpleImputer\n",
-                "from sklearn.model_selection import train_test_split\n",
-                "import pandas as pd\n",
-                "from sklearn.preprocessing import LabelEncoder\n",
-                "\n",
-                "numeric_features = train['X'].select_dtypes(exclude=['object']).columns.tolist()\n",
-                "categorical_features = train['X'].select_dtypes(include=['object']).columns.tolist()\n",
-                "preprocessor = ColumnTransformer(\n",
-                "    transformers=[\n",
-                "        ('num', StandardScaler(), numeric_features),\n",
-                "        #('cat', OneHotEncoder(sparse_output=False), categorical_features)\n",
-                "    ])\n",
-                "\n",
-                "def transform_to_df(pipeline, X, numeric_features, categorical_features, preprocessor):\n",
-                "    transformed_data = pipeline.transform(X)\n",
-                "    #ohe = preprocessor.named_transformers_['cat']\n",
-                "    #categorical_ohe_columns = ohe.get_feature_names_out(categorical_features).tolist()\n",
-                "    all_feature_names = numeric_features# + categorical_ohe_columns\n",
-                "    return pd.DataFrame(transformed_data, columns=all_feature_names)\n",
-                "pipeline = Pipeline(steps=[\n",
-                "    ('preprocessor', preprocessor)\n",
-                "])\n",
-                "pipeline.fit(train[\"X\"])\n",
-                "Xt_train = transform_to_df(pipeline, train[\"X\"], numeric_features, categorical_features, preprocessor)\n",
-                "Xt_test = transform_to_df(pipeline, test[\"X\"], numeric_features, categorical_features, preprocessor)\n",
-                "yt_train = train[\"y\"]\n",
-                "yt_test = test[\"y\"]"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 3,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "from sklearn.linear_model import LinearRegression, BayesianRidge\n",
-                "from sklearn.ensemble import RandomForestRegressor\n",
-                "from sklearn.neural_network import MLPRegressor\n",
-                "from holisticai.utils import RegressionProxy\n",
-                "\n",
-                "models = {}\n",
-                "\n",
-                "model = RandomForestRegressor(random_state=42)\n",
-                "model.fit(Xt_train, train['y'])\n",
-                "models[\"RandomForestRegressor\"] = RegressionProxy(predict=model.predict)\n",
-                "\n",
-                "model = BayesianRidge()\n",
-                "model.fit(Xt_train, train['y'])\n",
-                "models[\"BayesianRidge\"] = RegressionProxy(predict=model.predict)\n",
-                "\n",
-                "model = LinearRegression()\n",
-                "model.fit(Xt_train, train['y'])\n",
-                "models[\"LinearRegression\"] = RegressionProxy(predict=model.predict)\n",
-                "\n",
-                "model = MLPRegressor(hidden_layer_sizes=(300, 200), max_iter=2000, random_state=42, activation='relu')\n",
-                "model.fit(Xt_train, train['y'])\n",
-                "models[\"MLPRegressor\"] = RegressionProxy(predict=model.predict)"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "# Global Feature Importance Analysis"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 4,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "from utils import partial_dependence_oscilation,rank_alignment"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 5,
-            "metadata": {},
-            "outputs": [
-                {
-                    "name": "stderr",
-                    "output_type": "stream",
-                    "text": [
-                        "  0%|          | 0/4 [00:00<?, ?it/s]"
-                    ]
-                },
-                {
-                    "name": "stderr",
-                    "output_type": "stream",
-                    "text": [
-                        "100%|██████████| 4/4 [00:21<00:00,  5.45s/it]\n"
-                    ]
-                }
-            ],
-            "source": [
-                "import os\n",
-                "import importlib\n",
-                "import holisticai.utils.feature_importances as feature_importances\n",
-                "importlib.reload(sys.modules['holisticai.utils.feature_importances'])\n",
-                "from holisticai.utils.inspection import compute_partial_dependence\n",
-                "from holisticai.explainability.metrics import spread_divergence, alpha_score\n",
-                "from sklearn.metrics import f1_score\n",
-                "import pandas as pd\n",
-                "from tqdm import tqdm\n",
-                "\n",
-                "top_n = 8\n",
-                "results = {}\n",
-                "for model_name,proxy in tqdm(models.items()):\n",
-                "    importances  = feature_importances.compute_permutation_feature_importance(X=Xt_test, y=yt_test, proxy=proxy, n_repeats=5)\n",
-                "    top_feature_names = list(importances.as_dataframe().sort_values('Importance', ascending=False).head(top_n).Variable)\n",
-                "    conditional_feature_importances  = feature_importances.compute_permutation_feature_importance(X=Xt_test, y=yt_test, proxy=proxy, importance_type=\"conditional\", n_repeats=5)\n",
-                "    partial_dependencies = compute_partial_dependence(Xt_test, features=top_feature_names[:top_n], proxy=proxy)\n",
-                "    results[model_name] = {\n",
-                "        'importances':importances,\n",
-                "        'conditional_feature_importances':conditional_feature_importances,\n",
-                "        'partial_dependencies':partial_dependencies\n",
-                "    }"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 9,
-            "metadata": {},
-            "outputs": [
-                {
-                    "name": "stderr",
-                    "output_type": "stream",
-                    "text": [
-                        "100%|██████████| 4/4 [00:00<00:00, 20.74it/s]\n"
-                    ]
-                }
-            ],
-            "source": [
-                "import sys\n",
-                "sys.path.insert(0, \"/home/kcosta/repos/hai/holisticai/tutorials/explainability/demos\")\n",
-                "\n",
-                "from holisticai.utils.feature_importances import compute_permutation_feature_importance\n",
-                "from holisticai.utils.inspection import compute_partial_dependence\n",
-                "from holisticai.explainability.metrics import spread_divergence, alpha_score,xai_ease_score\n",
-                "import pandas as pd\n",
-                "from tqdm import tqdm\n",
-                "from metric_utils import partial_dependence_oscilation, rank_alignment\n",
-                "importlib.reload(sys.modules['metric_utils'])\n",
-                "from holisticai.utils import Importances\n",
-                "\n",
-                "model_metrics = {}\n",
-                "for model_name,result in tqdm(results.items()):\n",
-                "    importances  = result['importances']\n",
-                "    conditional_feature_importances  = result['conditional_feature_importances']\n",
-                "    partial_dependencies = result['partial_dependencies']\n",
-                "    acc = mean_squared_error(yt_test, models[model_name].predict(Xt_test))\n",
-                "    metrics  = pd.DataFrame(index=['Alpha Score', 'Spread Divergence', 'Fluctuation Ratio', 'XAI Ease', 'Rank Alignment', 'MSE'], columns=['Value', 'Reference'])\n",
-                "    metrics.at['Alpha Score','Value'] = alpha_score(importances)\n",
-                "    metrics.at['Alpha Score','Reference'] = 0\n",
-                "    metrics.at['Spread Divergence','Value'] = 1 - spread_divergence(importances)\n",
-                "    metrics.at['Spread Divergence','Reference'] = 1\n",
-                "    metrics.at['Fluctuation Ratio','Value'] = partial_dependence_oscilation(partial_dependencies, importances, top_n=top_n)\n",
-                "    metrics.at['Fluctuation Ratio','Reference'] = 0\n",
-                "    imp = Importances(values=importances.as_dataframe().Importance.values[:top_n], feature_names=importances.as_dataframe().Variable.values[:top_n])\n",
-                "    metrics.at['XAI Ease','Value'] = xai_ease_score(partial_dependencies, imp)\n",
-                "    metrics.at['XAI Ease','Reference'] = 0\n",
-                "    metrics.at['Rank Alignment','Value'] = rank_alignment(conditional_feature_importances, importances)\n",
-                "    metrics.at['Rank Alignment','Reference'] = 1\n",
-                "    metrics.at['MSE','Value'] = acc\n",
-                "    metrics.at['MSE','Reference'] = 0\n",
-                "    model_metrics[model_name] = metrics"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 10,
-            "metadata": {},
-            "outputs": [
-                {
-                    "name": "stdout",
-                    "output_type": "stream",
-                    "text": [
-                        "\\begin{tabular}{llllll}\n",
-                        "\\toprule\n",
-                        " & RandomForestRegressor & BayesianRidge & LinearRegression & MLPRegressor & Reference \\\\\n",
-                        "\\midrule\n",
-                        "MSE & 0.0198 & 0.0186 & 0.0190 & 0.0311 & 0 \\\\\n",
-                        "Spread Divergence & 0.7174 & 0.5789 & 0.6733 & 0.3125 & 1 \\\\\n",
-                        "Fluctuation Ratio & 0.3074 & 0.0000 & 0.0000 & 0.0280 & 0 \\\\\n",
-                        "Rank Alignment & 0.1960 & 0.3915 & 0.7056 & 0.4040 & 1 \\\\\n",
-                        "\\bottomrule\n",
-                        "\\end{tabular}\n",
-                        "\n"
-                    ]
-                }
-            ],
-            "source": [
-                "from holisticai.utils import concatenate_metrics\n",
-                "metric_names = [\"MSE\", \"Spread Divergence\",\t\"Fluctuation Ratio\", \"Rank Alignment\"]\n",
-                "print(concatenate_metrics(model_metrics).loc[metric_names].to_latex(float_format=\"%.4f\"))"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 11,
-            "metadata": {},
-            "outputs": [
-                {
-                    "data": {
-                        "text/html": [
-                            "<div>\n",
-                            "<style scoped>\n",
-                            "    .dataframe tbody tr th:only-of-type {\n",
-                            "        vertical-align: middle;\n",
-                            "    }\n",
-                            "\n",
-                            "    .dataframe tbody tr th {\n",
-                            "        vertical-align: top;\n",
-                            "    }\n",
-                            "\n",
-                            "    .dataframe thead th {\n",
-                            "        text-align: right;\n",
-                            "    }\n",
-                            "</style>\n",
-                            "<table border=\"1\" class=\"dataframe\">\n",
-                            "  <thead>\n",
-                            "    <tr style=\"text-align: right;\">\n",
-                            "      <th></th>\n",
-                            "      <th>RandomForestRegressor</th>\n",
-                            "      <th>BayesianRidge</th>\n",
-                            "      <th>LinearRegression</th>\n",
-                            "      <th>MLPRegressor</th>\n",
-                            "      <th>Reference</th>\n",
-                            "    </tr>\n",
-                            "  </thead>\n",
-                            "  <tbody>\n",
-                            "    <tr>\n",
-                            "      <th>Alpha Score</th>\n",
-                            "      <td>0.089109</td>\n",
-                            "      <td>0.237624</td>\n",
-                            "      <td>0.158416</td>\n",
-                            "      <td>0.524752</td>\n",
-                            "      <td>0</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>Spread Divergence</th>\n",
-                            "      <td>0.717439</td>\n",
-                            "      <td>0.578866</td>\n",
-                            "      <td>0.67329</td>\n",
-                            "      <td>0.312462</td>\n",
-                            "      <td>1</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>Fluctuation Ratio</th>\n",
-                            "      <td>0.307422</td>\n",
-                            "      <td>0.0</td>\n",
-                            "      <td>0.0</td>\n",
-                            "      <td>0.028033</td>\n",
-                            "      <td>0</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>XAI Ease</th>\n",
-                            "      <td>0.9375</td>\n",
-                            "      <td>1.0</td>\n",
-                            "      <td>1.0</td>\n",
-                            "      <td>0.9375</td>\n",
-                            "      <td>0</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>Rank Alignment</th>\n",
-                            "      <td>0.196023</td>\n",
-                            "      <td>0.391477</td>\n",
-                            "      <td>0.705556</td>\n",
-                            "      <td>0.40398</td>\n",
-                            "      <td>1</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>MSE</th>\n",
-                            "      <td>0.019849</td>\n",
-                            "      <td>0.018593</td>\n",
-                            "      <td>0.019026</td>\n",
-                            "      <td>0.031063</td>\n",
-                            "      <td>0</td>\n",
-                            "    </tr>\n",
-                            "  </tbody>\n",
-                            "</table>\n",
-                            "</div>"
-                        ],
-                        "text/plain": [
-                            "                  RandomForestRegressor BayesianRidge LinearRegression  \\\n",
-                            "Alpha Score                    0.089109      0.237624         0.158416   \n",
-                            "Spread Divergence              0.717439      0.578866          0.67329   \n",
-                            "Fluctuation Ratio              0.307422           0.0              0.0   \n",
-                            "XAI Ease                         0.9375           1.0              1.0   \n",
-                            "Rank Alignment                 0.196023      0.391477         0.705556   \n",
-                            "MSE                            0.019849      0.018593         0.019026   \n",
-                            "\n",
-                            "                  MLPRegressor Reference  \n",
-                            "Alpha Score           0.524752         0  \n",
-                            "Spread Divergence     0.312462         1  \n",
-                            "Fluctuation Ratio     0.028033         0  \n",
-                            "XAI Ease                0.9375         0  \n",
-                            "Rank Alignment         0.40398         1  \n",
-                            "MSE                   0.031063         0  "
-                        ]
-                    },
-                    "execution_count": 11,
-                    "metadata": {},
-                    "output_type": "execute_result"
-                }
-            ],
-            "source": [
-                "concatenate_metrics(model_metrics)"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 12,
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "import matplotlib.pyplot as plt\n",
-                "import numpy as np\n",
-                "\n",
-                "def plot_feature_importance_contrast(model_name, importances, conditional_feature_importances):\n",
-                "    feature_names = []\n",
-                "    for name, cimp in conditional_feature_importances.values.items():\n",
-                "        feature_names += cimp.top_alpha().feature_names\n",
-                "    feature_names = sorted(set(feature_names))[:10]\n",
-                "    \n",
-                "    # Prepare dataframes\n",
-                "    imp_df = importances.as_dataframe().set_index('Variable').rename({'Importance': \"Overall\"}, axis=1).loc[feature_names]\n",
-                "    cimp_df = [cimp.as_dataframe().set_index('Variable').rename({\"Importance\": f\"label={name}\"}, axis=1).loc[feature_names] for name, cimp in conditional_feature_importances.values.items()]\n",
-                "    all_df = pd.concat([imp_df, *cimp_df], axis=1).sort_values(by='Overall', ascending=False)\n",
-                "\n",
-                "    # Set bar width and the number of bars\n",
-                "    width = 0.5  # Width of each bar\n",
-                "    num_columns = len(all_df.columns)  # Number of columns to plot\n",
-                "\n",
-                "    # Create figure and primary axis\n",
-                "    #fig, ax1 = plt.subplots(figsize=(30, 6), dpi=200)\n",
-                "\n",
-                "    # Plot each set of bars with different positions\n",
-                "    x = np.arange(len(all_df))  # Position for each feature\n",
-                "\n",
-                "    # Plot conditional importances and Overall importance\n",
-                "    for i, col in enumerate(all_df.columns):  # Exclude the last column (Fluctuation Ratio)\n",
-                "        # stacked bar chart for class\n",
-                "        if i == 0:\n",
-                "            data = all_df[col]\n",
-                "            plt.bar(x, all_df[col], width=width, label=col, bottom=0)\n",
-                "        else:\n",
-                "            plt.bar(x, all_df[col], width=width, label=col, bottom=data)\n",
-                "            data += all_df[col]\n",
-                "\n",
-                "    # Set axis labels and title\n",
-                "    plt.xlabel('Features')\n",
-                "    plt.ylabel('Importance')\n",
-                "    plt.title(f'[{model_name}]')\n",
-                "    plt.tick_params(axis='x', rotation=90)\n",
-                "    plt.xticks(x, labels=all_df.index)\n",
-                "\n",
-                "    plt.legend()\n",
-                "    plt.tight_layout()\n",
-                "    plt.tight_layout()"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 13,
-            "metadata": {},
-            "outputs": [
-                {
-                    "data": {
-                        "image/png": "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",
-                        "text/plain": [
-                            "<Figure size 1500x1200 with 4 Axes>"
-                        ]
-                    },
-                    "metadata": {},
-                    "output_type": "display_data"
-                }
-            ],
-            "source": [
-                "import os\n",
-                "import matplotlib.pyplot as plt\n",
-                "#from utils import plot_feature_importance_contrast\n",
-                "\n",
-                "plt.figure(figsize=(15, 12))\n",
-                "for i,(model_name, result) in enumerate(results.items()):\n",
-                "    os.makedirs(model_name, exist_ok=True)\n",
-                "    importances = result['importances']\n",
-                "    conditional_feature_importances = result['conditional_feature_importances']\n",
-                "    proxy=models[model_name]\n",
-                "    plt.subplot(2,2,i+1)\n",
-                "    plot_feature_importance_contrast(model_name, importances, conditional_feature_importances)\n",
-                "plt.savefig(f\"feature_importance_contrast.png\")"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 15,
-            "metadata": {},
-            "outputs": [
-                {
-                    "data": {
-                        "image/png": "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",
-                        "text/plain": [
-                            "<Figure size 2000x500 with 8 Axes>"
-                        ]
-                    },
-                    "metadata": {},
-                    "output_type": "display_data"
-                }
-            ],
-            "source": [
-                "# def plot_feature_importance_partial_dependencies_oscillation(model_name, df, top_n=None):#, figsize=None):\n",
-                "#     if top_n is not None:\n",
-                "#         df = df.iloc[:top_n]\n",
-                "#     # Create positions for the bars\n",
-                "#     features = df['Variable']\n",
-                "#     x_pos = np.arange(len(features))\n",
-                "#     # Create horizontal lollipop chart\n",
-                "#     plt.hlines(y=range(len(df)), xmin=0, xmax=df['Importance'], color='#5B7BE9', alpha=0.7, linewidth=2)\n",
-                "#     plt.plot(df['Importance'], range(len(df)), \"o\", markersize=8, color='#5B7BE9', alpha=0.8)\n",
-                "#     # Add oscillation markers\n",
-                "#     # Customize the plot\n",
-                "#     plt.yticks(range(len(df)), df['Variable'])\n",
-                "#     plt.xlabel('Value', fontsize=12)\n",
-                "#     # Add a second x-axis for oscillation\n",
-                "#     plt.gca().invert_yaxis()\n",
-                "#     ax1 = plt.gca()\n",
-                "#     ax2 = ax1.twiny()\n",
-                "#     ax2.plot(df['Oscillation'], range(len(df)), \"D\", markersize=7, color='#47B39C', alpha=0.8)\n",
-                "#     ax2.set_xlim(-0.1, 1)\n",
-                "\n",
-                "#     #ax2.set_xlim(ax1.get_xlim())\n",
-                "#     # Set labels and titles\n",
-                "#     ax1.set_xlabel('Importance', color='#5B7BE9', fontsize=12)\n",
-                "#     ax2.set_xlabel('PD Oscillation', color='#47B39C', fontsize=12)\n",
-                "#     plt.title(f'{model_name}', fontsize=14, pad=20)\n",
-                "#     ax2.grid(False)\n",
-                "#     # Add legend\n",
-                "#     from matplotlib.lines import Line2D\n",
-                "#     legend_elements = [\n",
-                "#         Line2D([0], [0], marker='o', color='#5B7BE9', label='Importance',\n",
-                "#             markerfacecolor='#5B7BE9', markersize=8, linewidth=2),\n",
-                "#         Line2D([0], [0], marker='D', color='#47B39C', label='Oscillation',\n",
-                "#             markerfacecolor='#47B39C', markersize=7, linestyle='None')\n",
-                "#     ]\n",
-                "#     ax1.legend(handles=legend_elements, loc='lower right')\n",
-                "\n",
-                "#def get_importance_oscillation_table(partial_dependencies, ranked_importances):\n",
-                "#    ocilations = partial_dependence_oscilation(partial_dependencies, aggregated=False)\n",
-                "#    idf = ranked_importances.as_dataframe().set_index('Variable')\n",
-                "#    odf = pd.DataFrame(ocilations, index=partial_dependencies.feature_names, columns=['Oscillation'])\n",
-                "#    return pd.concat([idf, odf], axis=1).reset_index().rename({'index': 'Variable'}, axis=1).sort_values(by='Importance', ascending=False)\n",
-                "\n",
-                "import matplotlib.pyplot as plt\n",
-                "from metric_utils import get_importance_oscillation_table\n",
-                "from plot_utils import plot_feature_importance_partial_dependencies_oscillation\n",
-                "importlib.reload(sys.modules['plot_utils'])\n",
-                "#from utils import get_importance_oscillation_table\n",
-                "plt.style.use('ggplot')\n",
-                "plt.rcParams.update({'font.size': 12})\n",
-                "plt.figure(figsize=(20, 5))\n",
-                "\n",
-                "for i,(model_name, result) in enumerate(results.items()):\n",
-                "    df = get_importance_oscillation_table(result['partial_dependencies'], result['importances'], top_n=top_n)\n",
-                "    plt.subplot(1,4,i+1)\n",
-                "    plot_feature_importance_partial_dependencies_oscillation(model_name, df, top_n=10)\n",
-                "plt.tight_layout()\n",
-                "plt.savefig('feature_importance.pdf')"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 16,
-            "metadata": {},
-            "outputs": [
-                {
-                    "data": {
-                        "image/png": "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",
-                        "text/plain": [
-                            "<Figure size 2000x500 with 5 Axes>"
-                        ]
-                    },
-                    "metadata": {},
-                    "output_type": "display_data"
-                },
-                {
-                    "data": {
-                        "image/png": "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",
-                        "text/plain": [
-                            "<Figure size 2000x500 with 5 Axes>"
-                        ]
-                    },
-                    "metadata": {},
-                    "output_type": "display_data"
-                },
-                {
-                    "data": {
-                        "image/png": "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",
-                        "text/plain": [
-                            "<Figure size 2000x500 with 5 Axes>"
-                        ]
-                    },
-                    "metadata": {},
-                    "output_type": "display_data"
-                },
-                {
-                    "data": {
-                        "image/png": "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",
-                        "text/plain": [
-                            "<Figure size 2000x500 with 5 Axes>"
-                        ]
-                    },
-                    "metadata": {},
-                    "output_type": "display_data"
-                }
-            ],
-            "source": [
-                "from holisticai.explainability.plots import plot_feature_importance\n",
-                "import os\n",
-                "import matplotlib.pyplot as plt\n",
-                "importlib.reload(sys.modules['plot_utils'])\n",
-                "from plot_utils import plot_partial_dependence_with_std, plot_partial_dependence_oscilation\n",
-                "for model_name, result in results.items():\n",
-                "    partial_dependencies = result['partial_dependencies']\n",
-                "    #partial_dependencies.feature_names = [index2featurenames[i] for i in partial_dependencies.feature_names]\n",
-                "    importances = result['importances']\n",
-                "    #importances.feature_names = [index2featurenames[i] for i in importances.feature_names]\n",
-                "    df = get_importance_oscillation_table(partial_dependencies, importances, top_n=top_n)\n",
-                "    os.makedirs(model_name, exist_ok=True)\n",
-                "    plot_partial_dependence_with_std(partial_dependencies, feature_names=df['Variable'].values, top_n=5)\n",
-                "    plt.savefig(os.path.join(model_name, 'partial_dependence.png'))\n",
-                "    #plot_partial_dependence_oscilation(result['partial_dependencies'], feature_names=df['Variable'].values)\n",
-                "    #plt.savefig(os.path.join(model_name, 'partial_dependence_oscilation.png'))"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "# Local Feature Importance Analysis"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 17,
-            "metadata": {},
-            "outputs": [
-                {
-                    "name": "stderr",
-                    "output_type": "stream",
-                    "text": [
-                        "PermutationExplainer explainer: 1595it [04:53,  5.29it/s]                          \n",
-                        "PermutationExplainer explainer: 1595it [00:53, 23.32it/s]                          \n",
-                        "PermutationExplainer explainer: 1595it [01:00, 21.24it/s]                          \n",
-                        "PermutationExplainer explainer: 1595it [20:26,  1.28it/s]                             \n"
-                    ]
-                }
-            ],
-            "source": [
-                "from holisticai.utils.feature_importances import compute_shap_feature_importance\n",
-                "from utils import feature_rank_stability, feature_importance_stability\n",
-                "X = Xt_train\n",
-                "\n",
-                "local_model_metrics = {}\n",
-                "local_results = {}\n",
-                "for model_name,model in models.items():\n",
-                "    local_importances = compute_shap_feature_importance(X=X, proxy=model, max_samples=1000, random_state=42)\n",
-                "    local_conditional_importances = local_importances.conditional()\n",
-                "    importances = local_importances.to_global()\n",
-                "    conditional_importances = local_conditional_importances.to_global()\n",
-                "\n",
-                "    metrics  = pd.DataFrame(index=['Feature Rank Stability', 'Feature Importance Stability'], columns=['Value', 'Reference'])\n",
-                "    metrics.at['Feature Rank Stability','Value'] = feature_rank_stability(local_importances.values)\n",
-                "    metrics.at['Feature Rank Stability','Reference'] = 0\n",
-                "\n",
-                "    metrics.at['Feature Importance Stability','Value'] = feature_importance_stability(local_importances.values)\n",
-                "    metrics.at['Feature Importance Stability','Reference'] = 0\n",
-                "    local_model_metrics[model_name] = metrics\n",
-                "    local_results[model_name] = {'importances':importances, 'conditional_importances':conditional_importances, 'local_importances':local_importances, 'local_conditional_importances':local_conditional_importances}"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 18,
-            "metadata": {},
-            "outputs": [
-                {
-                    "name": "stdout",
-                    "output_type": "stream",
-                    "text": [
-                        "\\begin{tabular}{llllll}\n",
-                        "\\toprule\n",
-                        " & RandomForestRegressor & BayesianRidge & LinearRegression & MLPRegressor & Reference \\\\\n",
-                        "\\midrule\n",
-                        "Feature Rank Stability & 0.7893 & 0.8184 & 0.8364 & 0.7215 & 0 \\\\\n",
-                        "Feature Importance Stability & 0.9972 & 0.9944 & 0.9825 & 0.9825 & 0 \\\\\n",
-                        "\\bottomrule\n",
-                        "\\end{tabular}\n",
-                        "\n"
-                    ]
-                }
-            ],
-            "source": [
-                "metric_names = [\"Feature Rank Stability\",\t\"Feature Importance Stability\"]\n",
-                "from holisticai.utils import concatenate_metrics\n",
-                "print(concatenate_metrics(local_model_metrics).loc[metric_names].to_latex(float_format=\"%.4f\"))"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 19,
-            "metadata": {},
-            "outputs": [
-                {
-                    "name": "stdout",
-                    "output_type": "stream",
-                    "text": [
-                        "\\begin{tabular}{lll}\n",
-                        "\\toprule\n",
-                        " & Feature Rank Stability & Feature Importance Stability \\\\\n",
-                        "\\midrule\n",
-                        "RandomForestRegressor & 0.789 & 0.997 \\\\\n",
-                        "BayesianRidge & 0.818 & 0.994 \\\\\n",
-                        "LinearRegression & 0.836 & 0.983 \\\\\n",
-                        "MLPRegressor & 0.722 & 0.982 \\\\\n",
-                        "\\bottomrule\n",
-                        "\\end{tabular}\n",
-                        "\n"
-                    ]
-                }
-            ],
-            "source": [
-                "model_names = ['RandomForestRegressor', 'BayesianRidge', 'LinearRegression', 'MLPRegressor']\n",
-                "metric_names = [\"Feature Rank Stability\",\t\"Feature Importance Stability\"]\n",
-                "print(concatenate_metrics(local_model_metrics).T.loc[model_names, metric_names].to_latex(float_format=\"%.3f\"))"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 20,
-            "metadata": {},
-            "outputs": [
-                {
-                    "data": {
-                        "image/png": "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",
-                        "text/plain": [
-                            "<Figure size 640x480 with 1 Axes>"
-                        ]
-                    },
-                    "metadata": {},
-                    "output_type": "display_data"
-                }
-            ],
-            "source": [
-                "data = local_results['LinearRegression']['local_importances'].data.sort_values(by=('Metadata', 'y'), ascending=False).DataFrame\n",
-                "\n",
-                "\n",
-                "import matplotlib.pyplot as plt\n",
-                "import numpy as np\n",
-                "\n",
-                "from collections import Counter\n",
-                "\n",
-                "\n",
-                "def feature_rank_stability(local_importances):\n",
-                "    \"\"\"\n",
-                "    Calculates the rank stability (RSt) for a set of ranked features derived from local feature importances.\n",
-                "    Args:\n",
-                "        local_importances (np.array): A matrix of shape (M, d), where M is the number of samples\n",
-                "                                      and d is the number of features. Each entry represents the importance of a feature in a sample.\n",
-                "    Returns:\n",
-                "        float: The rank stability (RSt) value between 0 and 1.\n",
-                "    \"\"\"\n",
-                "    # Convert local importances to rankings (higher importance gets a lower rank)\n",
-                "    ranked_features = np.argsort(-local_importances, axis=1)  # Sort each row in descending order, giving ranks\n",
-                "    # Number of iterations\n",
-                "    n = len(ranked_features)\n",
-                "    # Flatten the ranked features list and get the unique features\n",
-                "    unique_features = list(set([feature for iteration in ranked_features for feature in iteration]))\n",
-                "    # Initialize a dictionary to store ranks for each feature\n",
-                "    feature_ranks = {feature: [] for feature in unique_features}\n",
-                "    # Populate ranks for each feature\n",
-                "    for iteration in ranked_features:\n",
-                "        for rank, feature in enumerate(iteration, start=1):\n",
-                "            feature_ranks[feature].append(rank)\n",
-                "    # Calculate rank stability for each feature\n",
-                "    def rank_stability(feature_rankings):\n",
-                "        if len(feature_rankings) == 1:\n",
-                "            return 1.0  # If a feature is ranked only once, its stability is maximal\n",
-                "        # Find the most frequent (consistent) rank\n",
-                "        rank_counter = Counter(feature_rankings)\n",
-                "        most_frequent_rank = rank_counter.most_common(1)[0][0]\n",
-                "        # Calculate actual deviation (sum of absolute differences from the most frequent rank)\n",
-                "        actual_deviation = sum(abs(rank - most_frequent_rank) for rank in feature_rankings)\n",
-                "        # Calculate maximum deviation\n",
-                "        max_deviation = len(feature_rankings) * (max(feature_rankings) - min(feature_rankings))\n",
-                "        if max_deviation == 0:\n",
-                "            return 1.0  # If there's no variation, stability is maximal\n",
-                "        # Calculate and return rank stability\n",
-                "        return 1 - (actual_deviation / max_deviation)\n",
-                "    # Calculate overall rank stability for the system\n",
-                "    data = {feature:rank_stability(feature_ranks[feature]) for feature in unique_features}\n",
-                "    return pd.DataFrame(data, index=[0]).T.reset_index().rename({'index':'Feature', 0:'Rank Stability'}, axis=1)\n",
-                "\n",
-                "data_res = pd.DataFrame()\n",
-                "for model in local_results:\n",
-                "    data = feature_rank_stability(local_results[model]['local_importances'].values)\n",
-                "    data_res[model] = data['Rank Stability']\n",
-                "    data_res['Feature'+ model] = data['Feature']\n",
-                "    plt.plot(data['Rank Stability'], label=model)\n",
-                "    plt.legend()"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 21,
-            "metadata": {},
-            "outputs": [
-                {
-                    "data": {
-                        "text/html": [
-                            "<div>\n",
-                            "<style scoped>\n",
-                            "    .dataframe tbody tr th:only-of-type {\n",
-                            "        vertical-align: middle;\n",
-                            "    }\n",
-                            "\n",
-                            "    .dataframe tbody tr th {\n",
-                            "        vertical-align: top;\n",
-                            "    }\n",
-                            "\n",
-                            "    .dataframe thead th {\n",
-                            "        text-align: right;\n",
-                            "    }\n",
-                            "</style>\n",
-                            "<table border=\"1\" class=\"dataframe\">\n",
-                            "  <thead>\n",
-                            "    <tr style=\"text-align: right;\">\n",
-                            "      <th></th>\n",
-                            "      <th>RandomForestRegressor</th>\n",
-                            "      <th>FeatureRandomForestRegressor</th>\n",
-                            "      <th>BayesianRidge</th>\n",
-                            "      <th>FeatureBayesianRidge</th>\n",
-                            "      <th>LinearRegression</th>\n",
-                            "      <th>FeatureLinearRegression</th>\n",
-                            "      <th>MLPRegressor</th>\n",
-                            "      <th>FeatureMLPRegressor</th>\n",
-                            "      <th>Mean</th>\n",
-                            "    </tr>\n",
-                            "  </thead>\n",
-                            "  <tbody>\n",
-                            "    <tr>\n",
-                            "      <th>0</th>\n",
-                            "      <td>0.886961</td>\n",
-                            "      <td>0</td>\n",
-                            "      <td>0.809516</td>\n",
-                            "      <td>0</td>\n",
-                            "      <td>0.796638</td>\n",
-                            "      <td>0</td>\n",
-                            "      <td>0.726154</td>\n",
-                            "      <td>0</td>\n",
-                            "      <td>0.402409</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>1</th>\n",
-                            "      <td>0.773539</td>\n",
-                            "      <td>1</td>\n",
-                            "      <td>0.756530</td>\n",
-                            "      <td>1</td>\n",
-                            "      <td>0.824473</td>\n",
-                            "      <td>1</td>\n",
-                            "      <td>0.762014</td>\n",
-                            "      <td>1</td>\n",
-                            "      <td>0.889570</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>2</th>\n",
-                            "      <td>0.783894</td>\n",
-                            "      <td>2</td>\n",
-                            "      <td>0.895437</td>\n",
-                            "      <td>2</td>\n",
-                            "      <td>0.909126</td>\n",
-                            "      <td>2</td>\n",
-                            "      <td>0.749699</td>\n",
-                            "      <td>2</td>\n",
-                            "      <td>1.417269</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>3</th>\n",
-                            "      <td>0.809408</td>\n",
-                            "      <td>3</td>\n",
-                            "      <td>0.807760</td>\n",
-                            "      <td>3</td>\n",
-                            "      <td>0.848144</td>\n",
-                            "      <td>3</td>\n",
-                            "      <td>0.752215</td>\n",
-                            "      <td>3</td>\n",
-                            "      <td>1.902191</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>4</th>\n",
-                            "      <td>0.940127</td>\n",
-                            "      <td>4</td>\n",
-                            "      <td>0.933516</td>\n",
-                            "      <td>4</td>\n",
-                            "      <td>0.826899</td>\n",
-                            "      <td>4</td>\n",
-                            "      <td>0.787372</td>\n",
-                            "      <td>4</td>\n",
-                            "      <td>2.435989</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>...</th>\n",
-                            "      <td>...</td>\n",
-                            "      <td>...</td>\n",
-                            "      <td>...</td>\n",
-                            "      <td>...</td>\n",
-                            "      <td>...</td>\n",
-                            "      <td>...</td>\n",
-                            "      <td>...</td>\n",
-                            "      <td>...</td>\n",
-                            "      <td>...</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>96</th>\n",
-                            "      <td>0.761747</td>\n",
-                            "      <td>96</td>\n",
-                            "      <td>0.799330</td>\n",
-                            "      <td>96</td>\n",
-                            "      <td>0.839384</td>\n",
-                            "      <td>96</td>\n",
-                            "      <td>0.773237</td>\n",
-                            "      <td>96</td>\n",
-                            "      <td>48.396712</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>97</th>\n",
-                            "      <td>0.797894</td>\n",
-                            "      <td>97</td>\n",
-                            "      <td>0.921654</td>\n",
-                            "      <td>97</td>\n",
-                            "      <td>0.945870</td>\n",
-                            "      <td>97</td>\n",
-                            "      <td>0.764912</td>\n",
-                            "      <td>97</td>\n",
-                            "      <td>48.928791</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>98</th>\n",
-                            "      <td>0.785695</td>\n",
-                            "      <td>98</td>\n",
-                            "      <td>0.832942</td>\n",
-                            "      <td>98</td>\n",
-                            "      <td>0.873712</td>\n",
-                            "      <td>98</td>\n",
-                            "      <td>0.694304</td>\n",
-                            "      <td>98</td>\n",
-                            "      <td>49.398332</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>99</th>\n",
-                            "      <td>0.697098</td>\n",
-                            "      <td>99</td>\n",
-                            "      <td>0.860499</td>\n",
-                            "      <td>99</td>\n",
-                            "      <td>0.861272</td>\n",
-                            "      <td>99</td>\n",
-                            "      <td>0.702848</td>\n",
-                            "      <td>99</td>\n",
-                            "      <td>49.890215</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>100</th>\n",
-                            "      <td>0.824368</td>\n",
-                            "      <td>100</td>\n",
-                            "      <td>0.881335</td>\n",
-                            "      <td>100</td>\n",
-                            "      <td>0.906095</td>\n",
-                            "      <td>100</td>\n",
-                            "      <td>0.792459</td>\n",
-                            "      <td>100</td>\n",
-                            "      <td>50.425532</td>\n",
-                            "    </tr>\n",
-                            "  </tbody>\n",
-                            "</table>\n",
-                            "<p>101 rows × 9 columns</p>\n",
-                            "</div>"
-                        ],
-                        "text/plain": [
-                            "     RandomForestRegressor  FeatureRandomForestRegressor  BayesianRidge  \\\n",
-                            "0                 0.886961                             0       0.809516   \n",
-                            "1                 0.773539                             1       0.756530   \n",
-                            "2                 0.783894                             2       0.895437   \n",
-                            "3                 0.809408                             3       0.807760   \n",
-                            "4                 0.940127                             4       0.933516   \n",
-                            "..                     ...                           ...            ...   \n",
-                            "96                0.761747                            96       0.799330   \n",
-                            "97                0.797894                            97       0.921654   \n",
-                            "98                0.785695                            98       0.832942   \n",
-                            "99                0.697098                            99       0.860499   \n",
-                            "100               0.824368                           100       0.881335   \n",
-                            "\n",
-                            "     FeatureBayesianRidge  LinearRegression  FeatureLinearRegression  \\\n",
-                            "0                       0          0.796638                        0   \n",
-                            "1                       1          0.824473                        1   \n",
-                            "2                       2          0.909126                        2   \n",
-                            "3                       3          0.848144                        3   \n",
-                            "4                       4          0.826899                        4   \n",
-                            "..                    ...               ...                      ...   \n",
-                            "96                     96          0.839384                       96   \n",
-                            "97                     97          0.945870                       97   \n",
-                            "98                     98          0.873712                       98   \n",
-                            "99                     99          0.861272                       99   \n",
-                            "100                   100          0.906095                      100   \n",
-                            "\n",
-                            "     MLPRegressor  FeatureMLPRegressor       Mean  \n",
-                            "0        0.726154                    0   0.402409  \n",
-                            "1        0.762014                    1   0.889570  \n",
-                            "2        0.749699                    2   1.417269  \n",
-                            "3        0.752215                    3   1.902191  \n",
-                            "4        0.787372                    4   2.435989  \n",
-                            "..            ...                  ...        ...  \n",
-                            "96       0.773237                   96  48.396712  \n",
-                            "97       0.764912                   97  48.928791  \n",
-                            "98       0.694304                   98  49.398332  \n",
-                            "99       0.702848                   99  49.890215  \n",
-                            "100      0.792459                  100  50.425532  \n",
-                            "\n",
-                            "[101 rows x 9 columns]"
-                        ]
-                    },
-                    "execution_count": 21,
-                    "metadata": {},
-                    "output_type": "execute_result"
-                }
-            ],
-            "source": [
-                "data_res['Mean'] = data_res.mean(axis=1)\n",
-                "data_res"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 40,
-            "metadata": {},
-            "outputs": [
-                {
-                    "data": {
-                        "text/html": [
-                            "<div>\n",
-                            "<style scoped>\n",
-                            "    .dataframe tbody tr th:only-of-type {\n",
-                            "        vertical-align: middle;\n",
-                            "    }\n",
-                            "\n",
-                            "    .dataframe tbody tr th {\n",
-                            "        vertical-align: top;\n",
-                            "    }\n",
-                            "\n",
-                            "    .dataframe thead th {\n",
-                            "        text-align: right;\n",
-                            "    }\n",
-                            "</style>\n",
-                            "<table border=\"1\" class=\"dataframe\">\n",
-                            "  <thead>\n",
-                            "    <tr style=\"text-align: right;\">\n",
-                            "      <th></th>\n",
-                            "      <th>condition</th>\n",
-                            "    </tr>\n",
-                            "  </thead>\n",
-                            "  <tbody>\n",
-                            "    <tr>\n",
-                            "      <th>0</th>\n",
-                            "      <td>Q0-Q1</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>1</th>\n",
-                            "      <td>Q0-Q1</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>2</th>\n",
-                            "      <td>Q0-Q1</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>3</th>\n",
-                            "      <td>Q0-Q1</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>4</th>\n",
-                            "      <td>Q0-Q1</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>...</th>\n",
-                            "      <td>...</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>1589</th>\n",
-                            "      <td>Q3-Q4</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>1590</th>\n",
-                            "      <td>Q3-Q4</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>1591</th>\n",
-                            "      <td>Q3-Q4</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>1592</th>\n",
-                            "      <td>Q3-Q4</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>1593</th>\n",
-                            "      <td>Q3-Q4</td>\n",
-                            "    </tr>\n",
-                            "  </tbody>\n",
-                            "</table>\n",
-                            "<p>1594 rows × 1 columns</p>\n",
-                            "</div>"
-                        ],
-                        "text/plain": [
-                            "     condition\n",
-                            "0        Q0-Q1\n",
-                            "1        Q0-Q1\n",
-                            "2        Q0-Q1\n",
-                            "3        Q0-Q1\n",
-                            "4        Q0-Q1\n",
-                            "...        ...\n",
-                            "1589     Q3-Q4\n",
-                            "1590     Q3-Q4\n",
-                            "1591     Q3-Q4\n",
-                            "1592     Q3-Q4\n",
-                            "1593     Q3-Q4\n",
-                            "\n",
-                            "[1594 rows x 1 columns]"
-                        ]
-                    },
-                    "execution_count": 40,
-                    "metadata": {},
-                    "output_type": "execute_result"
-                }
-            ],
-            "source": [
-                "local_results['LinearRegression']['local_importances'].data['Serie']"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 44,
-            "metadata": {},
-            "outputs": [
-                {
-                    "data": {
-                        "image/png": "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",
-                        "text/plain": [
-                            "<Figure size 640x480 with 2 Axes>"
-                        ]
-                    },
-                    "metadata": {},
-                    "output_type": "display_data"
-                }
-            ],
-            "source": [
-                "#pd.DataFrame(np.argsort(-local_results['LinearRegression']['local_importances'].values, axis=1))\n",
-                "\n",
-                "# tsne for local importance\n",
-                "from sklearn.manifold import TSNE\n",
-                "import matplotlib.pyplot as plt\n",
-                "\n",
-                "data = local_results['LinearRegression']['local_importances'].values\n",
-                "label = local_results['LinearRegression']['local_importances'].data['Metadata']['y']\n",
-                "\n",
-                "local_results['LinearRegression']['local_importances']\n",
-                "tsne = TSNE(n_components=2, random_state=42)\n",
-                "X_embedded = tsne.fit_transform(data)\n",
-                "\n",
-                "plt.scatter(X_embedded[:,0], X_embedded[:,1], c=label)\n",
-                "plt.colorbar()\n",
-                "plt.title('TSNE for Local Feature Importance')\n",
-                "#plt.savefig('tsne_local_importance.png')\n",
-                "plt.show()\n",
-                "\n"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 24,
-            "metadata": {},
-            "outputs": [
-                {
-                    "data": {
-                        "text/plain": [
-                            "<Axes: >"
-                        ]
-                    },
-                    "execution_count": 24,
-                    "metadata": {},
-                    "output_type": "execute_result"
-                },
-                {
-                    "data": {
-                        "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhEAAAGuCAYAAAAu6lQvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9dVRW69f9AV8njGMcUVQUC1tMMDCPYouFipioGNiK3d2tKCaKhYld2GIrFnYrFiaKfdQT73/vGHt/5vs+nEfP9/n+xvD6jzVu4L7vvfd1rTXXXHP+8Pfff/9tvq/v6/v6vr6v7+v7+r7+4frx//oNfF/f1/f1fX1f39f39f/m+p5EfF/f1/f1fX1f39f39b9a35OI7+v7+r6+r+/r+/q+/lfrexLxfX1f39f39X19X9/X/2p9TyK+r+/r+/q+vq/v6/v6X63vScT39X19X9/X9/V9fV//q/U9ifi+vq/v6/v6vr6v7+t/tb4nEd/X9/V9fV/f1/f1ff2v1s/f4o8UH3PA8nN8/O94TYYMKRBL82tSxGoXTo+YQ9JEiOVNkxKxp+/5f3Ol5euUvlbhLqsR86xSwPLzNO+CeI1TqiSI5Wi/BrHuLUogljLJT4itPfYAsS9f/kSsbeUciB2/+xox14zJETsTY33d2QuP8ZpevgUQa1gwE2LLzvL93nv1CbEkPzNfbVHEGbECmX9FLHXNyYjdXdcDsepTDyE2sVFhy88FnVPxf3YR16tlKcSuPXmL2OUbLxD7+PELYk/vP0WsiS/viQcv3iPmmJL32Lkrzyw/h3Xk+1XPw9svfyAWOOsoYlGT6yK27/YzxAaHRCE2p2tZxLrPP4lY3PlTiJVqVMv6t3yL4DV/iufXSewllSYdQCyl+C77e+VBLOuvfG4Wnn2I2KWYl4gN98qH2O47cZaf6+d1wms8281E7MHWgYhlaTwHMfPkNkLJC5VGbKq4Nh1HbePf+5F7057Jvog1msLveFJ7D8vPB2/H4zVhi/cgFjGjFWI50vE6DNl5HbFOHlkRqz5kC2Kngxoi9unLX4h5NBiBmPlifZ7iombhJX/+yXvzhx9+QMy1N9/bi/NnEIvdNRwx5zoTESvvUxmxQ8s2INZ1SBvEJtfOi9g/Wd8kibCvNeJG/flHfpE+M48gNqN+IcRaLuVmc+s6N+W38dzkL8xugti+O9wMZ/blRciS8hfLz+efxOM1XQfxM4zuWAax5+95sNTOmwGxB/GfETt0Phax5kWzIFa/AA/lgt3WITa4nfXAaeXB5KBkNkfElpy+j5ja0NsX53tL9ys3b69pBxFb2YEbn3+HWohFP4hHrFcdHgZh56zf3daxO/Ga0Z3LIVY6UxrEdp/jdUiUiJvtenH/F/Udh1gmh98Qa1CQSbS/2Kjr1rAmeX02XcJrTh3hZvv3FyZ4pSrzoK4pErIxjflsXpxWD7FJB3mgHRldA7FyQxEyyZJatyR1f5VoPRcx9yolETs1vCpirn23I9akewhiToXdEXt6j9c/cmpjxJZd4Ovi3lgPoPc5mMyZN0xImy45jVhgF36X3nl430w7cgexijn4uqq1iyMW2oyfXyUvabNnQ8wjs/XZGb32Ml5j3r1CSJ0Rh+4+R2zTlmjE5vjw3mzcoChiRfznIxa7vjtivj1aIja7AYtI+0pfvh9iqd15HryK2o9YaCgTxvMPWBh6NauO2PtP4n5KzoIpeEwoYpNrMyn5J+uHbyF7HWs7+Ir2ZZalDvj63rzIPctlR+zEI2b7iw/cRWxv7/KIffmDH6/0SGbBb16KBGRGfcvPg3Zcw2uaFGEiEPP6A2IlnXkopfyFCEvxXswe8xcRCUMJHvynYnjDfRA31+S61gMoW9pkeE2ZcbzJXTLxpoxYw9eZZHxdh9a8NovXMDnMmpPf56ZuPOTPxHITuvKMVXyaZNZDSSUHXiMjEHN0So3Y58/8LosXyYjY5Dr5EfMctRexbC78H7//zv9Rv2RmxKrntB4GC04TETp4hpVz9mwOiH0WldgffzLWu3JOxOI/MTnOnIL3k18QkxLHdEQJ57UoZvn5tfj7j95/RKykuK6TDvIQHVODVdfRezy8q+YmUnDhIZ+vPE78DHnahSE2uLP1/h8TxD2oTWtPxEJnsghQyYbJwGvj16oSYn0rEMFU1XPJXusRK1jUBbFJouir2ma65efIJb3xmobTIxG7MKk2YhMjmZAu28yEeXwAUT2fQnxu0pXqhphCFHZeeYLYucfvLD///gefkXLZuPc16cGD27zlmVben0jPoRU8S6PWMNnwCGAibF7xMzyLHI9YyqRfx2r4JklEhgDrje5Rgtnp8Gp8eL1GsSp8/5YHwbGphKDaLmOGrtooeXOzop7VoDBi6vD29LS+Z3VgduhSB7FHr5hEVM3H97HsCCv71uX53dkREWOMyZaaMJ+HePATJWai0rWZdaP2FohI9vQ8COLeEiVptohwdnATN8Ri33Hjv/WS31NS0fYokp4PZi4ntscWnbqHWOtiVphz9L5beI13vnSIPf3Ie2na1huInRxKBGuogFsruDjwdx++QSxdCoKD/SfxOWnazJpY7T/Oz97R2xWxWnl4OPYSKEacuDbTGrsh1iGUieBPP7GiLJqf/3eMF/eEckOtn3VmByIMvZecRezsWFbnj17xnvtJQMtpRYtj7y0inQsO8TueL+51n2C2h4b6WBP3LCLRChXtEscUiRGrloN7iUpm8ndii7ZFYx62MlERhYBqmYQs6MuY7XuKOkgkwr0MWz4xt5kcvbrP79y7iSdik0Tintd7LGI/pHdB7MAkH8Q8W05CzLeLFXWaVpf/M8tvPRBTSUp90QY8tH4fYs+2D0Asf5+tiF2dyvZjugr8XfMXW+Mfo6bwdf9gfZN2xlB/KxymYPVt19h3//EnHhgqYXBOzUN0W3dWpyvOsRrLkoq90i+iyvo5Eb+K+4+tm3ymwoSzRlTLjdjtp0yEHr7lpjysFh+kZWcIhY6sxkNueTQ3nHNBzGS3Xef3vvaE9Xfvv+SBuWoWN6Cb29ifU1Xy6D08bDuXdUFs6MxIxOYOJAR98H4cYjFv+B1viXqEWIaU1k24Vl5uwCkS89r3WnEVsWexrB78V5xD7LOoUFRyNGUe2xSlKvIeCx3JDaJN/5WWn2s3YzKz7wqh4JEzdiPmmJloSnKRuDom54G2KZDPYdHm0xD78J7w+HNxT3ywPSfFsxBh2NCDqFb58UzwRzbkd5lJHN4zRQL2o4DW//qL9Za61rciDyN2qqQ1mU2bi4lL8iS8D3ef5nPepzzRBNVq+DEZE4sJInGLeUZ4fEhltgZVktNlKu9h79rW9lh8EaIkat2Z3QCx9H7LEFsoErc83TcidnXTIMRc/dgKS52ChZYRbT9nB+tZktCEwbEGq/+IOR0Ru3GTSVT6sj0RS1uaCJOPKOZi97OF6lyJ38nXrm+SRNhbC9M3cgN+95qbvmpx/CEe1FhRUage+8SlRCeaeRN1cEjCm+YPQTiLCLT2rKtPJyT78h3hVseU3GxzOhE5qD6DfAp1KCdPysu09wKhqonBhMzLVePmvbeH9XMtO81NdH02Jjhj97OK7yEOAjcnkiN7icPWKSur0/Vn+blevycCsj6AFWr57Ey2ivaybi57RpJf8bOonN/EM+mbIdoqpbMwKdl0lYnbgh03EctVSLTuDhAVkNVuy2qWnzM6MFk+/ZrJoR3BMMaYX8ThFfOMz2bJwLWIpc/MHvuhUPaYFcmzfMNhiC1d1N/y81bxXaYQhORb+yMRu/CbC2JpknLfyOzA5/X3L9yHxtZm5VmiPaHqm1uGIHbjqfX7rNWdvzdxGAuo+QeIatxsxjawdyPya1SCk9AqtudmogeKDLliAjlnrumsz3/RuUQ68lSqgJhKGFQLZc15Fouvzh3j+6jCxDL2aBBiO69zz4k7SjI32j5jeZ9fvE90cfUMkhlnH49B7NMHJi6+vdsi9jSe56FCMZwFsfLUekFE+sr1TdoZ33I6o6t48HM68ncVOVJNcSw9yex5RctijIkpAzsZcssJvub6RR7AkZOYUe+7yyxzxioerH39uEEosmU/0dv8XfS2V13g57dX7Gva80B2bcqM2qsxM+DISEL3jeu5ITa4Ui7ELsWyx5wxJe+Jt4LX0WA8N7RqlVhlDa1iRYrai++8vCsPwu5lecBXENXuB5HgqMmWrdGExwdXZbUXuJLvL00aogJpbQjb6fM8bLf05kZ9L57JfPGsrPZfvePnyp6eiXCu7psQe/mUiE2WXOTw7OnviVhef+vhOm8Y++TFMpJLsvQcUSjVnx6y9iJiamLDPTcTUh9xn9wViFivGSQMd/KzPmML17Il8/7iccQeHJyK2KHbRJiaDwpHTCUWiofVUUw2/CF4EgriDw3ujFi/RdZibktf7hvJkzIRdHbgfX5REAsrtSbSFTKjPWL7b5I3tWopC624LT0Qc/QVHINYK8KqyJdB9fjsO5cNROzZcU7ipK81ATE5dRFONDGRE9vgKVLx3Hx1nlNSH098HbHyX5nOUCuh0xSja7ACjv/Aar9KTlaxaorjxhVurjmOsKKe0IWM+ghbayG8IycHNl11QezV79yA6+cnZJwugA/0g3hmo2q5duZY4r1FzRBbf5S8C5+y1k1j9XluwMdCCLfdFxvm7fvxiIVvvYCYqxM3iEaFibqM3MOKfcl8Mupvr+WDufEyW0G9bCSsVAKSz5WWiYtKGBQBrYWAh/sHzkDMXmEbY8zwHUTsqpXgd9KvAuHgVx+s99iN4jykU/7Cx7vjOB5UYYFsD3j15f3l04gs84hBVRC7GcfnOtnPfC9vxCisHSmZsplk5lqluWEevcL9pUE+7hFzW3ISIasjWxz5AlYgZvz4/KvEYu9YVvaDtluv9ft7vM8VvyBHu5WInZzGHv6rzayKXwgOU9JEbKtlqc42pVNxftbIZZw8aBJMNNVOkOwUzv3AW4zyqySiiEgEza9pEVJjpCpheLaR+4ZKGNJm5r2TS7Qa7UslDKk9mES1WR3NXxZkS9XiMn/wufkSQ+TolZjOKN+SBe7Xrv9YEnFWzJ1feswsM1s68UCLfpcaLfsiKvHMLrzhFvuTXLRXjBKVtpHBPnwmKUWNabYN47yvSmbGCASgpTsnMZIJ+NbhF8bmCYisZAG+v9vPrXDY7ceE4JIl5mYzMCgSMbuWhjHGvBZwmyK0HbrD71xBy9mLcwSxuWhdTarL91I1l3WzuiN0GI6KcdFcYnJizzb+zxNZ+KBe3c3M3k4YNMaYCW15oLUfxypDrcc2tE8hPRXHEOIsLapONVqndALWL+N7a1DID7F2YiQ1kwsr+4heREqO2sZol7Wn/oUaoRxUk8lcjWGE7mf28kSseHZe62shzRGzt8aMMcbHlRweVcUDAfhMtDZgGOHn4OH1EFOt3FtP3yH2QqBJXs1GInYpghXwpafcmzeKQvDihJqI/WjbOjYvoQ5Fyk71EbMjGMYY8+I2J2yOzWuHmH8oOQGh4xoh1mUD24Umjmjtphls05RrNMry83UxuqnW9aB6iFUX8gaJcrD1nlhwqRKqHWHe8xr+G+s/1s7o15D9RDX2WH30LsRyCWGWZa2YCBTqvAqxjaMIhzr+wocwheAdbLP1yt5+YhJxNiae760FWxKVJhPifBjDFkd2MVp28wqRgsmiP/9EVB7HbjG7fRhrrRQrFmUVmyElURKVWFx9yoQhbXL+bpcyLoidvEfCZI7UhODOPiEsGXqYCEtUGHv2Pj2t/chTF9n/VEJNVQZztCqTC6/NtObknChBq+4bCKOfu8T3okiDl19wMyhnS44zCALxopMxiI1fEY3YNJs4kPr7xhiTSBCh1RRDEvspYoxJLH43KJJj2kdWWQ/+SxvJL1C9/pGCzHv5Fp+vVQJNVEhn1R7LETMfeB1K1SPcfPGcmLpqaL1PYkQymzM97/1nb4hM+rmRuL7+Ktu7I6uS9F13DrkDD+7z+XrxkNf1eijFoB6/4l5fdfBmy89fPvCz/pCIe7BDWgfEbgUz2XCsOwMxE8c9MmI5SYRe7fi7+xf3QqxSZ6ITvv5WAmr45AV4zfmdbPlUE+PyFycy+VLtjOc7OM6ppi78erVA7L64x1b7s3BJnYwFwz9Z/0oSsUhAhio5SJGKPdbd/SsidusF4VE1n17MmRVFKzEK2rIcq7EhC9grihhmHRsr35cjlEkEUSt3fh7KXsX44KsE5KFQRWxewQUxBwFVbzjHQykhKpuzj3Ezf/6OPASVWMzbTEg+qB2v/73XTDbU6KL5nRXVxun+iK0VyUAmQS60cxvUZI5qDamEIZMzCaPLBb9GKWcuacODWhE6Kw5h1XZ6aj3E7CjeZ/G5gvazitvVjW278/d4OPoI1v3Gvnw2UyXjPTFgG+8J7yKErz1EEWGflNgfRR7SvgF8H41CTiCWREDBL8TGWiQv31vp7EwEK4jE6tlbHvK1bYeoMcZ0aW393ruJpHrOCfKrVOESulCoPU4jIrRCiNSNr8l2cZY6nB6o3YoEZMW7uTyJh6GjpzXxe75/DF6z9QrfW+953IPViOf+Wa0RmxvFxO2zUPrdEcFk/stNIsdqFNIksu4vIXN74CUBo3cgplojV6ZQGqChGJdWhEmFMOxZzsSiQCbuV87ViUR9PDwKsX+y/pV2hlKiVGjC7EZuiL0SRDUlXb33NjNltdQYZUuhlKimOOxJw9BOrBKV4EjTwkwi7KiGMTphGFCX7/e5+E7UUi2DhMhyL+7Hnl3ACh6Egc2JsKQSfUznFIwpGeG7YYQlq06ORGzWESY588W9o6ZHztiqrMJCMEtB3K+F6JNKet748r65sZeVx+isDojNb8Q2zZI+PCAXneJB2qywNSl985HvNyqCVacRSYRql/3qwLZivy3su/4sEIaoY+z3K2l1X1Ep9/e0EoZVEhElRn6VcujN66zOE4nJrDuC4DugInkonoOZ4FX0JDlWrUO2pLdoJqIOKmFoWpDtSF+RMPwlakGlMZGlAoWfTBa2Aec25H2dJZz7ukpAvdtbp0yUxPNrga4phcmPn3kdQoSwWvhyHrbXV5D0eUgUTNePTkdMaZ10DLcmIAHtBHJwgoR0VbikrzoCMZOYRVBCRanUyHvVFnx/5hfed1+7/k+JlWopAao8gpSo2hkqsXBJxc3w2kxCZErbwRgr9JlI3FjirDFFu7GyzVuIZLBVot/bV2zUT+M4btjbixtwyZxCAVHwREqXs/bPS4hZfJ9aRDCU10eh3KzOlARzIyGt3SgNSYS5XfheFHkzrRij7VySCNPaS9bDq/5Ajps5ZScP5d1rIiJqPFKt7BXY63/1jhVrVh9uXuZ9PEJ7lvRBrF6QdUNvXZ2cCKUdcfURE9eJkUy+dvf1RKzUYFZZTWtS0OroAaKESzqzf5w8Me+nj7aDNKvgnCiS5kshjrVzMEmfZfuS1/AkmpMSJz1dEDs7jfvGRKGKuW2sN2Lxn6yFgPIwCR0zD7GUo7sgVi4rv5NxOzgltUV850UWkhzZZggR1hJDiRwrpczb4jkZa/MO+ak275G0KVjcqLHS9SuYkPu24H0dGcwxynOP2KZRS0lVp/XgZIs98fmlIL9fpYipxkqf7RnB99Fk4f+/t/n/XSOEcKMioC4XJErlp/G16z+WRCgkokxvbuhKbEqNJSnEYtgiwkGj2jLZ8OsiRH5KcaTPPm56TBDw1MGqEIuOpV0Q2y0SK+UVsLItoXClpzFhC5nsdrElY4zJncEKcy0+QyiwYAYmX0PnsbL9809WT9tHkofSJYwbtTRSEsjGHFHtt1t9HjEl8W33BTk2i1WcEptRPfzCPRL2APZvwE3z1gv2jifV5Via8p1wSUsU59Pv1oN62V7+njIC6yfIdsrgK3djbnyqrZT0Z97/bWbRT+L2Sx42Su3y/Vtr20slAmqc89ZFVpjtV/BzXQwm2e4XgWIo8678rQgPq+ffnjAYY8y+O/GWn9VUh8lEFPL4dTHOWZitUdW6UaiDGhlVK+4x0R7zM58TNRUR0N0q6PTqIJUjFfl0+z7yWlRyoCSz5/lSftuzLrU41HRGlw1MwK/fYwKyb6iVRBv1kChBQCfuc6qFYN7xd5V3Rg1B3E8oiVJNYvyQ6evMttT6jyURalWuymr3pFAFVGiC0o4oVpyVaKMirHaH/cTNy09UyheF4I59fREPQ6NC/FtPX7MSVU6kqZNz4/Odx7E8RcpU7YZkYoO0E25CwjiCNakHYfXYxRwhXXCCm7dKGG4cZ+xqYSJMasrAezaTl7eiF333Eg/SsxesKEM98fcjjrHvqipgu5qiMZqHse0SN/6gerzXlSpi7YKcYlB6GqVsZNiT0ewxfxG8ITtx0Rhjzm8YjNj9p7z3lWdFEpFsLROH/KnLbOfdv87v/dRs6z2mWgiF3Pmct2nFyrGrQKaeCgGu8m04sx/Yl4lQJqHXoSSoVRLhlduKsNUfRVTH/Mnr1asK4XwPb14vv/4BiK2NZMKgENcHawj7P4jjtc7rzD1XkRztHIjUFSkqFrGwB2JVKvDZVLyhF1FUBP3zT3IMokL4nWQLoBJv0mR8hpVBVuVH8ZafD4+k0qeasLgXykmfcaL1qqTQlcKkR2NOOkZtY4terX0Tv/2I579CrHQWLOMo4Wug2gqZWlK1LHlKVmK/igNY+WQElifCECd0HCZvJRxo77Mua01UY9UFbpgTp2xCbMpw9rGU8t7m8+zjBguHujSi3+ncmjPlSv+iWAZr2+N2PKvEt8JsauomIh1KO6GSB9sDfX7jdVDKji2LcuNvJsY5HcTn372bcKjdO+T9TRKrhowiUau5G5PPVstIwFK+ABvH8r52y+KAWI7WnADYPYG/W7U3N74MOa3f01ohA19/MqtppevQbD6TVEU2nFCLCEsLQVxWCps3njMpuSNUQStktbbHFAp57D4T6JRCujxlIv7uAWHd7Z5RidnFI6baDcr4Sh3KA23mfW8FSqT8H+oEkYcQJBw2dwrfCdXKnD+DolRdexOdiROIldJdSJ2Vbdobtn1dCUb13sDCZXZjfq5dwn5+3AKqeKZxYht0Wz9PxDoKsbkzm0lUTVuEhOnr062H973nvH+L1qIejGpnKDRB+WRIsqVqSQgiaOQqqlPOPslzeFkzJj7/ZP3HRjzz52HvXMHZ6tBXREiVgKjseZFwMly5mTewUju0O4qq6QzFdehYjRvLzst8yBV0r4SPnMVceJuRFGBaOoJtBOVsudEmQNW9FvkVXnkIoy0Tqp5thdmaEmoqnJcV9rkr3CAm+ZFs2KQjyUrKx0NVLa9t43vKFVChCcsjmFRGiMmhYbv5ukChdnn+GTdSdf8rcp1KaIr33mT5+X0sr02GAjyUFDqxfQB7zH0EN+fogSuI/f2SSbRHXRJ11VSISnqLFHex/KymKdSYZolOTMg2jmdrNH9GtiS+CHK0EmpS+hTnxeF98WwM38sw6xRDhBg/bSQ0Xa4Ld+FkooWkOBa18hHpUx4bx+YwiZ4jDpuwiRx7PL+Dkx0/20Z8CzSgh8PzvYT4O69ngt+oMNvgvn153xQuTxS2onDYXSEE3pZ3I4rVbFokYi45rWfYJXGdv1ynXoXy0/gkErxrsbzWlTrwekn9B5FEPDvEcVOVlOzqTL2if7L+Y0lEz/qsYpRRV6OFHPNRExbBh2MQW9SUmazaqJXIUfzv3FztFbtKIi7OaYrY2ovcWJXEdZUKPLzdsxBhufyYG2m84IR8+oM30ouXTKzu3rRyMVxF+2Wz0E5QWhc5xdRBjfxMGLv2nI/YLznICj87g3Db6/e8NjHCi0WOkU6xVhne9YkmbdnCa/NyDXux684zIV0knFgruApX0Lf8DKWy8VorLsa4DTy8b523wqGK6+E5cBNi3VvyuiZNxORrxT4SBhcIJE6pPbYV0t23brPHPrcduT52jQ23nqy67JoLxhhTOguTA/Vdugj3249CRG6FmCaJEtMe78W9WU7oOITOtbZlnFy5Hz69wO/NN4AkzYGeLFKKNmZlq1oGBcXYn0osohdxciqLI4seNZ3RyCb7becSGGNMpZEULvPyZDtD+XUo9OPydH5PStfk7nPuG2X78B7LmI3Jy/3d1lbg9lVMhLKl4fNQ0IsIQ6AgzAaNoO6EEn0zSolSyGOPqs5zM38m7jn/lVbgmbOxrXD1fAxiikSpCIONhbXuG5Ghn5jIXpGy+FYQ/0+iP13OBq3ee8Ub0Hc0p0mU/PSMw9yUlReH0oTIJW7Mybs4RnftEpMXVaHaJa0zpmYlrhwLFQHz5G0SkHyKsqKyf5fGGPOrgKqVCE/oWX6u+y/YgnknRIMGVrOO4PVfSxSqbVX6kGQQ7PFsoq12U0i3F3FyQEx5Vigr8LBdJJe5CPXMhsWtB9Xs7fw9Zb+txLYcBBIzVYz4ZRacAKXE6VGM7ayZDdiS8xIIo915c9tVVux5hE29cixVhNEhVZi4K2XHcCGjrdoZ+9fwIKkUwMrTzrEYYbsvjTHm2C0mWvVGEHH88jYesdq+bGfJMU0hcd11ID0gghcI86rVJAI/F9wkf1v7MfYR7/MrU6hDkasrJ2eUToQa3Sw7jPfhi/NC/8GRqN7zNeROPBATcfZWhW9ffh/hM9iO/yELEcGnK/wR67WFxULYfI7HKiSiw0CiSVcf8XX+pfn5m7qziPwn619BIub7sZ+kEoH1oo+riJXKJ+PAXVYF6qC69pw38KLjPFiV8dfQTdaL+kWIl9QtxQ1TMbbbejB7vvuMN+qQnYTblgjXvgOiV/ir6AGP383DJX9W66GkKuKHggi69hAfaKV2qczB7ogKQBHQfIdQqCd7fhfEFrclBKcO9KXHrehBHTfeSxvPsOpsX57XK3AW7+G3D/mdXF3FMS912A5s7obYzC1sj4wXPcv2060HcPnfeDgqsZnGhQjx5nIShLmmixFTjp0pBDfl+RNuXlETSXxT45H29sDcJkQdtt/gAX/mPv9np1K8hrXa0rzpB8FruL+UB6v7AB7oL+7y+nftRMLdojXWA+3KbHKkhu7ktf9TJPNqCsklHRNcH1fe665CMC1dDYpBXVrDsWKlnukzmclG4qTWe0K1AYu2ZdUdMYOKmLkEvy6NmKaqMp1ky3PreAAnzsV26efr5PWoNk2RgKXWwAO2/Hx6MyGZ1YCkajWx4duJRXX4THq4PIvke0uoUFWidEwi3qzmvf5P1v+pi+e5k2SopnTggbZrKB/KhI59Kt0J5Vnx8gMfzEmLra2Vwe0IBddz5abcTHi7j67HbFSNjMZ/ZKJySCjPdalB6E+5B/Zry/5xQ1sbSQlSuQ2I4N8X7pSjRPspo7DHHtOIlWiGZKxslVa80sW/sY0bRNeRrFDsFdXNpbTWVdMPigi56wareCm/LUSe+vSqh9iUeSQ+Kl6La1pu/HYhoSqTIvEahUQoYSXlO7H9OqvipSupCqmIoG0X8nodGUK4ta1o8dnbj1PqCD+UMYS49w+vhtieW0y00wiFzc0X+DqFWCjb73JebMmoCZjAwdYD0kPAys17UCdgfwgT0o+ibZlDJBGFu1AGvkVjtqRKZ+V7aSim2lQSkUxofXRaZ0X7QgXRttUKXvtT59gurFqOBUlLUTkXEdNUSYTZWIF+nIp5co2F1vNNPRBL95vNIO0LzzmFTuw9yHMub36itSe2RCKmPFbMFyGFnkDZ6zFebHGUEOqs/2T9K0lEUuFDoWy/lYhSnIg9vsfNWxk//SamM5Q+gxq3VCZE9tHK2AdESZQOhbIkVwTHMuKgKpyJscYiKbkqeBf7RlGCNrVwrVxjswdXExFrhYW44rBMEtWkunkj1rBi8e9ASHPJOHInhkziRnpV8EQexTE2xSb7ra6z91QmXyphGiGmGHaN4mdoFcLESmlHqNbd6ighByzUE+0qlheuEs7fFEik76mAn73acBRQCVwFH4tBLJnQJxgmlCiVt0fqhqxGQ4dbv8+Uifj3/YXBlxrTm92JSX9LYSF/ajpdMX0EcioJnX4UDMvgRuTw4FDrVEycIG4uPMtnLo2Qt1fTJCMFb2Z6UzfEYsWYrtIiUDyJ/UGsWNWURQGbYNzAiix4nouExLMnCZPmFVHC1PndELNPhBijlTKVoVdgNz7DatTcbt6lWhexkeSmKGdPk4Z76Q8OvA52uXRjjJkfxv2ldHkWAmqKI+4wVSyTCU7UP1nfRCeidUUrG10dNorkokiPW4SmerEM/CKXi+p83TFWhRtP8sFsVIYtCNVuyJzBmqFfv0joUglcKWGtMEFKayD0D16KJEodaC8LEFquPIxZdomSLojZ/TSUcqKHF9XYUonk8IU4lCIjCcueX04iUfTjeMQG752MWO7ahP5Wz2Ni0WQwe6otbO6GpYQ2xVahzjh2Hzknp6eR9NlhTTRiSuSpcDoHxFZe5D2sELYzoj3wQugd4O+LaYIA4eK5Yk5XxPznE3WYI1xHlV6LfXLEGGNmBZIBn6sQp1jss/Kq5aWkprdvjUZMJQwK6dxwmQfVrSP8/EYkERHzeF8rCWr7qOYC4S+k1pSxYupE3PvzWrCFXCmQh5xyBU2oKJV9TNUYY3aJlnQiG5p4XUwdXHvFNrN7Oe5zuwM7Ipau3gzE1GSHfSTTGGNG7eFzvWwzFXbVFAdMyQQSka0N2w9ntzOxKNqAfhW/CXLkOzGtpXQnnD05WnpoDUc8HWuwFfJxH7Uo/sn6j7Uz3gk2vTpsVYtDETDV6JOD0MVXm1xPIcusnDdfvrMeBoqk+bOolHoJTsjaI0xAFJ/i1F0SFe0Kk8YYky4F/++ZGB42aox05XprfzZ1OhL3nDJws50jpl+mC1+LWgXITbnylMlRXaFFUN6PY0ljxrEFoXgnNfMyQbADD0NE33nVaiIMtetxkx9WhYfXIzER0knA+b+I5OCN0Eno14w92zTid6vbRnBdu1H9VbWVCuTitdm8ngfm2XmsOvffFWiHMH2bJFoQvws+UdhFHt7nblr/xwZxcCv31yb+3Byv7+G9dOsZCbmZxDOyUPgztBIweowiW3cTLPtkVshYaUlkacBk/oeUvIZXFpC4rZCe6oLDM7Y226pFXRwQU4dtm2JscUwWSGQ7G7H20Tve5wNXEsG4f4FoSqJU/PzZ8/I6KB6OEq+aIzR30tXkvaM8K+bNsSIKHQOYHKQty0mUXLk5reUnCI6NCjN25l48Yl6t+H+VOqVy7Pw3DLj+TzkRX8SsbP2S/CJ9CxLZOBPLwzYsihB/7cI8qJQCZtAhHoazGlgJbcpqXLl4tmzIhGRENUK8i6IS5tpXPx9hriMPuJF65+f3VHcWxWpS2ljr1cQs9piJrOqPLOiAmKrYldfF63getgoBUIdyS+Eo+aNAtga1YvJmtyrvXpqIk3KizNlyEWI+jYjOVMzDBEyJchUQOikpRdvrmrBlVpyFkrYJKGXJXTQj35tHL44pe5ThvXlfCAQ1qsj+dNsSTIQVibRcSX7vmxcw8bFPCijtBK+R5OuohGmuqPZbCCvsXcIV9OozVsozhCuqnaRsjDEeWbjX2c3xnJMzcVHun93bstJXfIo8wqRQcTiUnXnkwu6ILTzDJEo5gH4Q47H2Vo2reL9Km+OSmFZSxE01sZE2J+/Nq1OJRKQr0wMx8xOfQ6U8ucUm558vIz9X9go9EVM6EXYzL2OMCV/LZD52JQuoJktIBE2o26cRFuz/lS6eaikDLkWYVH3iH4Q7ZeuxNIhRypYqiVDrtYDl7e5rKmGY3I0PuacLM0814pk/Pd9vNYHOKH0GNQp6Rmi521syxtCoq2Yu/k8HobDpKHw4Dh1mEvHlM+H8Zj484Nst5wjW5i48qCd3ZjWa35HozAgh/BTS2M3yc9PFbD/5lGDylcedqIOfO1/nKUS0Yl7yXrosxtwaFOS92U/oE0zdR4Gsu3esnyO3MELb7sDxyAxZ+D8XC7l0ZbalEly7YZYxxoQF0jvm5e/8TtxGU4ujmU1Yq8JoqiRGjiX5VPlpBB1lYaCmSSYc4PerJiBO7KNfS/7WnogVzcDE4rnNgC25QDAXDCI5dI7Q6+j9Gw/MrHVFNZ2MhLkHW+nPcPMJ0RmFukw5xPcStCASsURJrajI/P6E6fffFEWg0ISQBMc6UxD7UyBd6ZtxwsgkZYLn24US54rv4NXOipIrVUul6+DowfbT+Z1EyWaLKQ7lJqoSBqUToTgRsbs44vu165skEXYipWpdeAhlw2zpiAhECVnazoLFrZQiG5Vj7MpTVrZDFpCYorgDzW2TB4WK8u+PXkFYrvIwSgt3Kc3+r3KtU34aLsK+Wm3oyo2zuisruY02UmavTcyKZ/owE7cr0RljzJwePDDK5+DBaleONMYYt+VESap+YA+8Rx1W4ueexiPWrRy/47IjrRtTReGnoPxPetVhEvFJqML13EwI9sVbInERm9niUJMoytK6ikg2Wth64KqyU8l3gblk7H/4TL7CniGEZdVURG6hsKpaHMOri2v4mIfXhdh4y8/KMlq1VRav4x6hRKl2bGciUL4o0c9Vy4l+/SAOIKUdMVLwCexJhFrj1vNeWiuS6vuCN2USCRtpgTqoRODQJV4vJUGtEJCsebknfnhvvf/bdCdZOmQGpxjCEDFGbDnG15/FZzeBMJZvPBoxpeKYN3AT/4ngOzw/bOVrZWrNd5ypYg3ElouWXDqhYZK+lrDuFmiCmsRoXoQFzvFDbCsqFOP/GcVKJXut/DSUiVbkXh62iwfzRpoawap4Vw8iBYoZnRCTKzUaqpKUtqJ3uFvoOpx7QF5HaTFu81yo4s1czora05MbddwbXovBNawHpJoIUT1sJdXq1pEP0pEZTRAr154byfAB7OPN20xC07GRrNBG7yN35pN4z6Nsh9fSsyTf7r3Ea1O/GPkVTYsQuu+8nklkgyJEdkaH8x5OI8SbzhwiX6dcNW7o9jHCrOWYzLnnZ/LRtYwLYrWG0+TKJTc3pTfiXlophNscRHsou0DdMrejJ0inJtbkqKEYhUst0AR1vypVRDWx4ZyC18FRiI0dvsfkZcpmtq4UKbNNdyuva3EY95sDkzgl4tmI5lXbVzBWODP3jUsC/dp+k58heC5RXb9WlC63jxUbY0zQeD7/dr2DnkIG/uk73kvlBF9HJRE7rzDpaT6A99KphdRsUByWeCEF31m0UVKksiaRP4mEX5mDBQezXdSgIJEeNcXh3pS+Jud2sfj6Gt+NjyeEK+g/WN8Eibh8yJrdFK7I2ekcTsxiu/aqgNio7XwoHy0jyavK1EOIKZGrfN3Z23cWFXt+4cYXbssgq4tZ/OxCTfC4EzelsQu5sVyfwxtky1Uy6rOnYZVxYSbJpkrvoLBAMXIHWBnECwWMqoSV1Aipfwsmaf6LiPSoaQ9/kTAmEvCdMhurlZfXS037/PGXNfFZtpvQdd6cvB9qC5Lm7OOEx+29bmOMcROKlWqphKFpM36fgeLgP+JuPVz79KOvQdKkPAiaCE+Ezx+YCDcSYlvqszabzfukpw/JexvD2aZ5f49Jf928Xpafw8SESVKB4BTKwCRFySgHLmQlVkvISAeWEZ44w7mXVKrLpOSAaBlce2wtGNpNS1i7MKErmSAaDxJTB+e2sj2kYHnVWtg/i6qIt9vWQ8zZpoCa6GfeNyvP835QtvK/iFgBJ+5pyZ34vN54wSKtuT9tyZVB1py+fHa87fo6zZfgNWptv8jEbe1pfv7ErixSd4uppjzCryWhKEYiF6ITX7u+CRJx/r71YileQ62xrAr++pOV7fu3zBRvhnCkZds1XgQFSy8+IDZ+Qcrb1pUVVd7OVuhXjfglVDlz23WRPbuzsm24gMlG3+okvh0QLoM18/BgVYJWdrnt+3f4GW7N5Sa3W/BacqdmcrhDkPwmLWLlpXgSSidi3nxqFrz+nT3rouLwfmdzIz0qvo+86Zj0qUmfbot4AD2JIlHPoyGTrcSiagkRc/yKZT/jEBOfY7esbb+z0eQE/OrAduFQMS7cZjjn6S8t9EdMJWlunVkB5szP+9ouZ22MMc2HU5TJDsF37U5y3GOBdHYR6pSDtrM9oIiQMc942DwUY4krBBI5TEz7dBdtNfvYZ63eHAVUExuq/aBEnySHQ8jFKzKz8o4oWNQFMZWA+HVjIRRva0kqDRM1iaHkrH8Uiesj4QfUcHokYopYaee5GaO1Yx6K/2GXvVaEycuCHOo9gRyGZCm55zw6xNf59mABHR5CAq75yNZgQj02/ivbGQ/FCFaKVKwUlOy1SkCU6qTyyVDTExtHkYQV81pYEAsypF3JUR2iSkQqiwOh0Nk7Cb8n1CejoMq8hWaDt9CdqOtB2Gz6cuthuGckxVYqD+EGf2kW0Y+Oa9ljPhhJNEklDFfEJEIKAYXXFJyAJ8LQ6oDo7QZ4ulh+buzGA05ZFccJbkYxcQA1EmqaT5/yge5YU0zn7OEBoaZYggOoMdJ7ebTl56xCsU+ZXnWoI8zs1glOTAduLBsuMtlMK3q77YoLfX7RLsztQgTI7rGh3ESVwNUvIha6OBKx2g1EIiBGd9XEjhoPrTWA0y5n57DoKdZtjeVnNXURNJv73J4Z7H8/ECOTGYX6qzTbqiMImIpP8T4eof1L+yJ2+zW/E3sr4HQQ940Qm1iaMcas2MprXasyr01QfSbCjnVnIOZekXuOSoTMJ36fVyMoBZ7W1uJSCYNnw8H8PTH2+eI09+rY/XQ7df6tF2K+vTmxoUiZCZXC/lqdiG/SzrAnDQk14PKZyd6OSiwihpGsUqo/qyflqLn3Ng9+lTAoc60j962wUfxHZvs9BFM6R/s1iHVvwYNgxcEYxIbXF3PcPTgKl6+QaAUImVdl1W03zao6nJ4A+8bQ60At+6SHMcZkcuTDqwyz1FSE4h0oUy51yCsb9Y4drEzuabVFdSL66ZOEXkO5MXwAP3/mPVFWcGKmCU5ECy9yWJIn5jX8IGSOvWxwuyI41hJIx5EYQqFqzT3MtocytDp3h4mKQ3k+E0rtUU1U2KXrn4qkStmD3zoZjZgix6VPxcP2tRAH8+gq1BOf8zs5v4GHxoBt5PXYXWHPxcTjNdWmMvmo2ptIT6JkLMjUBMTL24LMKSY2mrbgiOuk2lRYzdqKEwvXBEpsRzFCz1DwTz3Tt4KpOpm3J/f5ewLpUb4bK4Qg4bkU3K8il1Bsy54wGGNMHltr/FUUeROXdlEsr6APEzff7gkTjIo9TK8X50o89J/GEyVf14ZnTno1CvqV65skEfakQREr3UuyP6nGPtVS0s2K5KiQiAuzSfJTYlPKgGvgPGtrIVgkOLef8mHo15rv7fBNbrYKiTj3mDBqznxEExRhVMl55+8Sjph9LFXxVVRL4mE8D261yT8SFdt6cYiokdQqUzjOWkiML3q4sMoaOodJ6cZlQyw/OybjvbRFWDxnc+BGPciXCd7EDTwwdu5lzE7KMsaYkpn5GYpnZXXeYhlHYe2CTuMOkF9QJD0PjICBfEayugu3x7T8/H1FcjByD30HBDps6ojr+kUQ2o7a3DPPbSbpb8okEubWiferko1OHkxSlZts5FSO/S0T/Aw1YdO1rAtiqataJwVCp3G8te0YftZXGzrxbwm5cIVEKBKlWiphUG2U5o3JdftFtOmm2vR1BgiEIeoACcl/CTG78a1ZkCjzLiVKtWQgEYC+S6h1o9xpHStxFNJOGJ0dVA+vkZMeAukIn8zPoLgZCoko35ZiYwphSC9IlGmLk5v2tes/phOhvDPUevpe9DvXRiO2TYw+bRZ+GkqUanQNQrpVR1DAppm39WFQrYvimbjpK3XKjtVI3lJjmk0LM2G4Jdw+Zx8j1yOHeBjUxMbpB9ZDvrgQx2ku/DRUL1KJzSiXRR8BZ186y41qfKAnYvN28IA8IuDQcV1IQrITS5WbaHExuubRmNWDd3vCsndPs51TuxmrwnxCr2PyHra4QppxI1VtiVnHYyw/b9tAMussYb+tFBDfv+V1rZDLAbHO4fysJw4I8t4VJmW5cvL/rmxFMaiPNlSoltBvySiqxAm1+ewrV1fldXEolOx5lTD4uLKt5lqN1eOpLSTvJc9mbWdNEIJkO8bVQ0whFhvHsmLfKch2auribAihcLXKZWUCOm4H+R+DIvg5pntbr8WMBkxS64r3q+SsE6dmAXFkLj9DuUYUTNp02Q2xGmLaJ3MbJtZKT8Gu9qgSgZv7iRzkbsjv6OpaJgdKMjt1cQ4fKISBO5OexGgizr6vXd+EE1FuinWs5XdBelPoRLua7HdFnGdfW/29thVdEFt1kvCo8iIYXk2MQn7kZnXRRrhS/hpKRKqFG+Hs7hvZd1YW3y5tqJWvxlm7C/7DsXHkf6wSRlp2NcpD8zmzHSWSr0tPmMwcE+JIj4Wa5hBx49+J43deIxcPm4LO3NC6b+D3WasQ21SLImMsP1+7yO+jS3O+t/VCwVRB8r8IVnydaRzzOj+W1zB1g7mIhY8jLBkUyfcS3NC6MdeYSF2D4kXIWE8i2O4bNhLpUNLKSolS6UnciOPhrcbolJ+I58BNlp+PTuaBqXgYBbuTm1C3BhOLU5e5v2zvyfHYWcJs7IMYcS4nEDGnX1gwtZlrTaKbVOfe111M4fQSWjKN3HgQNu8cjJhx4Kix0o54FsGWTK8tJD4qxcosflTFjAq23jvZhcOoGt2MusM9x6sZZZpNeheElGLlKiF6lkj8Y09/6nook693Nv7Hl+vkQ7nW5/PbqxavdU6BTFZqRh6GMvQK3MR7InwRx7QTKkD1XzHiaT/k1ahlY+GK55WLmX2aZHxLVXLyYWgqLKjbVxaGPoIFm0KQEnM68Ua/+dJatdYWB/cHIaKkVvsyrOwV271yVRJk7ggE4Oxk9vbto5vGGDOqKzPZYyFWU5vqQkZYyUrnzc9DKbMzK+wywuRKmXelS0EUo9kEjpapUdj2pfh9ZhL97pnvrShGkeIueI1ChAaJMcUHb5hEuWUSZEshD91sKQ/qDDn5GVIkYtJ7ZC+h358bWTkbT25T/+KySKAVwfNULqJfx+8zEVQ+MVefk1ym+BRKbCp1Cr4/u0GW52Buju9jiUK92kHSn1NLJuQqKak1nePit6/wfxycQh2HoKMxiK0Xgl5t+vhZfvbOw73v2hMmX8Or8gBK9yuTqNoBfG9jhe1zkTa0G0/vReQksC/bOf0E18O9DP+HXQo/iyPJ4opE+epKNGJ+/dm6CpvIcWbF9MnqSC5d2WFMhJfOoslX7QLcw/60Tf9l8uf/vLqRh3S9/gmb4lCTGJInIRIL1VZWCYOa2Pja9U2QiPiP1k245fKzeE2s6JP3q82NZVCYgId/Y3LQQih0KTRBeWL4iYkFD9GW6LvVmo3HPGIW36UGuR5dx5CoOLwHtRgy/sr+fMcxPNBV9RA0igfruFWszk+N4YNUaZK1ah3TiLD35svsp54QqIPyhAgU4jInBbKx5Sz/XiNxbRYIbYfN3TmSG/OCh7x9Zv2O6JNPFbLHy1syEd57k22agO5EE6LWUCdA8XpaLOPIqBK5svt/GGPMxp3WezNqIomwE4U50g7R694kKnGlz9CsEJ+5Vx/Jk1GGVkVt0wnGGHNvMScPTsRYk5fNV8SM/SaqU36+zu9y/xpWse7CbOoPMRoedIT3RFNhkFTAn5C2YzYmh59/t35Pbx8TNS1cnshkf4HWuqYj+vHbIE5TqRF6ZZke/yIesaKlmWxOrc+2xGyhO3LSpgFxP4oVu7c/UdN8wuJ84hCOfCvC7KENIhES7bfyBYniqHHOgydiELO7gtqTCmOMSV91BGKqNfLoFf9nGrFHzD3B7zdoCVvDX2KYlClTrv/a6Qy78FNCRzyVxLMy6lIwn5rOUFMc3kI9sN04alYoAmZHG3pw9jGzxwfxTFyiF5ApbB8XNUaPjFatyZ54BSGs5C40EdKIjF+JVyWzkQsviQTPuwBbA0+FOdaBSBLrBlXkBqQ0MY7eYmIxdB7Rniw5eA23XGUCkic1750UttG/zdd4KEUdI+fiD+EnoZCj7BWI9Ky9xPe29gAPbzXZMe0Oyab1KjFRXWgToVF8lRsi6V3emVyiUl2pOqhGIe08DGOMmViLpDz3/kQPTgcx6a0rzLBy2FpXqqo/tZZJWuKfWYkXaTEbsaur6GNQZwbbTys7sHVVoAarwikzabhUx5WJYF4fq9yyMr1SPIy10Wy/tC/Jw2bdQBYpyq9ETfo0LMLkaMRuPtcKrQ1fEYmYXe3yljNhdW/haVRHGAgeaErk6OY17puVB1I74ctrnkO7ulMVsssG8npenCdymLaJ9e/9/SefX0WiVEqUikSZREzXLdnGtlLp8iy+D4kkQiUMXXvyOfna9a+MeCqfDIVEKE2IG1e4Ab8VI1jK60IhEQOEol5CR0Er57De6PWHcXNUUyfKWGv1dn4uNcXgVYwPkhoFdajBS7e/Lw+0jN4k+owZbL2R5m4lYerRDf5PdbD0aUk+gRoZPTqB7RdlU97bnwzw1sVY2alJFCWle+qB9VC226AbY0zrxvwMA7YTup1Sly2OER/Zalgewe9zZAuOjCrU6eoiQprKlrnjHGs1srEvx/QexTLpzSsInn060+tFWc2nE5XSJ+HZMU8YpoWeJRflrSBNDrYlTHdiySU5KMZUK7gQEYucS67PZIFMKnv0rqKKVXLTtdry+eqTmNX+qz1DLT/vuMz9oH8FtsGUnLfvHFaiNy+xYv07hp/hgfD1UAlDjZz8TrI0noNY6sxMQNrYvEgqdaMR1lblJ1GFFXu5xhRuuzzdmzEh8V1zKNEZlTCoqaMHz1mQnlhiHftVYlMbLhBhGr2WB7xqUyjzLuWTMU3sQ/mFFHh+QSINnk7u0OTa/wVIhH3EU3libB/MTFkphaml9CQcRdWdS9jhlvuNVfFMQZpSVt12MzBl+lWlMC/U0pPcMKd5k+twMIZV8U/iO1GKkvEfXRD7XRC/Vk/lTZj1V2uSszEDb/xSbqxYXTMyOYq6G4/Y9qFeiKUUnIhsqYnOuDkRqlXOm6ECKbj5isnmR1vlpSY4FGE0owMPgkoTSF5UEs9KObN4dnInttXjdEKBjmSKN/bh6xzTWe91NdWkJkeaLeX3+4eAvec3cUNMEUaVP8cRAXEfG8N7okE+Ikx2IrRKNAbN5vtQ0t12gp8xxoROIepi5ysYoydbLgpkZ8Wcroj5jWJyaD+olelVZcElChSaCDdO81ByysWD8E0yJv0Dd3BSYHBlFkKqNagmOxQ6F/0k3vKzdOKsQRJh3H62nxx9aHC2syxRzTaDiFiZZzEIhc9g0m8ME/czxzk5ZV+K19BvAVs3iuuRoSyT/rNjmbgow6z8fZgcvbgqkAghaPUsUoiNfeX6JpyIugusm7xCHZwEQ3eF6DsriF9JELecxrlz1TLpWZ9w6yJhrxvSkhv1cptYiXKKK+hHVnTKzHxdubIc8VTmWKePsSpI58zWQmahUFgoO9seB4XQi53HUECQIw8KqdrRNfldjtzFqruJB9GUTMmJOigJajVu2SOU6MHhYZwKsPtkGGNM9UnW+6R1dW6Yl2J5v7pn4fuolpMH5hYhZ772EA9R1xzk3CxpztaVMqV6f5NcF/vh9VA4h0Y/5OdSo5vSROo8N9Gu7eknoCYWugqn1HhBQK7cn8SvW4usB/o7IeesxrY7CsMkO0nTGG1TnkPsTU9f8/t8K96L4n8oaWW7nLmq6o/NoTeFUo71qUNuwsCKvK9V4n5StJp9h7AVEDKUCEChdNxzVOHSc701eT23htWvmrBQyUblaSS9XthBmP7u9qGIKSKokoxOnYdTPArtsI9gqukMqU4pTLlMSu4HaprCXXgzBY1ahFjcYXpnhJ0h2bqpUOxNmVSMyvyD9a+MeNYuykNko6jOl7UmjKyUIz2EPK4SeVITIL8KJnPbyszab74Qbpc2aLWhmAi5LtovpycRui/cnaqTSkZaeYLUFb3C50I//y/RHhq6kwfEvj1WSC9bbpIZnZzIL6gtRsv2XyO0fOpkDGKdm/DAfCqkq5csZXKophgSJ+YGGdGH7ZxKY6wyt0ObcwNWmhhPxCGiRhxdBWTYRlRKZx/xQHf4hfClb0Fe60tPWAE372utqO0TN8YYc/gBr03ILiYHiljrLqZOlN34C+GIq3r7oUu5kfo0ZKV8zYb+eQkJ7WaF+R2deczEYv9Nxvzc+LufxaHfeCyv9cxenogVy8jvqUR7jj3mKW49qOa1YAGlWj5hQUSmvNqQMPckjvth9Ele6/tLWXV3Xc8kdaFAoq6K9lj5hmzx1O5m5YQdFVyaV/eZaCvVSY8c/H6VENSeUHJTYt8TnfLKx+c1fWnyU3z7shV2wKbN01wUVUpfw7cNVSxVEmH+YusqdjtbDUqxUhlrJU7K9mMxDyJbX+ud8U3aGXYhKaXOqBQWR+xmr1eZSLkNIDyoSIRrhIlWhzBWsbXEjdRKqAJ2sDH5lV5FlQpsg4Sd43jYx6dsGTQSSYlCE2LfxCCmeBfP33ND37ONcFipytb+/EKhFPdS/K2pgtk/sBI/f1sx7+0sJlEuC5OjIYHM5FcI5GhvP0/EEomx1M29rYmFspFWCoCZcjERaCo2jaKZmGwVFQdLrEj6HH7h49clnHCrEpvKVdLN8vPr35mQtS/FDeP5O97DHUS7cPMAXof5p1jZKM+K8K08lPIUIRJXNR830v42R807r5h8PRYIXgcxGqymP24+4d+79IKH4+fXvIcHhrCt9uoS9w3HIiyObmyzEsFDC7CVo6y2f8nBw2Go8Pp49JbthzxCzOuNkO5XCUP6ZuQx/C2mxMyv5E7s3m2F1q/PI2k9exWSY9OKz69kr+3KkcYYE/OGSVSPWbyv358XqrZhTEqUNk3uudZC8JDw0rHfv8YYsyKEstpV8/L6/yQcjO8953VV68tzJqClBbJx/BCRY/PfkETYORDKO6P4UE5EqENfmW0pZ8/NvXkjKWGpO9dZ2fuJHvsioW1h98748y8+MC6pmMwEH45B7O66Hojl7Ujo+tolJhuLensipuSxlY+H6c9edH2bpa0iKXZYzs0xkZC4VaObJQoxSQscxp5lntLkNVwTB2b2bA6ILRZQXbUcbPvYPTain8XjNfeXU4I4pTjgBwib+j8F+vNc9PGzCHfOEWtJ8lKeHaHivi5gM1fy6ssRSvOI7zdiJTfMtWJK6s4bHrbKKTJPet7/R8ZzfE+hKduuEimxu7P2709dg0sbhyB2eR7J0m79SIROJFqjT++zherfhmTTJct5AKlJkbfioJ52xIp2Da3C5LuVeOZuz6dew5BdbHl2LMGk96EYI6zViW2UtAWIzilNkJK1SIY8EkFIv4CbtZ2rDsKbu2g2FXRUqPAKgqd9bNsYY+oVJJpaI5hnRLIk/D4VsqHcSe2TF7kyO/C9+czk7z3huPCz43xdrq60mldoglpnl3MCpIewd1DJxteuf8XFU6lT5hd6ArXFmM/m83ygA8uzolItDiUGpZKD8zbijzHGPBDw9dpjVkShdH5mjwqSVoqVvkL2ebE/KxaVCA0TvIPS2Zkp77vGA7iYC19n98BYMp/TFLfX8qZMIyqFrO2ZHCihqkGteB2U2ZYialWfyr5oMSFBXDUv74nNF6yk1AvXyfVQWhfKvlg5ZX4W7PmLZwnVKlXMKaOXIFaqER1VF/sx2fIcZW3ThImEXKnz+UwlOVQhLOv2EQqf6s/3oey8kzuQvBk9nRC8l+A12VVBY0R78+cf+LkeCej67CP+rjpsP4s2zUNR2TcZzE3evGUitH0uLa3rDLVW1H+L5NNNTHp1Fq3XGnmZpCeUY1GmARMwJejUXnxP9nFpY7Sb8BybtoFrevJGuk+LRMy7NhPo8OXkP6i2h0oslCeGOqi7N+b/rZCVhXAh2/Of7jcKnCkNC+mJUYeCUWldiTqpCQtprOXJZNYkYis/USbeY29Ws8X1T9Y3QSKc0xPSta8rN/iwzWvEi/dFCb+IsazXoipMn5pVkbL0rSgIcj2FvKxdWnuPOKRr5uHDVnYwD2U1nVKmN3kSj5bxgiqTHzVu55HdAbFGhZih2zU2ClfkWKV9NNIYY4o48++7ir9ftyhZ5hWy8qBWLRM7+mOMtsdeFUrE6kNzVo921b6bosf+QszTbwshGaxSLzrvrdkUjZhybG0nxp43VfJETK1Lj1nFJ0lqva/XXWHyvWAZk+q5wpRImYjtGkD2uBotfLWOveOrj4iSqTHt+7dJSv1o82IpLO65TVfIuagonHmV6NuazYSgWzdkO08VByphUEZaLWeS/9HLZv19T+h69BMjnnOj2Bp1+ZWtzIhpnDAp48devHSFbEaiXpuirMSVUmZTMT3w3ob+BR2MxmtUde4/jGTOJD/zflU8iYv3hS23UKe0S1cbY0we0Rqv5Mtkyy5pHTiC9/6KHXyWVMKQoTDPvidHmeCvn8prmK7CAMRMaiYbzzayEFT24F+7/hUDLmX7rZjSihMQ1JBfriI9Hn/JTfOTEFJ5KlARZbZ1YiLJkMV7WdnjdxYQCrMLbRljzKExfBiazD+B2F+vuSm1WRmN2LR6zFCHCC0CNVFw+hGTAfvBX7EAk6qW49ljzuRCJEZV8YlEb6+ekBb+SSAW9T25kW7t64lYs/nc0NS0Q6QNeVh7kQdX2RxEGJLnJtlQkT6PzeLm/atohbReQRXXcm5MwKrm4gapxMDCOpay/HzuaTxeo2yaFWSulPeSCeJqo/JMhEqOZqW4qzcnIBTpVxEVr7+0JiCq+v3pB95fyrp7z1T24qsNYCWqJkyCh7OyD13YDzGXlDzQZ3cqhdgqmzprezHBYp/gMMaYEaLtkbUG4Xflk9FnMDkh7gO590VMJOz/o/iO1Xjo9PocXXexOar+2JNj1RlaUJJ8yVm2chUSobgjrYuyOFjQjehc2Rzcr07d4x6p1tVtO6w/H+C+oXxIXHvx3s8jnIn/+MLvSSUMqYuQw+Ai2j5KPdMIDZP/Ck6EfaQzYzZmReuFjbZy55TywELiOiSMVdH03hxBqz6aTnZhQphHaUfY+4Jxgone9DdurIfvMTlQfIL+ferxfSxnpvhJqAKqdsYuIVX9UOjxNypnfc8dS7vgNe4ZmZCow0yNM6re+cunfFBD+pH4kzs1/2+z+bzWAWJUU40RKoKUfSkVy6miPVA1FzdqReaMEdLaR7awOj3yPh6xcJG8dGrCVpD9cHVOIQ4gISL09CmvoTIHUwREBfGeyUqUpPRw8p8UshF2goeGXYAsYCTbJXZisDFapEtN03RpzesaLsS8slZhITBrD6tn9VwHVmIiPMSWDISdJ5qSXPAQ1KTL9kV0gKw9mKOLyovj0HBW9gU7k0/z5SaTTe/u/oipxGeTjdcVMIyjvKFjqJyopmn2z2JLplJroikrivAZ+VO0Gm/MpAJmOSE2ZjKQIGmv7NM3IV/nzL14xOJOk0vjVI7366HLQsPiE/eSV7eYzBUqwr1UOpGKyY6vXf8KEqGEoFTCoOzBb73gja/aGUr4KfYND/lRbQkte/tR6OR+JJXcymSz9nbfiemM2qI/qSSuFbS6sROJSiqJUBC/QmeUPLancCy1G+S4OfGADxfcFCU29V60JCL3sjWkxkhd07J3/kGYYamKXU0Z3BIHZC7bqOrTj//zKK8xGjn4LRsh85y1KJBzdQtn1rO6k7ymDu9FYjx2siBgTpm2yfJz+DRuSm6Z2Wb0FiS6iw+YCKhJHMVXuRnDe2eHQI6iHvJ1V4XK3uzh1rbfOOEcqUZNzz7kAeRdlfd+1E3RkhDPYepfWMyUCeS4ZeJk7Lt/8nRBrNooa2LVUojPNZweiZgiOI6sSnTi75dMyLaF83lQhl5f7vDw6jqSvI5auXn/K3TCTja2j7caY8y9V3wO7Rbixuh7M3lOCry9uM37NWVG7hvVgpjMn9u6F7Fne0YgVteGJqdKRw6WVxOOvCply47hnGD6IQ3f799CxdK853ey2p+TOMpaXPlpfO36V5KIuDiSkhKKRDj+wgP4zGky8ZW09uQQZnxK4jpoNjP5vJ1JELQ/wEpqW5E+lRLnmN48MBZEsYqfJyYxqolxoK5DmI0PH8AbRDmW2i2zzwjm/JU75H8ohOF5LDfllk0Ij9XIwwfugFDs/C0Lq4I2RflweQnnUSMq9qpNRlh+vrmXPcZLsfz8SjLaawrbGfOCqM/gPZN6JYVduQG/fMcETK2nd9kXt3tAqKpbyU8rl9BGYsTz+EhyeFSStk7wkNSaI8Z0UzsyKbWvN0ryvgtbFytG0oBMrXXteG/eecZqb+VFIgCFSzIpGS/g/NDTZMC/umFPrPl7FyZxqsXZl/4f6pkOmcKKXZnDdVvHhCFRDiaWCtVzFCixsgdPlsR68HkFk5ujUK2C/VhoVRICf++fcuLu+gomPUcFItymDRUbvXtQiVOtWzet+9XrawI5SMTCOG0Tjsv+VpkJ09/xTKpT5+L3q9CU+iGkBihTLqe6boh97fom0xkZAqwEQTXiqezB1WGr+Aq/ihG03f0JjxbqzEpBtTiUn8bqQYT5sqW2bnJ9t/CiFBWugCmTMHts68GHQUHGarRyQF3eSG+FedOCfURsVrYlabKVzT3Sy51EyDET2TtWgkb3xXx2GeFjoKrYtqvoxhjS2A0xVwG3JkrMw9BXKPkVzGA95NT7UDbloYeZuKqpoy8CMlUcA68yvP7qPimbxQGx+i2JnJVqaeXn9K5M+LVgRrZyem3iPRx1hklKxCCSVG/GESXsvYSITfEivJ9UBdxUTCxlcLI+64uakeeizMbCLvJgKedCpMvpF27y6tBvJ6YTvDryQN+zgLLXVf2nIBY42DpRMGcZOVId/JjgBM9lO9a9ghti+3uRh+K/gs9XMsExWbVSwO3Z+fmfPaT8vhKvSmpr8TwQRaXSRJgsXGfbFeP7yCPcPtVo5fC+5LnNFt4Zqu3xKooKqCELrfyE3dcFgruW19XE8f5SEt8v3zFxy+1FVFOJUiVUAVNNdnytYuW/gkSohEGJPt2/w0p0zwjqGqgphmoTyWRVqENTQd7ML0YL1bInDUcOs3e6rAXJlusvElqsNJlVrJ2bYIxOGK6ISqlpYVbnaWuzUmgjYHm7FsUsXze8prUY8UyomqZaKmEYIVotKmFo5sP7yTsfK3uFqKw7ba0o/YWa5Obz3BzVhElSMSWTLRXh7NXCefGykPgulYvJdu503CA7DOuEWEPbuHF7oX2yQxAczwnPhriTfJbi3vN3u8/nsxT3kPfEKUGibH6X7YZ8Ofn5t620EulOC86Rkvg+JNQeO3kQiXn/OzfgGq58H15t2N5UHhtV21P2vutAHqwxz63PcMZsRBfjBDKluAP1xUTUMyFmpsibhTMzsdxzhIe34jCppWSv7Wq62dIRrXKsR4j/fGg7xPyXcvqjgBjvVyteXGvlzvl8Lw/0dI2JYuRMZX82+R09W83PkDdwE2JKcdmjwQjEEjwymkCuQ/palMf+r7ACtyMPSn763Wt+aUpESiERlasS+htdg4et4lPcvMIDXU1ZqCzQXrW65Cb/Qd0MnmLc7M9q3FgdkrKaDphENnLUNG4kq4RbXMQZQrCJhL3sw4VW1nq71TRqUv3J5+/5HXUWCovBPiQHVspHdCJUsLGPTCJUp0bLJhwgyS1sYzRi719aD6/2YsJgoOBEDBIuniFN3RBTSqdRB1nte9dnBaDcPhcLtKu0Bw+DI7YR3BXCuloR655EEVruM5bVtFc3jv01bUODoFOX2ZL4UehThIvWys6b5N28qGUlPuYRpnrNe5DQNmUMJxHUeGTTgnyGA9pxYw1fzgqw9/JoxJQmhCJI3oy3XgulV6J8TarmZrJx4jYPL+X/UW8E2wOdW3Jy5PhoFm5qJLfm5EjESg/lfm3nJ7hXZBGgliKuK77COaGcGTyXqpBDFzEBUWqXu68xsV49mijGBpsFeZCYmlMIy6tzfOayp+M+V97fFzFl5608QZSxllPzJYgpPsXXrn8FiVBLcRieCphrdD2SZpSw1Iqz3CDeClKeOvhVG2HEbm7or23Kg6vai9EtcZgfuMzKtktFcida9SPxZUh/3lzbhMlTx1IuiClp6dr5WFF72US58gnltVihdtfeg/+zg7Abfixg/7ELCfOdnkYOx8mH5GL0HCmmM3zI0LcnDMYYM7Gf9eAbHc5DelMg+Tpq9d16BbGrAnVSS42fDhDmTcrkraYYI25qa0HVF8JNf3xhy0txOPZc46H0Q0pW52vWc1OuU9sNsSl1ubnWmkFC2429hIxz2bQzVG8+gxtFr5QVeB1XJunqoIpcNxYxNRXRz4dTUrWaj0IsajP/nrPNgO7QILZZlWCUEQemXyfuEWs3Eemb05f/Q0lBe+fhiLePMDRTZNAhlUnyjLxp3f9UW81VJAf2Q9oYY0wKjjxHLOyB2OvPAsXpzpHJgLk80NUKn7EMsaa9rC2pJ2KfUwJXCk0QebZ5+45oUuxWWoYr3Yn7YiJMkXL5NH39+o8pVj6+x4PQXSi0zW7khtjJWG5yxTLw5lLjoQqdULLUarLBPnmhEgY1TaGQDtXOUEZg8WICpK1IwLaL1sKGc/yOZ9YnKvBLYmvPcp2S2t5DiLOMsCpWFcvWHUQnlgmRo6VR/L/KF2BpNF9nh/ON0XbbMw5ZEYv3nwm/1s3LTfSuQM5+FaTEjgsI8f/+gfd/mnTsz78QyqmphVPiIF8m1o42OdxsDqxEpx8hR+bASXI9com2gkJdFHlzZgf28Ved472ptB02r2diuX+atSWp5MedxFRXpUlsyaRMSQQrieAE5BceCD5CEVWNUUbPoRZFGZuYmzHGzAq0HmjnH/P+Chq7FLEHuwi1y2RDEPq6tqMhXfBMvjd1yCVy4p6jxj4VUbn5EuueOKkuk4+FgocTtpjaNL4t2Ne/fk8UC8K6vZiQy998mclhA9Eadiz7P6tRPj/Blky6KhyrTJ3fDTHlEqqSkqIt2Lq4Hk7UJWB1NGKHlnG0Nm3xMog9COZ7+SfrP4ZEqJaEkr3+Q/RTX37gwWq36TbGmE6iB6jGQ5UFeZQYVbMjAHsv8JBWSMeMwzyAY4UCZP0CrIBzBxCdUAjAsqN8CGf6kFioqme7FLZdBtsYY24cJ5dicH2KFxVz5gb8SDgKFstMNOnFR/5f/1Bq8T9+QHQihyPbA3VHEVqtWd1aFZ8Vyo5qtRaErgIBrE6OBZGHo5j9W0Tium8UtQhG7aW2g4czv7uiHa3vpVw1Ih1HD/Dav1xDhUW7IJcxOmFQvhNvBdoxuQ6TnvOx8Yg1cquHWMhp632tJoLsmgvGaPXLrDn5bDYvyz0ijVC1zSVUeA9MYlsx6BgnrJb0Iek72c/WrfbQJbbjQmaS+3JNeOQULkcU7sI2anMoM6jguUysFPHvxmaKHA3dSQRIkSYvn7deQ88tRDWcCvN+TZuTRdU8XyYHf7EOMGP2ka+mVr8F3F8ChKOobw/yWsJtBlzpSnXDaxRfQU01OXsSYVBTMoocmdeXfB3VplAtjsfC3uFr1zdBItZGWzdNdbA0XsCqY1FLzraqJCLuI2GeXKJXuvc2DwilHRG2m74AAxsRgp290/o6Vdn0qsIHVR2YuWuzooheT3WzdSJTdhDTA7+LWXk1AXLiDpOXnbesh/InNXd/gwfLQmFfXGEgK5vpgYQRl4ik5654bxFi6qZ4IMdvY0LZA58pDHw6lbJ+J0pPQBEhj57hxrqhB8mGw3dxTn6m4ITkb8+xxLBh7EXfEJty8DrOlNstyOu4EZmplJ3cnOYCOVkoZszVRt1uCTfgueIZtmtzGGNMj41kxSsk4tUG60GauupovKZ2K/qLpBcE1/O3SY4rnY+Fy3aRCNzdRT5B4OguiG08yHtOqbh2L2dtZ/4ltt3MqfkZirQh/6NSXbZV968n0vlgA+2xc7bnBNuvaYiSVS3HA33V7HDEjCOVIlOmcbD8vHkQx4V7byBaGSOul7IMV+OcKcUembsz36+C+F+fjkRMITshc3tYfg7ox6Iibic9LNS0VhcxJTJH7BvOrajsqUY3/XpxP1QtDv/SvF5N3YnE/JP1f2rAlcOJiYCyAldogncRbpqNivALUqZcVQqzQmkvDuBV560HSRWxKSvDLHVDu7ThzSAFswRi0U1Y9V4VcOjIamwFKCTikU15srcXK7sDt+MRGy5EbtZe4GFbNjOvYdWhdFQ8PrkeYhMjWaFlEuY6yROzqThyJklI2fO7WH5WG7x9IsAYY1Jm5rWpJGzffxMy1X0mEhHp2p796egYJjTK9ntrH8LSXdZauSgrhJmbOqiqToxELLH4LlVlv2YwiZXtxLi02qiz52BirdoIoVPCLD8rdUZFInStxspOcROUtbhzCiEYJRLr28J3oZbgHE0RQl1Bs63ITvhEtjzH7SAva7rg/qhWwPZ9RLDuzCbn6K6Y9FJkwFixhz98xwRXuWfa+/2rzvH9HrwVj5iSuFb+D7cEmb1sLyYMi4ZQm6dNh+mI5fFiMn/3OluoqdJaEdyP78gbuzmH5EjnWnQsNfEsePeHc5RbqnMGE7Fq3mEGYkpYShE1/yumMxJiwOXnwZtt6UkeQC23MUM7OpaVR/VJkYgtO8J+77Yu7AFlaskMsoyYz/fMZj1w1ORIM29CUPNnU6p3ynDeXH0mE4J0LUqeyJkYQlXKbCtSiDfZZYSNMebsBWvPWo2QHhSV+B9iimH2Vm5e0e4c+yxWkpWNMkd7+zs5FlNDyDs5GUSDoIpTuTHXGm29Zj5CHKztdH/E8mVggqsgeeXsOCSQ/I+yAp1STpmbehLtuCF4PQG2KZO0KckHcm5N9MPe3jHGmGEiOTwuWkh9Rd9VrVfPmRwphClUjGUeW2mF0ReK14zIxPd7aB0Jjq8FX8c9ExOXJmIMfIwghxbLyN89EcPvqU953utBNomJweHc5zwKsDAasI1V57habBfdeMQ9QulELBQFyVZhaNZmENE/8ywGoYBfmZQXrma9h1WrZcw4CjwVH1wPsUz+YYidmsEJi+5t2RpWbqeK/3F8CBP8vD2JsFYsY907RgjtE9WmUFMXF88zScmWVgi3fSEKX1WID5rk5FL5FOXnP7Tqv7Sd8S2twFUicO4kN1tl6HVNKHnlaE/dgcHtCAcWSs+/5zfZ+rkyCwZ4RgHdpk7Otsek2mR2K9+F2mI8dmRdbhr2loQx2nlw4pRNiF0Ks470KbSiSTFWWAqdiBBVVy9fbsBqcub2c2byxYSJ2CZBGK2cn6hQ1RyMTT5oRTaU2JRy7FStpkZzOSUy1pdcn+bjuGm6lRD9XiGs9dsgJqCF3NnHt3tgrOnMZNlrHBnwh0YSTZh7kpBx8AL2sW8u5cY/X/xu2C4mlimEaVJoGwqhPXhjrXb33Ynn7y3lpEfwIH4uhRLkaE1EUPFElO7CLeEdo1oQSuI7oI9VtdDdi+jSODH9sFNA/HZUwxgjXTEfHGTvXBGyHQTXJYOQ804qxsWnCvKul013o033+XiNmrrYM9MfsarNiSZdjWDFnjYF91x1tCnUxX0In9f7u/kcHttk5RiUacz3EbufqEMT4XSqEIFTy7oj9vYjOUEq+d55iNdfiWgpF9P/Citw+8qQgQersgJ/LXwX1gpZ2tpizEsZ36ixT6VEKaW1n7B6uhxkhYMWneKG6V+cG3x7UbHZBViMMabHRva6L53lobxTTCJkceCmfO4BK9ZU2Vh5O9qqVjWSpx7AncIKvUB+JoJjhN1ssJA9VwiL0qI4sooPdJ2JFHVRLZMLM61VS8/NrACHjKJk8PBdhJbVdMrPP3BjjRxfDzHXTEyOKk3j6OaMbvye7OOBxhjz9ov1eyrXj4iIIhYuFlC4In1GzWGPVbVHmhUm6lQyM3vsB2PiEVP6H/YVungTYopEOnUTuSl5W/M7Vx4T9wUP5Uws94OiAolQ9uiP7hERtPfY7wsit1qu6Xnt27TjnuZXiAdBry0sDuzkQGO0T4TSGFDEUmfRamwzxJqUazGnEMQcBDIZHMyD1dWPct5xW3og9uETW1IDt/A++STQTyM8KxrMsD6vyk2zcD/uQa9fCG2Gl0R/MomE1Lk+kQ313hQSsWIa97X5R1mkf+36P0UiXr7h6xTq4FmFh1zNgjy8cqdhr7SlmJ93zkJoeUcPkgHt9sVHYpgIdRW+A2o+/+wM9qeWiA1dKVEOFMJHEWtYKZ5YSA0ApRZnF9ZSUwdDuhHiU46dhYSlrbIkV/bg0Q+ZFVfNy2vjkYmxOkJ3QPEdquazVkWlBV8jiaiwWohEaJtw9szVgUQ1jzKE23Nl5MG6ZBoncRRRrU9nSlB3KGltZ5wR1W+/MGp47OnviViZIWzTjW1DEq0ix46uSYRt8DYeXruELfPQnUJsa50Vgs+YhdergHBd7CmIgCrpefye6JdCO3YIhG1RByKYGcW4adE67DHbSZlBk4mQmmQ8CB6sIYlws2g/nIih10tHIVKWV7jzDhHXoV1x3oclmkxCzL0O781o2x7+YjUPM8e6MxBTMtUFRau82RhKgadx4h7x9HgkYhHLeW1SCdG/XE48S9KXtiY0G8M4zumYjMWd3d7eGD0lUqUC28VK0ErpRKgpjivC4O7FaXIEP57g3/sn619BIpQ6pTF88J8I0Se1Tglnw3Fe3LyknoRAChI64jl0k3UzXCVQEtXiaF7BBTGVMCiNiVvVWRUNFoIuaikJWkUsLZTdujEvHUHjnyIZHBBTo6YLomIQuyxIn+u3RCN2dQ45DEqzomC7JYgN70HG95n7zPgH2fwZ0otxScWePjiYSVS3DUSOFNnwkTiouvYkpDtlUgBiT96yKlLKlnYXzz2ziczc37sDsb/6EUY/OIIEtAojuFGHBZKvociGMxqQJ1RnHicxAj2Jkq0TVvD21VtwDjIK7k/uBtwcO/Rgf/pINA/llV2Y9FTqQ55Am1YsPl6d5JjfMVv78ZBoZ2wRLSmlCXE2hG2l37JxH6o8mroLR0fxfj0nzPY8lnHfiFrVDzFFVD1uUwV1rMTDNmRGe8SUF8Wuiwkbya5a1gUxrzbUU/DqQS2O55t6IBYjJhvs65UQuCqZXXhYtKPnSteeRHVGVifHQulVSGVLoQmhkBI19vm16z+mE6HaGXPacjzMzkMwRstjq6WmM6rkZCtg93XemIpcaDdXmnksBq8J70g5XzWm2lJ4G0wQG9W2C1S7VMuu9WCMMVkcuZHaEwZjaEr1QMwOd5y6CTHlObJXIDiqj6csnZWfxjvRulKV+JRl/D4jhpNlvXu3lZjWsSYTsnRCpCy71wjGKnDjry/GFFUroFQjkoPHr4hGLHlKXsMfhFFdrpJulp+nicr5/A5uGK5tE6Z1oaS2f/mZMKoiG24Tz5cSrwpYFY2YvdqP/8SNeok49EPHzEPMCNKfcgWdJ0aXN98Qz6FQjyyaiRWrkpHfsNEq1OQmhPYuPSKaYN5w31RtoKN3+bomwhrgymP+j6i9FJFSicrIPeS6nBDS9cEB1kmhYcJsKvw8+/rVBAo5WWiY7BhNx9amQWwNqomVRKm4H6b77X8WljLGmJv7rZMSyYWBnvSwEK0GZUj3Qqip+vXxR0xNDqnkIH19JrMNBcK6qzOTjX+y/k/bGYrkZpeaNkZPWCjkIKGti7qleBgq34lMNihNOeD1LMdqSvErlE/Gc8EJUQTEeZvZzggQRl0ZBEO/6xDCpvbxxehp9fCaScJRT/Ewbr3gte4rKkUlBqMSC1XtNxDjvPkd2R6oOJjcicX9rIjCqrMklilJ6qLDSLa6e5D316WNQxBTyMn5kFaIdRG+I0rvYfp6tgdGNLdW+0WFgqsiVsbF8nD8UShx9hJs97UHeE+o8dD+9YgSTt5CNGWvGF3NWte6GZaqR5h2aHUat62/ys917iYPIFXtqwmLIwLVSiihUU2KOKWytj2K9iKH5cNbopAlyvGzjhQtJAXJp07B2OzjbEk2dCV35osQClGcBbVPJLEZ1QXVJyR//h6/XzXOqAiYN1dSr6NAF+5zJ6awhVx5JBE25W3x/DCVOB/ZrADSi2TOuSxHUlXbo35bOr3KREAYZimug/94ok6ly/PeUS2O/2cUKxX/4YuA35V1dcvlVE9Ukx0zRbJxR9gGFxX96ZbuTCzsks6DIniYl+9LZv+kHhxnU9W+Shi2nGDbI3oCK+wKEyIRayTMpbwaE5a38ykEcGIGi3HOYbuZ2ds3DGOMufGMPUCl9dB4EfuCPiVI1AucxYmVg2NY2Rcp7oJYCVsS2UFwWIxIItS0wyiRCCtuRoacrOJL9dmE2MfX3EgDPbnxKVnq6nmsG//vgomtJKkHrmTiomS1B4eyOvUsw4T5Tiw/QwnBYXkdz+fwqdgTmnaoZ/l5QEWKufmICaYedbhhqnXhId9vo+EUlvpbeMIkL0TU8UsqHnK34gnxr79qRWeuBXNMUWmkKCtwr3VsU/kFEk1SnIhuZVwQKzuMydH41kRnth1jUtZV/L2iLg6Wn1W7sFK3xYgpcywlwKSkpRNl4n6l2rvK4ts4MHHfd4NoWhPbwR8byXaZ1HoQbTCl4XDlEffN1LlYaKVJyuRFCVAdek6059BCJmBfu/5jSYQiTB6bypum7GA+0NsHs/+tfDKK92JfSEHw065wgwzry4M/5rW1MlA+FI6CX5HQdokiUaokYlEUq4eYm0ROKvhRllatWmOsXISx+3lt2hfn95YtNW9e5UVxQ/RJu4jNZu5qXoeBQjDr7QtWik3ms40wqiErnio2PZHX9ziSptovjmIk8b6QIK4mpNbdBcQ9LpxoQlahnbHhEivqxIL4efq+FYnrKKYEVBLx4Bbh5+HLCfFHDGILSR1yS1qxJZksMbeVEkI7pOk8vmf72OeeW/w+FLGyai4eBAUdmaR8/IPJVms/JgehM/k9rR3AqYhabVk9txnJhOnU7GaWn31FAv1JSHwnSumA2K4gTmJUCmSbqlJu9t0LiMkZJQ6mNBYC2rM6//CJ9uj2qbvSeTl6HTKGff0N0dw3lVHV2TWcWMjiSAJ5z808WNOW5TW0u44aY0ynYGHUlcT6P5QOSaVmYuxTJBsKsZjtQJ7I9aB6iKX3pCqmapkosuXay0QiSmTn7/6T9R9rZ6wRzPafRa+3y9poxJa1ohqfkriuICy4lQOm0oRQplz2jLqFGzkXvmIj7FKDWbEyxzpzmuM2Suti9jEefEEriM4o4auKORwQ+/Sn9eBXbRXVavoti9DJSE2EobpwnVTjkU9FdbqyFZMyx6asWv56zR5w4YpEsarZDi+ldNmgAN/ba8HNUCNYF4TITy8h8tO/ASFou4mWMcYsPc3DK6WAqtsUs96LbRfyUIp7yraau0BrEmq29TaeSdTl2STHRt1n0rfhIpOBI6eYMNv5HyXdmHwoorHw95JJimq1LBLaNAk15ZLTGZ05dRNpE0LLkZ6JprdwmFTaEUqxM1li9ucTopxpjDH7RVKitAjCwoi6/ZKKB9DHK1bxrtCFJGTWyc/rqhKG4UJzJHgqK3tpGPaa96F5x2fih/QuiD1d4Y9Y+vLWz6H8NQ6IvfrFUbYa1CRO6oLc+16dpxCaR2NOsWwSk0MJ1af4r1CsTMhSPIFhi0jyWNaLfdI0orenCIiqPbDiYAxiihOh2i3181mz8cJdVuM1yVPygV6wjw/0zSs8HJQVttK6OHaL/A+VMKRLwcsZfp7JloeLtRrJIIRalLBUw4J8nWpJrO3Eyu7sY17/ijl5GChUQPXn1wspdDuHxRhOMTRtQ3Z6h4vRiEWI1tgj0RoLXMZkzl1oZ4SdEAiA6O0P8GQCOiGSSJF9KmJJAFEH32mRiD17TkSsSDdKBidKzGdO6U5cEu0MP2GEpqr9JoKN3tGG7NwR79ejK5U4by72R+zdOybHuYVI3SShk1K+zUzEQsXGf2wO+9PuZQhBP/9o3V9y/sB9o7Nw9XUSfj1qZanASQSncqy6Ty2gsJZKaGp/5H7oIKTbg8cTAbETepWEdrp6MxBTB7xJzQR/+NBmiM1cw/ZTlbpuiNUrwEKzWj7e13fFfWfXrOjalfeIRh2YRKR1Z8Gj9CQSKl3dLxPvTTWx8W9MZ/w/YQVefTT7ggltcZQStrylSrG3qzgWA2y+AEq4Svl6/JabPeyOpV0QixNs3OXRrABUi0ONkToI2+QF+/j+lrW2IjtzhT20SkiUX4dyWdy3j9B9SD9CaypRqZGH/fRh6whLLhFqh1VFb3uYbSxXWVJ7CMO48h0WIDZvHG2fnX5hJeomJNT/EH3hYULQ6oRNktwYrX9h/xy5hXKqMmlTfh0rRUvi5D1Wcb2XRyPmKCaClJCSInQ6ZWM1uq2fp+XnNOKZLjuSm7JSxFzbiYlgsLjXFcIwMoKiRMvF91SwMwl98/vzXk9iK7M/iLaKXdXSGCMr1siZJOnmFLoGKYSHTzdh/NRKGDBtE6RUZVUetYbQuv29OPpwciZ1Rraf8ubnYX5LvA/VflBjmi/ekaQ/TCAb69azYk8IEnF+Kwm0RWry+4hYSQ6HV5NhiJkU3Ptid/F31QRIQpON/fOpO1I6lwPfyz9Y/7EkQqlYphFQoPLYiBeKYpVz8MG/HcdevDrkI/fyUHq0jNCUnYtQX0Bway+ywlSbtx3VMMaYxef4u4eExfmq9oSq9t7mpjx0HuHQ3v48bO1KkWrqxI5WGGNM/1FUu/PvQILjdG8S9UqO5g0d0ZPjoXNPkP9hF1YyxpjHohWiCG2jw63X+uVzjrgt6UH0a5GA2g8eIiLw9jorIO/25PpE7OLm7SMqpaPneP37+RCCXx1lfd1ywc1RZEvVpsiUhUnUMyHxnFEIFXWoxIQ8peixJxYS76pllsfR+j/iRKvtF6FW67+IsK9qXZwXibA6RBMLwrCy/VYJSBshj57NxfodK55Ac6H+2X09ibBLxUiqmvZ4f5HvQ0lhKy0Klago469xXkRdLsdanzGvvky0fkgkZKqFmqhJxWTj+Rrqq6hWSMdwTnol1ORLeXZ8uWO9FqndmaT+JO7NC5OowxPznJM46nmt5MvpL5VsmMQ8SxUnQqETXys29U2SiNh464OuPCGU2+PiAzzgVQKixKtGtSVPoq445Av34MN1YzYJR4q8uGCHdSwxb05evK6/uSDWfh43tOexzKgvzyOjeogQFroixGDc8nAT6u9JJvuqC3ww6+SxPphHH/Lv77rM95tE6AS0EkmfnXNhjDEXn/AaJk1EVGDMMFZj/r2aI1YqGw80t/QOiNldVtXkiEoYDkSyYnm4kEhEFTGd0VpMyey5yu84TowztxJWvSFCKTSkmXWipEgHbnp2B1Nj9NSJIohlFUS1LyI5jnpE1KGvMEw7MbYmYh4DKBG8wKZsOXUfyZznT8cglknwoZQTaevG3De+iPGkLKmIbGwUhoHj65OzUHvwZsScslqfuV9FAbWvL5PZB3FMlssEsLKPmEVdB69m1GeIXMvqOXlSPteqrfizUJ3NJxLL9I2swmq+TciHC18RiVjcpm6IKaGqwIEkc8aJ1lXYYiJWCrHYfY33SfMetGDv2ttq+hc8itLdiXKwzVywqAtii/xEIliLhNHYo9R6UEhE2uJ8rvMLZOe/lhNRtK+1ZeBRgpuoqjouHyKMpCyYx7Rnv9clFTe5nG25kSqEoc3KaMQiNrO3P6a3VclPWYGP2U/9A/9a7HXPXM4K+JMYQZruLVwWxWilGsF8KsZIj97g4WUfZ00uSFmPn7ISVX4lSYSOe8lsbOccu8fP36kUe8ArhKBTZqFP8fp3bnKNhDpnSpt2xs0rPAjUPPlvIolQCcMjIRCU9he+X9VuGCuqOGUQpJIIu7fD8O6sOmrlYRV3L57JXJ50PAgO3WUSqQiIik+gllIAfHWJ0zk9lljbI7+IFt3vH3if37rIgsSnIfeN3Gl5eE9eS5Roo+BmVRSqkMsuEDmKmkmH2RJ+VgvqRXMJKytew/U9lJr2bs7JGa9e3PuUcqaSGreLzxljzJAl5PoEBRDVdHUmYmnXzti0ha0W8xerbrVUwlAjJ6+DV7sZiO1fTBt5Ve1vu0qS9tLpTMqq2p6nFVt5cKsR0pRCr0FNl5kk/J7U8IF7A6K/uTI78M8JNO3fWN8kichsOzSUOuV6YcBURrQVIoYJN76xFP45No4QkeJYKBdPNdIUNIiVkr1lotolY4QqnKr+JwtjJTU5kiUVN7lHcdyA686i3sF+UcnUc2c2evFJvOXnJ4Kb0agck7nxC3lIOzVL2FjpzSc8bJVQzV5bT9wYY6pPpchTOTciIElFD3h2U+v7O/nYBa+594rQoloBnvxdJbblnII8gcuPBLHyBROVCbUIwT8XJC97y2Dk0FC85kY3IicPxGHuIPgEF64yidgUyHtY+URkKE++UvHsbJk4FiEq4GhDQBYK6D7uPWP+c3hvqoQ8awt+TytGUgFRCTU9fsVrvTiMLYM4QdI+FdbT8nN7MV3VdSQTi1bLmWipyZHtU4nWrROqkN552X5R/IcXd5m4ls/JwytdHYom2avxS0LeXh3mjtU4HunXidNqLWYxmU+d3w0xpUWhkAjl17PtCs8wL1tLWiUMcVGzEFNoivnEPUeRMpXYlEdt7vNq0k21LoyYRPna9U2SiIc2EpY9qTDGmKE7SVRSh35jISTzl4DHX4leaUKVLRVP4uUHVrb28c3rF/lgKa0Lpf+gZK/VobdYwFxbkvEhVxMmH8R0SqPChMftqFARZwe8ZmIkD/jKlcl1UO6UGwVPZEIt/m7FIYSzlSzxUB8eBjeF82KaNDy8T9umgg7fIrHweQZe+z0juWFOFFMSJYT8uFpZ07LKWLaOB4kae0wiRjzdMlkPkgwevPdLCV5LgND/UFMcigi55w6nKRLnJdnwl1/4fpW1dmpHfiftK1s5FvPE99G0IBPjZw/5fndcJ0nVrtdgjDHPRFvJtSWJtXmK8z5U8tVK0tguVd3fi69p0p3wuB1CN8aY4Jkki4fGMWHYuIz99Jg3TCLP3OEeuWIcdRzcB5C4/HxrH8Qib1qvRVqhpBu4kQWkSUq0To2VKlJmpPAEkVMhQqhKoR3hs1l8hs+wTqL49qWuQ4YWtJpXLql2M6//X+vSqp6IFWw6nS98n7DJjlHVWfR+7fo/JVYqAarKVdljjBIW3D2aUmUwTTIeyqrt4ZSc1b6STLaPYKqvqruw81YGXzMO81BOKbTXFRKhnEKV8ZdqN1w4zkmJIYHWKZPdFzgG2khwHfpMJiKkIGN1EBYVOhFqimN0Z1a7z9/xkO9UikiJUt60w+gK4psq5ukV2TSJ+H6XriQs2b6lGA8VaIdfMXJ4Zuzne3magNZS3HNyPUb6EyWyEzKNMaa3UIUsJqpdZZmtCIjN5rM6TylGFZU6bfHemyw/Hx5HlKCo7zjEQmZ2QsxNmMj5zGSRopxNbwli6Y9iskdZYSsCZuhCa39eEReLZGNCOkK0MoOGCkMngWLMDyM3q3ED3hM7D5F3oiYgjs2jyZvy6ync25rk2HkuxhhTSSAiigg5qTaRuey1RiMWOrMDYm06cQRTtVGeHWLLSCUgbi1t37vw1zDx3EuVimWhLLzWhQZQiXSqeIYr5uZ3l1BNiHkT6evTShQW/2T9n3pnqORAiS3NOx6DmJKuvvmSWfYOoQCo+v0Phc23ayHrQRrsWwSv6bSawkLFc5M7oUxTFAT1SowlRR1hHzNuFefTUzdk9XR3GV9XaYL1et09zQmDDAWIHPiJuf4Tt8i5UFoEvwsOw4GBVAldIAiudiKoMVo7QbWWRu+1clbGeLE/+fo90Q9v0UIJaseq++l7Xq+bosWhJIiVUuiWnazQoqezolh61spPmLqEnB5FNrx9hQle3bpMyJVfydvPvIYVs3NDey5Qh0fvmIAoC+4RVazaIcpq/ehk7hEl6g5GTPEJVHIQK1xXlbFY1TEk6q3uSWhZkQ1f2pBT/6Xc9Au4EFYvl4OHTce+SxAzKbm/mj95X6tD7vl+HnJXY9l+VGqXytK7cHnrwTexAZV+Q88QOdl7kM/D+r7Upqg+hEjMl+uC0zaDnIj2JV0QU89h0HhyTOwtiInTKCGdJzWL5QAhIqYsuWP3Mzk+eofn0qxDMYgppPfaS17DNn04pvu1xMp/JYmwtzeM0SJSnRfxQVKIhWpTKGnpvGn48JbpzbFEJRB1YiJVwOxfTfglVnFqnNP5V8J383Yz2+8r9P5jxQbcpSwJiFPFAzdmltCFF86DHbpYqzuV4CxZykP09jKSjSJukNcxdRNbVz7lOQqYS5DcKgjyanIho+wxjNoh6YXY1NMn1gp99yBuSkqd8riYOsiWilWXo9CxTyXg/AoDufGN7sj7Wjl75hRJ6QIbEmdPlowx5tRFXhtlmHVrfyRfl40J2ZdP/J6SpSTSFzmWfCXlAPlCEIGdbJbe7YWseB4nPueRd1gsrD3DdkaWdAIRFZyADKLVEjFHOKBu4AGc15n/Y9Qe6/XpI0zq7BW8Mca8esjDVjlsFm1O+e085Xl/DW/Aw+b4Ax42wbNZFe+fxYIkk2gh2p1Ck4qprrHifphQm+9N6auoZKbxEraL94exXXp3+1DEsldgyyBRXqJk90KtvBNnT05TNO1FhGnPEaI6cztybN83cBFjbfksqeJTtUvDponWihCbSpn06wiY/8qIZ+4Ayr6mFEpxSjAqcB2r4o0dqHZ3QOgkbLnEzUA5SkYIPX6lCjnD5pWRTLQf8neh2p8ibh6fQFhWZcCqj71ZqE4+FdV+ciHMM7gG0QM7YtNnJD/D483M4itNZmKxQSR4VcbTzr14IfaxFZ9AJUxeYuri7EkmZXvHMhHsujra8nNRMRq7ZBrv1/MbWNmqJ6W+aDXlE4ZZ7UvxMJx6gJ9BjXgOWRaN2DubYuWmwdXxmrNP4xFT0uWOomd9QBzKypRrzxAKsNnHao0xJncrbpARk0m46xZm/R/jG3Nk7rSokuM/EqZW7cKpIWIkV3lnLOXratcjEqUIqEqAy86eD5/K70NZlyuxqQdr2LpQxmJtxQTA6q5sFyr9h9qufC+XBIqjvnd7G+XYVCJpLuLQU3wF5eKpkplGM7g3TWrL66V0QpQ+R1QszwO7QqVqg+wRxW1z/7GIqdHNJMIjp34IEZYnAkl//oTXX0lmK4+N/4oRz45rrQe/ShiKFecmqtaNK6weYl8x82o9lpVo9RrccNSGtu4YR9XKFWLPvkBzK9M2aBRJTmmceJO7FyQUXKI39SrUxMaDeCIRgaKKbzaR/a6jE3iIOqVipbzMZns+ZjB1M+4+I/x8+xoJk36CMProRgxivwrbXDXiuOsqq+fsovI8cZ0o1u47PAw22iS4fxQjU/5u1PY//oBo2ol75B3UKkNuRtIEjlYp22+7O6cxxjz0Zl942V5rAhJ8LAav+S0X703/UG5KC/252Y5YQZGj5Cl5ON5+yQ2tYEZuVI6Z+XwpPsHIhlZOlG8H9rWdivM6j/dnSyb0KA9HNX6pNBE6BpOAqbgeik+hJirs+5CHH9/HcPE8lMnFhFTxJA6c574Z95j38L23PETDlhLB/NTcEzGl7LhgEAvBL0+tLUk1ifLgPgnOSp3x/AMejsqS/OpU7n3R9+MR867KhEG1ZB6EU7NiqE1c6rW4b5oPJ7dOLclhSKBMdfqqIxDz68b7KewWEWHzlsnR165vkkTE2jLUFKmYZb4WDOiRu9nrVxW7cvb0rEKmdJNi3KiU78Y4H5I3c6XlQdXavaPlZ2dhwNRzKh/ANy952FyaxSmO2qKKVaOVdjdRY4ypUYUHixot7VjKBTG7VLVPQT5YRXvwhh7WgQSpxmL6o5x48EsW4OFo7xMbY8zAVTy8FGejXGsKdanVy+bk5y3kzVMnZiVeMC0Pwm0C6XIVSWRFwUWoKzgWiUWbprpwowxeR8JZa5s+Q4DgXLwXPJSbRdlCqNCHdvaFipNsWSA7e/YD1/B6Kc2GxMn47CgCor21kDw3++nBARwNvfeahcYfYqorl9DrOCZ4PcpRcoEwAszbYj5iCinIUt16QAYOJux9V0xOrNrA5OCGMH1TnKM9Y70RUy6mahKj+dBNiK0eSy6K4sk832mdClFqkmqc09mHsL9Sk0xflu2HU1tY7S8QBO/w5nydUp7M0Y7+LKeDrHu40j45FsR9qUw9PiNXrrBYMkLF8w/FFhfqlPfFe1ETG/Pm8Pv82vUfM+BSa98eiryUFWTLXUMJ1SqEQVmBn5rKG//sY8Khjr/wAtpNw4aMIDxUsCjh99H12Ns7IoibmTMwcUkkxIZi3/CwDRaJULa2vPEV3Bhj24RaLWPlpOSy91/jZxgylYhQHne2UHqUdUEsuZiA+CASC5+WrHbWr+O1aOLBMa+HNnMx5ViqkohN13iI/Cn6sw/i+fdUH/ftKyaW6Z15KCu7bdUyKOpvlSo+UZcS4o5iIkKJvs0dyL+vuCmXHnNT2i2Y/atHsyqcGMHq+YqoRh/b7NYvzSRKVmEsE/cw0WMu70NIPnVVMvtzlePvzhKj1qrto4iKHz7zmWvTxzpGWFvwXD6LpKdkWd4jTkLt8ov43ZkCnfLOwyTaf7xwmRSkzOquLAQWneT/SN/Mqs+waAj37wdb6TGRVEw/5elOBFetbEJhVYotOXLqbKPw9Zl9kudQkTpWv4u4o7RGV5oQK5awNZrQFkfhfuR1hEyigOLyk0IyXKyO/cmTaPXf0M74366EjnOqdesFN+UJXVgpK+fNi3OYLXbbwGxxpo0T0SiBctl+k8kJ6CU2JeUTMmELIaj8OQhpqpFRpeOg1kvbqJ5PWVaxNXJys9kSxRvVvxUJsyph2HWLm+2iPfwMbwSjeGETTsWo0cLfhQJoeRu7vU1X+gT0GeqP2E3Rd7x2mxWrUpj84y++j5SpmTDOEYZOdndOY4zpvoFIxN11PSw/K8OsLnPZE48YRLXDs8Jht/okMZ3SkuNmSj1y2l6RWNiM0IzRanx2YbEGws77fpRwjhXy88EL+RmOLemBmOfATYgpv4fI6Wxx2JMDY7Tap91jo9oAHo5/vxXW1UL/4epuihL9LMp9vyJEGEu0p9iWQk4G7uA+pEZ8i6QnYvf3sxjLz94C6Xz/OxOtzut5n98Q03p15jGZUfwyJXudKBX30vxC68auCWEMEYt7wv9CGmaVZfWvxj5VwvDiKqe1HJIw6e0g9nBjhCmXEqD6yvUfE5tSmhBqSmLPCC/EFKQzdJPQGBAIQMZsvOFaLhUW5AKqtLdCnr5mS6ZpEcL5Y79w81YkL2Usplau9Myy1d+zM9uNMWb+IiY0w3tYK/scgmG9UxBXr10kl+S2EPQZXpUW38q8q0+veoilq0pkp+gw6lMcHMgpiy1XOT2TL42VqOrTib3DQ1f5WUOb88AsuICfoVRhqkJmFNdhRHPydVzS8roqCfLNiZmAlR5u/U7U5ERp0eIYLpxDewny8f29ZOcbkUQ4inaO4p3Umn4IMeWyuaqjle8wRkydePQg/N6tjAtiDUXlvPAsD+Ujk3hQDdjO/eX9F0L3lXM4IPaT+Py7bf436TMzSQ8OoMBZUCRbQ0oIS01hRczjCKJJRBRDuX0q3oFbZxZkCmVIlMkqwCVyalOkDydRlGCUUrY8sZMoZK6MRNPitvRALG9P/t9yggju24PVfvhk6/detB4J3+4NicKphKGSH7kOIbPJwwjoxyTCtxN1QlTyMv8o9+t/wwr8X5G9VjoRav0ojLqUs2XNPExKFohN/rrgIpweTSj85TtuuMoy3C7oFHOTfSzVLjk+uR5iGwVhVI2H7upZHrHaQsVTTRko90wFGdtFuUYI74DmlXmwqHVhBrNdpRPQtTsfrnr52P+/IWD/3vVIOFt2lg9I8KariNl5B87OrDqWCnGw87HxiCnEYvEWPuT7jxOdGtPSDbGAVdGIHdlN3ZE9U5moVF26yfJznipMqhRyEios1NU4q8lCzlF+oc2yTDjMKj8Jn+ocZ04t5LYLdrfyM5RyaNlenCZqV5zJvBo/fPyS1eMjwafYv4WFwJQ6/E4K/8pKvJUgEu5fbW37BfblZIpqZwwW6pfTRKI5RUh828dKjTHGuz6LJdV+W7GV97UdYTDGmJdiPNouaOXcihB6w3okwrYRhNR7ylZeJAfhQuLbsRYlucOnMTnwbcO2xI0tPMNqB7ax/LxtFjUXlIdFQTGSqtacfURmlXX3CMEldK5DdCp2K0dQ09dny+RjBDkm/2T9K+0MJSylnDgVAVOthKIOMwWMqla1vGJ6QoiQ2EWp1OjmcMGUVmOlvgLSayM2mwtiZntZaz74KimJFdr+FQuw4qlfwNpGOfeI16Z3Bcr53n7Ozba5EM1ZIWD6OUuZtefry15kX+EJ8vE1qyzzO2F/J1eSTd3zWz//heuEmiuO4aRL8SIk6bpl4WYwWZD8VMvkuhC5cnNhFR+ymONrccLbZPU8a9WiTM+2XOFhrvrOk1aSuJo1Lwm+d8RYsX0k0xhNrFzjwO9O6UnYR1WPCYdZNZK5X7QQtgpyZNQxHqxK/+H8DlZsUQ95oAU0pz/D9fWc9rlVwUpU7SkSSG/hE3JMJHh7dxH2fy/kjKvmI59C2bSrav/VFb6/8LlENn7+gYVgn3HWguz5BlbYqnXhKlRSz+zj/qLaCJVzCinsuZSl7rme97oa1VSy1EubWxOfy7Zraowx3hO4l2TaEo1Y4DBqfQSNIMKUrytb9JKUKUiUKrFQ9uBfu76JTkTdBdb2gH1awxgtQPU2nlWnct0csZsP/srN5DCoROD6Tf7fNeLCBCzjzWqXFu7tRZheEfWGzhO6BqJiV7bfLYUU8jwxkhrsQ9a6UnvMnobwZcdBVlgyehk3h2wCaleeGPkdeTgo0uve29zQ3wqvj0W72PZaGsB+euhZvpf9UWRjHxxsrdBbCBLpR9FW8nJnEtGkEDksKhFsWZYysr3EHPvnD0zKlBaBsiW/apv2mXSQCXQW4X6qJkdSCei6wui9iP0t2opPT5Oz8EMGbq5/fyE6lasIE1V7i0OJVDVyY5tCOTEq0md4L0/EBonWhTK5Ch1DC+6be1nFKiTu1UfrPlGrN7VJlDdH3dJsSVUXLpZKJVPxGirkdEDMIQmvv0oOPgnJ6JxphDigTSuhq9B+GbOPe/qKHUQS9w1lm0JJUnv1ICqgCg13L3K4Lp2NQSxFKn6uKrbCKnwu25tx+2m/fvE+C0PPhiRbKmKl4g0pUy6VHEj+g7iGH6OI2PyT9U2QCDsZUlmB37/DSkGt5mKTV6Yhrd25oSfE/8IYY/oICPrqEf7fpZOsCmXFnLmxKGfPypX5fot0IwSbKDEfXjV18eAtD5u3YqRLrcLpHBBbPdWqn67MwS6cZIJTrBwr/YdinDO8BycFJq3jRh3cmgfm7r6eiIWdY3Kg1vmx7M+uibb+rqcQ0Wnv4YLYCzGSrBKG5kIc6uJjVkorxDz9yYfKHl0gAGWpE/LEpva4bh+Tr7LF+N76T9qJ2JT+5CEpE61MwvY5chgVAMsN5f8IC2Sb7hehZDjZ5mNy7gr5KpsVN6UR2x49hVBVPtHO6ubJ7zePGPk+VJPISdBRoi77RIJb2qZDEzKK+1KV3Kyme2xkqzHiNKH73rXY9mgq/GouveA9N3kLn/W71/kZ/hCckL/FQb0/yFoIpivTA69RkuRx71iQKXnsoMkkvZ5fTRt1+zSFMcbs7cm9KW9PtnyVd8ith0IMzLYU/0NNeqilEoaGodybH2wm0pXFm9+nWmqc9WvXv9LOUEjEeyFyoqYzTpzgQ/mzFw8vH6GxsGc0H3JVAU+py4w/MpIP0tKT1hvYoTw3Vu/AJYipyr5UdgfEVCWu1oJ9/E66Hqd2hpKlViS3s0+tD01dMSWyTaA1HdYSCrwosvjyDfnw+g+iQc4gAWnOF5DumftMVJSQkho3S2dT8SwopLHtB7Ixxqy9xHbR5fNMZmr6s51RIiMTkOZCqEiNjCop8OHL+b3Xq2StirJmdcBr2pUgIuLnTr2SfGLUWMlv370Sg9hH4Yug/CQyCmO5dqvI/7Af6GcE6TV8PqFml9RsjZbwo9vhEjHO2bwiK2UlBb1d8JWUPXiRjHwvx+9bUdd5B/hMK0Kmkv0eLxLc3vNINox/EY9Y9Bzya6Ji+Fm9SvLeCZrN5FCNuNoTtVcnWWH7r+C13xHB/SCV0Gux61AYo1syiuR4/h73kqrleP1/Kk80TU172Fe63/oilqEsPYLUUpNeykSrlyBuq3aGIlGqpORr139sxFNNSQyvxj6xl0gilP+FsuBWduN26WpjtJ5E6XKEVnNnsFZeSvQpeAwJUmoVSs+NWiUgxtRDpFEZPtCJhESqa2dm6ArtuDXXym5fcZaH4zGha6GWkpr++cd6iGVMzUOk5mX29hQsr7gIHz4z5W9ZlN/TaFuFfuwCk4O/RPnQx5to0vahrNg3XGbFpqr9jeN5v3rmZWthrJhGCBMJ3ebr1sO1b1Xev/5z2FZTltkueYlYKCvw/VM42aI2vrYLOYK5qx8Ti5vX+T/+qOBi+VnJqisdhmmHuW+UqkeIN5PwxGgrkNPLQlq7heD/zG7E8eOlx1k92+XM1VRH887BiMXuGYXYLUGYbenNgqxraRfE/hLd61RCLr+aGCsPEhMghWsTYcvWxtqq+fI2Hq9R/h+bZy5B7NzCqYi1s0nZG6NF5M5tZUuuUCCRiGtivF+ZodmXal3k6srRXYXgqOVYg4e+alOEz2QrzLd7c8TUOrSEiLjpzHbxP1nfJImwty+U1oPiP+R0ShixUqlTqrHPl29YFTRdyAz9wFiqYrYWBi52HYfwszz0ahXiQXBCkMHsPARjjLm8goSj04JINVtULcopVKnWHRnALNi5tVWUatcoQsGx79hCUWz/V2VYKYWcZFJSNR83JTWJMvs4P+syYV62RcCSQ3YKWPap9b57dI9tNTVhohKyz++IsF0VRMj+YrY/+qloXYjDtk9D3usjxVimfZw3Xox4KrOxmsL/RCUCam0QAlzNCpHDU8mDyZyy0Vb8hPQ2efTkYvywUCc6e24T6ozqf778nVX8CJG42a27jTHGPOF9GC9Mo1YJGXE3mwaAlyeTPu/2TDRDxV6quCmJBIoR/4HtAeVZETqTRVrH5WTsx+0mAqAko2+utCKxpYdG4DVqJcpNFLLXFrZBC2VmQTZBmP5FLmGLQ3ExdnWn/YAiVpoU1sSiynT6qwxowamTFkW5RzrXYUs9PIiJlXLsVKuZIIKnL8+2x39tOyMhstfKbCufUCNTOhEKiUjdgP1O5buhssCTsS6ITfAlYjFqu/XGXCQEo7ZdZ2JRz5UX1LUcf3eZ6PVncaDKYJeK7NnaWy3GGPOTGJl1asnxqsjx9Sw/7xBCUGMm8tpUbeiJmPLwWNSbr9t5g8lR7XxEAJTC5pEhzMazNg9BbGI/zpmPq2lFFKq/ZHI09wQ36nFdmKSkENocT4XXSfYKrLobFOA9sViQSD0E7yanA5+njgusyfH66RQRUqJEv3/g+y3lxkRAGV8pA6bsQsPk2sN4xJROhF0TwhhjCja2krz2LOiK16gV/4kHZhrhsKqqfSUYtX0qK7uwaE672BEhY4zJKtQTs9oqW0cx3hon2hQ7L/LvP73Ffn3NXDwIlcT3OjEKGTqtDWJdw9lCSy9k/5V4U1IbSnp9OtFKNWHx5TWLlKB6TKoTiX2ulTioc7degljazOSdrBGjsFFbSV70aGrlHZxbtRavyZWZEyETlm9GzLslz7kKuVgYqvFT8yP3ofWXuYeX96eeimqPfO36JkmEs63PrCYxhu1ipqgSi6ojmLWq1kWhzqxGXIu4IKY0K6qIcSBFtjyz2zorXlr0xJVK5gDBMk4mGPAqYVCkPKWTUSkfST6KY6HEoOxupF3KMEmZlJbtp5GC4Hq/NKtONW6oDiC1lC15dXEAzRtG/suea8pcxrppJhWV7ZTBPFj6jOXhdeIcE8bK+Xl42ad6jDFmj3COVQqQc09yEmdwJVatyWwQdIbyfJZmC72Kae2pE5FMEBwVsjFyBkW/Fu9iP1m1LtTEQu1JkYg5ulqT+WdCEfNkENsqY0WFqSyTPRrWRGygJ/vfD4Q648Ra5GZVmkShokHieo2ztRtypGNimNeH5DhFGAzKRJ5Ayl94XytPEMW7aDuG0vVqnP3kNCr2bgsnN62urY22vxcRxzfCvCptTt5Lzs3odvogjElP8PEYxJ6vCUAsXSWiKco9tfpo3q++naznkJrOsAtSGWNM+YAWiG1exnOuqxBMU+OnCjl0/G0AYn69+H//aw24ErIi9/KQJv1OL9W6cC/JB7VlOWajjYSipMqCFbHS3m4YJmBl9VBOrkOIs9cmfn7FxlVjeTkdWVEoPsXwAYTlRwaQSGY/qOYv5iEdOpwtjlniQY2+wfZAnmyspiN2kWUeLchr9x+z7TW8Pr/PfOnIk5iymYnqNZtYTYxAXbJX52c9ITbgvpV52FwT0zknhxI5eSG0Hl6J8eBVK7kpJxFJyd5+npafc9ZifzZcPDf9xhCtyeZPnYQurZkcX1/CzVtpWCgr+EyZeL0mtWYSNXSVlVzXewknYnaICZ6rd7g5jvUlT0BNxPwsNmUV23WDSeSrOBLGnwtE4ahNYyL8Cu9DhboUabMQMdVW8VnB3XSIKIxUr79keRYHt27yuU4nnHjtkxjGGPPaloCeuM1ro9pKFUUxEz6XU3O3n/I7HyZUclWrJVEW8vDsrqPGaLltu49H4EAiWP1FQhp0hMjRuu089GULRSiMKoRBWXyHTSMKfWrjCP7uV65vkkRcuWEl4SnZ6/kCdSjfl+6BKjlQh20aYULjkoow4jxx8KUTzp7KZdNesY8SqnuKw/BJeDjM8SU8/JPo2a69QLhR2Yir9oirqG6Uj4G7jTRVycsNrzl0hySqeHHoBdbkw6vGSn8WEKR7FvY2UybltUki4DvlWJpW9HsjbMS8R6KdoZCj7VujEVPW3TkceM+lbshqJHt+F8QUYhE6ktDvladMehVnw74ih9En45bwBBncmZWidz4iUacf8F5/8ZH3hGqZRB0gee2+sGpuWNn6/AfPpJLsmcckMyo+0LgdTPrfigNeJYyLmrG3vUS0M5Z1Z9srmXBnnWUjA24dRP2D9VeZWJwPbYeYSiySC+RAJQxvPxJhOrGM95JTOb4/+35ojDGVAmYhdnZFL8vP1caR4Kisu9Mn456+cy8TQTUyGe5PVMCkYDGzZSQRzIbjibBVnsbC6npQPcvPmfzD8Jo+QmjQJz9bmXkDNyGW0KX0H2L3j0NM2Y2XaDkTsY9facD1TcSmio+xVh6qhZAhA6tplQioiQ2VbKR04AGUV1wsryLcDA8LAaoVQvr4QZz1wKk8jH4Cw9sSHlZiU7nzc4xStTialuTrSgq3x1TJ+buuTflAZyjAKt69oPU7URbqyuK3XFbCfmkEs7vnZlZAtQrwdxWMrhKGE4/iERtQicmLUuw8bCNSKnXOxWtIqs3kwoRhTGPyZladY7tIJYfThCxxYWG3rmSe+wkJ4lw2CeqIQ6x2nt7joffDTzxsFggNi4CR1Fw5FEQDKicxulkniGhKy0qsMpWN/AfbfecjJN/rCYO3fWLqZqrgTSkr7PXKO2UKDwjHIhznrSZGAVctJxIzpJe1jTKmH59Vv/6E3xV3IqA4W4hKMKzsaPa/lUx5tnRMhF8JzYYsguuhxMBGVrdqVqiJhVf3mQgofoU69L060jviVBiJoCWaCO2ET0zINy+lPLSSIPdtYXWAfXacB3IF0aKb2ZQJ6dmn8Yidvk8UVnFCnCvx0C/fUphtCf5DWlf+vQfBJCX/k/WvtDPmtCU7ufMiNR7lhlj10ezPKXRCGXqtas3stqPQNpglNhcFkd2O/5/7+MfvsmK/Poc9W/+VhGWPH1GfgRvVktPsk3cU41v9+9RDbOKUTYiN72+d2FBIz86brIqUTbWCEcvnckDspHhAVOtG+YksFK0gJQ++cwevdd261gdYtVW6t+TGqky5CmYgZOhdiIeSanGtu0TkRCUMLRfSs2FyEzfEetnm7J2E1sO712whZMpG8pZK5mo34NhXB+FtULKAMLkS0wlKbjutsNZ+9sZa02Rw4uc6IqTLlZfO7Zd8fvuF8R5xdCRhcP9SzvuHXWSiolQsVRU/ZoyNwyW8SZTplVJnrDKeVuhVSnNM9ahoq52IYQH1PpYFg0d2Fi6XRSsoX3p+d3Y7bAX7z1nGa6OIlfeEvlDqPPzuSnQidK+4DjfDOiIW84L/o+1sIhF2RUnVflCJhZqSiFjORGD7Be45TxLoQ7UxgMWso0giXpzjRJgxX5dEfBMkIkOAFUpS45zKsTNrDm5oi1pyA1JKlKqynyMyvriPhC+DD8cgpvQk7EJV88So4SqR2bu1T5gEa2JBXuzpz7+nJhbUAdxSMJQPCDfOfoutCc2xkaxEF59h4jJ9ORNBu+aEMcZcEptN1SYjEFPkxbP3qB63SFzX7ddE5SnGvCrYVBsv3uVGFeDpgphqyRx+QO2MumISRyk2ehRj9Xj5hvh7CbS0PjTdqk9SoQ/RumFdSHD0c+f7UFyfQ0IVcWorXochaykQNLIhIejiWXgovRctiGAbX6ejEMzqIBLyMUJATo14ZhETBvaJEGOM8fZnBXxStDPmtuPm/cffTITT/WJFbDZeZ5J+RvA6jkSITV8IPL06OBYx1boq05vo1+kgtnIDVlIMSiHMR8UYsV34qXBvtqQGC1KxKsgUgvmn4PocvB2P2E4he66UKM077jn7F/dCrEg2axGh2tbOnkQ1zJf/2czLGGNeCNG7LR14HnTZwEJIaUconoTSndj1lToR/0oSoaYuvEZxY03oOOfFOU0RU4JR+Ytww2ldnhn6c+HiOWUZIW37ARklHOUUi33SNm7K7auwV7boQAxi85rx4VK9SI9ePDQqeJIgNb0eN/RLT60P6y3hbKgsznM2ovKchxfnjlOIisou3GWMnjpQkxg7hIy2qtoiRYX69KP1wew4hqzoPZOZCK0Q8LhTSv7PsN1Ekx7diEEsfBzhxhSJ+PdmHqFOhmdeHsAbz1jf3yRxiLYKoUbKR9ETPyBGaI/fF8TSED4jSuthmiCSNRVeJHMPE9KeaVPArKdaI9XYQgjZwgRyqyBgNhPKoWrUtEQjCv/c3Ea75QHbyafJ6CD4WqmtpERXRyIs9UZQhbZFYyKTgWW4pymeRJ9u3F/zpmMSVT47i7kmQl8nWqC/f8cQ2fHu7m/5WZFeI/t7IlagJ0chVdsjsBsRPMVFUOhXuiq8hs/2jEBMkhwdrC3Oph3q4SWrQljwKjXJuMMcIe0YzoQ8yc/kkrUTBYln09GIpfXgvpk/PwvXr00i/hUr8MaijxkxjKxwtRTXQS01gqRaHGopLsY4sZHYk4ZsQlr3wX1Wk7U9eACr8cu0wqq47VJu1MqC/OwMVg+rhUGWGqVyTW890NV8skITkjsLY6kq3NCHrWP7IXVyMrv/FPmrv+idHxK+KwdE5aFG+uxGZVcXkU1+UDhAphWck+lL2GpYM5j3da8V3LxUwjBP6FM8EqOwaQSh8+Qh66GZ1IctulLCO+HoOVbTfbdS0Ecd+rnzUhVQaREcjyKK9ewVr42d4GsMWxBZs7CaUpyTQ8PZQngjEqZb+yMRqyP6/7kqeSJ2OIb3yfpFrLKVzfeVZ9bPr5KILy+JMKjxU6V/MGUQW7l9JjJhdi/HZDPgIAuyB2toQZ1CjGoqGemFZ6yj8MeHEK1QHhPvXidsDDxoKDkRsb0p1KRGMJ2KEjlSe52aingWYTXNUuTIrj05BtumKM+DvD1537w4KgTOkvDMmSRIlAnVhBgjNHy+dv0rOhFqFl9VjmdiCSNdE6M1CgH4UbD9p/fmzXrlKTevm0940xTLQCavHT1R7Zer52MQG9qJD9vRW/ysSuuhseCJ7BJJhDKD2tWNY3ntVrNSWL/MykZWkx7jhEto3RrcgMLO8FAqIw6vGnlYTauRuao5eFDVnByJ2K8iEfwi9PPtBKnGC1hhNf+NbSDVd48Sc/JlB3AzUGO1YwUB7W4M74kdfdmCKNVnE2I581sTuvOCqGUX2jLGmKmCqBc8niOePwn1xEUCJVOiX+qgevKEB8Qm8fmHVLYmZZnqkMyXWSTfuTpQN0aZnh0KY3/67Scm2gfEnnNEeEyYZGK0bhuTMrufiBKkOrW4E2IqYejfmSq0faeRJxHYkQhTyiTcN5UpVeBGFgLKO2LFBHpxdLWZyEli5Q3+fSV6FXGViNgcsTfdFTb1XUpSY0O5Z5puFOpSK38fK8rw6jTbjMNsExzGaLPEF6dJvjdpKPoWMYccjgSvz2yPVB5ItOfNahZW/2T9K4qVSmyqcBfKPisDLmVL65ScB4ZKNqrPIPR5VxAElYql0qwItsmhFs/Eg7DhXFbTC3fwwOjXkFMSX4QB01PRF3sgVBGjTxEyfvSSm3xBZ1aK7oOth2EB4VhYTFghb77Gg1WNfd56zM32gIDllFOmkgePCuXmukUohY4Zthgx09ua0F1Yx6praB2SnJSvwy6hMdGpCROwIul5sBxOyQPz3AtWcXWmUUp3utD733bJei0mbiKsPuRNNGLj/clrOLaSM+vJkwqypWg1qbVO8IRy1qd6pvK2SGErQPxDyQnYGshN38+XXCqF/pTvSr6SqrrVevuFyMa5Cm6MHWNrJV1KKxKnnnPFa4mcSlSj3xb2xBUy28qNvDGF/iV0ekK1EQJDeH3s7yWHkOg/c4XfpYvgzf38I5O5TYKk/ElMUzQV/J/nJzgVs/sa95K7e9nOyl7BOgGirLslX2HRNsRuRrD9kEoIhinDLOV/4dfHHzHzhftrB7+va12o9U2SCDvhRulEOAuTG3VDK46BXX7aGGO2CWOelWLcUll1D93ESuGysBx+YEMK4n/nIZIyJWH6RuX4WXdeZtvjmDAbe32PMZ+WrKgUjP6rsG+eFkZGfecm1oOkoDMPvVVCnVOhCUonoO8sJnNHVrHyiF7PqiCl+Ayqj72kLR+G2qt4GL61tXPClzJh6CYmhxR0r1ASNVqnxsPUvV6lIseZbwhiaWM3bob4vbv8PZUsv/zA5+vuj3xGmrdhz1ax3dVoXc6WVBns058Vaxeh0Nd5nbUv3EhwmpRj45rNRNzKuTD56tBeGEa1JrPfvxkTocVhvA8TiaJHEek+2NqZ11+SfH5pHkdoVeJ2VHBYnA/y+VK+I20FYXJjP/699+LeqRXAQ/NBBMsv9wFWbseZfXy+spYhahp6lmTeTsLFtEBm8qtUIpSzFwuonbe5Dx+6xCRiV3e2EPestR7812J5DRVKolbuSiRuqhZK12Ec+z2Ukvvwmg1EptW6ILRZvnZ9kyTCwUYkUixee8vDGGNei0pUeULcEkxmNZKpDL2aLWLCMLoeUQGlCll6gBW+siMTxhgTFUFYKks6blRqDRWjcDdfEJ0plJHQp0IFlMlTiDC5ajLUCsG3W+yP1xwTnIMlIsFZLKywK1cmjL5DKNSpdfAMr38mZ24aDYNYsSumvF1jInsaPqiKWOjamqjGb+fY61ctnlWziKYMGUWjLmUs9jyWKN7VR9ys8jtavxPlROqYjgjT5LWslE6Mro6YSrZypuEzsvIC21lBgygtffMF9wSFRFXKbUXA7BbaxhhToicr9iOTiExmEBoWaq1LR9StfwUhGuTKJLJwZibgWRrPQaxMA6vcsntjtsYOusQjtk08vw0EYVaRg8MFR+rIerYk/qrB57X2YMLeHg14nyjyYt8mVn5Ou5Lkayg1yU/CROq9cGy9eJ/73J3ZJC6P2E1EeM4y8pruhdInRREr05a18m5eRHEPUjLVColQUtgdyjJhKiUK8hVbeb1enec9YRKxwJ2VwCTnn6xvMp1Rbor1y1T9T3uiYYwxDYUD5EaRROzqwcN7xG5q5edOy/9RSrQgFHs6dwBHZOwcixOiJzqkMnUSlCrcXkHe23KWEwCDa+RBzD0zNzkl6DSyGn+35yYeGjNtN1KD2UyElNR0QlGH3v48zFOKCZPquZjtDxF27r5uZBTPPRiDWOoUfGgiQq3ti40LeuA1SsyqYykXxEoNpYaJl2CFH4nm5j2oAb/P0eG8hmp6YkRzkibDTlj/xzPRE1Z6DU/f8zBX6J+9XWKMMZs3Elp9tY6GQ2ka0wzsWgg36tcCFRmw3Zr0DxSiYspq/MkDIomfX7DCPBbCHvNCUQGfE7LPZfPzfl2+mYx6//q8XjVyWlEcJZi0P4SuvpUCyVdR5mAymalAToCvICD2EwlTjvQsyBx9qIlhXnEPe77XKsGeoxPhd+8afB4U56JPIEdt564mupo4ieD6dCZZ3iMrD2XVRngolG3tJHXFr0iUl3vfl+e8v86v7IFYt/W8lxKqTlnIxtcwxpi409yb1cTG14pNfZMkou4C6+aioFuFOiipWsWnODuZmawy9DnygL+77xpjytviB8H4tutEBA6ja9uPqQjxJhHugUqA6txDQtB+k6l2d2EGqywlQKW4GKdHExVZFGXtd6pkRjmHhkdzU86UmiiJwy9MGG49E9LNGblRKTc+1T+2986N0WOvoztbE1D7aKQxxpTLy55to4KsipQol1JU/FNwXZKLaY8NoiV3PjYesXFiZNhurJYnP0lZj4UPiUJr7I6gxhgTLsZq64t7c31vkvyGRJCf4SjafptnLkHs/A5rL1p9v7cuEhGLXSkOx218H975ea3fCuh+z3X24pV6ZCt38g6ai+9zelM3y8+q0m8lWihLQikZfWwOUa01l3lfjxBFxQ7xun134hFrWpCJexExKXPmHn+32bRIy88JVaf88oGJsEpS4vbTJ0Z50wzZyecmPITfu9LdCJ5PAq637RlrvozJzKEVJFo/3z8GMVehnTG+NflVAZ1mIGZEO0ONke4PG4jYDaHh1EoooP6T9U3aGVE2z/tRbQlx95xK9rASoFIy0uXHcFSlUx32k1eJufO/hDDJO5G8qArNbt4ViFdocuie+ZTMffs74bYm45h5KxGteSdiEFOKjd3rEebK1nYlYuUqWL87pZLZSMyJXxOEJt86rLo6luJYWrcNzLJ//8Jrk7sV++lZXVkpKa2A87MI6f78o5XQOX0921uZHHkfNp5DdGZNZx76d6/EIGYXgjJGH8BqtLRUZm6u27qyf2x3j+xRjZobhQTBc/4pcl32DWY7R6FT5UqSn6CMqiqLg7qcEJuq6spKOcpmVLVefPY7L9wQc67K3rxfIPVlquQjmpC6qpixL8D7+ugo8pDyVuZneHB4BmM2Cf1FQ9gamBcZg5hTLt77CjlpWZhJpHLxnLKLCO65g9GIhT5nkRI4gqiTag80rGflXK0Oj8drlDqlEn1SCYP3fO5NGwPIkVIIS6PC/AwHY/j+8qdhC9V3kRUBGy7aQBfPMxHYd4NJyourRCEDuvCZU6Ob69pwv1aEznzObGc+fk+E5WvXv6ITMWkdN+qbAs7ceJn91EZCT9+nEA/Whgt488734wVUipURwpZ59FwSmOztDEVwrFuQG+boGsw8e2zkIZo4KSsbNaZ4/yUTnClKoY8DEKaW0JOwj4euOs9NKZWoHN/H8gBas4m9+PE1meAt9xPjge2J7JSqTHMlJweO9NXNy0ppy1VWLf0nWcd0O7Rl5ayEaqoJl8U6YtTUPGfiak9cjDGmTmVWhSNW0JTq4FCaZjVbSmLa/dtWVOjKMxe85qaws953mtfwvpD9HdWQ95eSjL4q7v+Ro5m4KofKMiJhempDLFXLY5QQeFIkXTdfkkN9CjCJaNOdz8jmPaxilXmbceZ1DRKCYe4ZrXyS/Td5YK4XB2GvLdxLFYk0WSLec7tP8bnOk52t0XN/cc+ZN4cl0xDhqOpahIllg4JW7sjOAw54zdSOTKJU0qv0JDYING2MsIJX7e2unaYiFndiBmIZWpBs++W6NYn4qzoTnFfnmAi4pmfy+YMD96+/UxLVVuuK4EhJj406nIhSiMXHE+J1/2B9kyRC6ULY10dBkFl2iBvw4gN8APvV5qGkyJYJlbg+IaYiPKvwIthHMK/cYfbcsxxhf6W62TeAvI45vjwwa80gWSdPerYMlFTxEVFlPr3KDdducZ5GuJoOmU4Y1b8DR7yUotrsY/x+0wk4f98oEvAeveZGnU20TAZHkDsRsZm98j6drYdy2C62fJQokSJzhtggaWOMef6GsH/V4VQeTC9M1J7eF3bQYoz06hW2kXaPtrb4UotrqL6jArm4US1pzrHPXVf5Pw8MZALWXCQ4v2QmStRpGV+3RyhKfrZ5p1yJI+IWF8d7xM2Hss9jxrHFoSSpLwlNiAnC/2fDNV4bxU9ILxLwuVHWZ9MrLxMoRch0FyOkynMli/D/8BYTRnmFx0ptkQhefcbv+M1LXgtl320frV3fl/o9ahLDuyDRFMdSPRAz6V0QSpuThcDeIRQgMyJhUu3HFKlIIh4wy4o61WrJMVCFHDiLIujvl0R1zR/ch0KatEKsoHDwVbyL2K2U4FbmXV+7vkkSYT/Q1YinfdLBGGN+TSPglnvcvGaq/rcYGXX8hQ/vkcPMUA+MrYOYGrmK/916UTMKdb49Qk1RyXTfesG/79aTpBnlRREn+n0pk3BDU9baa48xVqC5dVY6eAzh98TJeOMvWU6izv3lFIjpIEzP4t4QTQk8QFdUZfyUNiUrirNCljqPO6tCP9us/OAqJOptFCz255l5rV8JufRMwoshrC/bA3b5bWOMmbKZrYDC6ViN/SrsxjPZBJfmC3vkVsUTphPg2pdJzw51wIvR1bblyGEpItQzu68n6nJNcDZ6rYm2/DzE2xWvWd+dLY5p7jyAlEpsxzkc0zw2hvLQEw9Sh0W1DFoKRLREIVaZU+paeVhXYnkgq/HT0FVMjN8Lnx+VgJgnnP5RY7rnV7MlM38/k77P95iUOv1KVKDmoE2Wn7u3ZQE1XbjaKi8K5WyqFCArdeM0leKwKIOsn0RLrksj3sMTllvHYxVJ8dAqPkvpQohqePdggrt5GRVG89Zkm045djo5uCHWSGhMqCTqa9e/4uKpVBwVd0DZfgeu4wF04woPDOW7MUgQutRSpDwlJHX6kbVCCSzPrPvmS0LBM4/FIDZ/NpOoAuVZ7RQfSm/7vaICVITRmEeEqpRmxbWL1n7nb9m4saQWY29OGXhgbLnKlpRKGAYKktf90twMauYVcstCte/xKj6EAWt479gVJZMmY0KSWnAi+niz3/le2KOfesDrn/VX/r1MqZhsKIfKFEkS9kj+NsrKp1EKnr+X4PebPDGRo1mi6v5RkEiVodX156xYFx1hPz1WzNS/FGO/dp8UxWl6JCS0PwjVyadvmfR18uE+NGgHD8c7sXyWcqRhkXL/KpONKqX4nGSv2Mfyc8RKejgMqUxey/wF3A+U7LdCRFaJRDssiMqexQOJnD5ZzhHEDZVZ7dcrKFrNrtYkqmI/Ep5X7OBercyx7q/lxEqRPiQlNm3FNqDa578Il2DHsnRsVVofdnEpdR9OOsgzwllMA54Taq3ygBcmWrUKE2HqP1AI7QmxqdD51HX52vWvJBEqYRgtSCgK9ldkS+W7oUSJ1MohDiUlQOXhwiRi5l5rJn9mN6uOKcOJHKjl1ZiQnvJJePmUN5drNeEMl4nfZ/QCQl9pkjMbT5PMetlrTqZ8q2LnVxnMhze+DJm9b8Ukjt9kkmMVLKskvpXM7++ialGIRcYsVlSseUVB0izKzzBX+FooDkNxMds+oSarZ0VUVEJKe+6Qr6PW4WFWqDboKFtIXYQ9tHIYvSUg6QfP6UMztjanmtYe4Ma/tRfvHWVp/fAdORt3n1mTsmFi5HdRM7ZfXNJx3/DIxCRNTSL0F/4UHl3J61B241lGcTyuVU+Sg+fNtyYRI8Xn6l2Z70MlB2rs89Vm6hosOMlkLjSY6pxtuhLFSNuEh5JSxUw7lMVcOVvLzCGtA15Tozw/a7uenvyfAiVQ0x59y5Njka839RmuTOGeoxIG96acprO7h5ZoQk2Ipl14Hqh7v/NvfDYPCXv0tMVJ5laW4dJETFiQt+lDxdam+76uxfGvuHimSMUHWo0aKsGoDkJh8fIhQmspM/MiLBPjZjsFQ7lmHrZbJu8j9NfEwwpfqhG/PdfYT1XcCWUZfu05Ic2Hooqft5MtGaU7oDwA1FTMmuFWLsKGS7wph1Ul7J88sVDAW0UFvD1LNyH2Sw7Clwv78HrdEGTAaDGJMqoGUazqEzgBUcPGWamY0wGvyZ+O/IdfhIjOJkHcXLafh3fKlEzcfhJeLzOVaVZ3VoqqQjk2y8/ys1MqVsmBQiNkYi3eN8olVnndqE3ZSfTY7eOnxhjTtRlJz+8/MxG0V7E+U3lNIwax6vToQG0K5WKZNBGf4QpCO2CoqJTPnuQekcmFRM2ybmx7hM21KipeX88NXo0yj9/PZC5M2GgrQye76JMxxqw+Rt5UZ4Ew9FvANkpKB+7r9y+Q+Bkxw1rMJBH3/sc/eE9nFGha0cYk/d3cMgSxpIJYOnwP902l4RP3lt/7/gXCWvsn2zORALTCGGMyteDBrRKyLzGc2FCtC2Ws9XwHxznV0T5W3E8TahIl/ifrmyQRxcdYH3SlTnnlBuVG8+bmw6taBgolqC0quytCqnmyMFdxS++A2HTBqLZDpLt2shJdOYwbVUEnQlDq4p0QcOOLJ/GIKQKiR5u5iNVuxl784aOsFFPZuChHhGLjMKH2dvYG+R+NBBIxdGYkYukzE4LbPYjozDAx2z2hNiv7imLs90kU74mQmVbfDeXNMmwDH97AmkyiPgko9OUHJm6Vs7M9pKzF5y/iATmxH1G3B/HkxETb4NDh1ZlUKTJjRC8afOVuwI166XS2i3qJg+X3D9xIlZ9IgAch/j8Eoe2TbTpJudAuEyqZSk1ScTjGi/u6YgH+7sajrOJvbONBrZQnFWJRor0tyRESx0q4S6mV7hDk27aCIzZUPEvjhSmbncxqjJbQz9Sao+vetUkOh3tmCrZGlXGX8uHY1o97xKpLfJZU0aOksFcK6/qMQtl0720WVn26TrEGxDVU7QLlCTJoO5OvDWI6J1sbJjNfk2w8205rgJRJxVjfP1j/McXKd6+JOigCZkL5FNPrMabIm9lzs1Lo7cUbzk6iNIY6EfOO870dvknUYVR1PqgBYkNXktGqTdNaoDPBYrKjwkBucmdn8OY6ft/6nmOFcJeazrgp5LGribHHfDl5XYu5MLHaKxCQn0XVokY87U6kxhhzdgmh2rQ2prxrN7bQVvZnEuU7mrB/T3+iSUsjeCj5VWdmXz0nE4uzwnmzoegxK0TBM7c1sa7jyrZKYjE5U1VcLzWxcU54yYR15OdX0xPK66PSNI5Qn9tMBVC7GZgyAlOH3jPRQssk7psqY6jN8uI+k5I2rT0RGykOKkVoXD2BULhd7fXoHXIuVk1eiJgiFqrJjmQ/s7Ltv5ZFz1GRuF8WVtjqoN4kCqGnF4hEmqTWIvLZRo6LKvvtyv1JNO/SmiTa+WHUifjyiO/NsRCTubjj3NfiomjKNUqgGMs2W59DNc4ZG8mE/OgdFtC+gWx5qfFLlRy0KMk94qhQU24sBMNCha3AsmZErP7J+iacCHvSkD8PN6XYZ8zalDqle0mSi/bt4Sa6swDHkkqUdEHshZjtrpaXiUWeLiT/uPS1suJH9iWz16szbVRV2+PqESYCFUX/XylbNhcExFbC3XBwO27yRbpRctYltxVuHVyflf6RGawUem7mdSgqpIDtB7cxxqyOJNJz6zwf/Kg5JHQlF2RDDxfRghCwvB09uDSTlWP0g3jELgbzOow/QDh7XEs3xLoJX49cQjRp0koSQWsM5/cZ/45IxJkH1gp1yjpWJ4lF+6l1dT5fqq2weQGTrQXFuHkpx9ZyWfn8Kz+d/sP9EXv01trOCovkAa9GUmtPikRso0BddotWyDvRBnzwhm01tdJmJwLQZAD1T7p2svbsZ9ZnEXT7Me85exvEGGMmbWcPO4mA87vXYtKjxpmrCvXMOWIss10/T8RKdOH12T/F+jkGRBARCR3PQ1SJWQ2uxPtVja4mEtosDmKsfOx+tm4cPUjeVJyIuV2t/IROwXiJOScMrhqJkW+5hNfFQGGr4NVK6DqkZsJwpw75FOVFAvq161+Rvfbz4GZjJykaowWNVDtj0HoeXqrHrFw8yw7mBWxSmw/wofN8GB7GWDPIcmVJBqpRgBtm4ARWWMO7s9qNOM8kQhl6jRnMg2/WBsJhp8YQClceG0NtY47Kr6JBER5myush5jozWzUBUa8Wx9LuPiVUq5CIXBmZMLg6scpsUID33R82tRrZBrlN6Dp5GkKw+0aRlKUg87WXeV0rZ2dLrt1sSjorVchxgqhZbaK1FdK0CjfbekKdUfnGVJ9KYu2qjvQdUMnh3puE1otl5HcXFUvuUEXhimofraycwwGvSSNk5TuIcbaTI5gwHLzFllxKYRleZyhRPTuXyBhjsgmegOJn2MctHxyk6NFAMSWiZLX33mVlO3HkEv7PxLzWcbvJJ1h1jm1gpdjoM5n8qhszKcmfrt4My8++Lbj33XoYj9guYXCYSKBpqsVz7CELUrQfjDEmBZ/DxFl4UJ+azj3XPuKdxyYgZowxEyN5zkWc5PebQcgFKJ8MRaxUapfmLZ+vRDmIMPQP4N8bLKaC/sn6V9oZyhNDjWq9ETB6pky8edXfU06cZ0VVpIyf6hcQPgOiUjrzxNp3dkjKzSYsihoDi5qyUmokkAMlN52zLfuOx6ZSUU8Zep17wIdLmXLZfULKDCJh7vPvrH7vLKCeRJuV0YhlTcuN9eYTXhsnMfaYVbhs2qdJjDHm8C1OsRw8RGTjyHirgU+RBhQlilpDUlJqMdViT0iMMWaA8GdQRmCZHfj3agoDsi5rCA9fjiYbfbaNRDxOyHkryWi12SptivKBnE6wC3cZY0zZLA6IeQovkiKDmVhPbeGGmN3HoqwYPy7ai9X5gp5EHY4LQq6dS2KMdrZU/e4MBbjnpBBaBOWFjoFfIWu76ZnQDVHvN2g894M8lfhZb5zn4eXbiMikquzdavH+VyOo996yJZ0vNfdrewsKfBBjzLP1VDBV6pyKw1F8MFuNlyYxwc/TnfeJmuxQQlWrAumeWrXRUMvP21dRsbJWl/mIqTaFIks7FmcSpQS+Spcn/2ljAAtopbuhSJ4f1lPr55+sf2XEUy2VMIzzY1+/mDOrmPBLRAlaTmP1lC0HNy8nRwr1KGfP5QKJsKMTdmTCGO31oQh4i4Xss5psUCtbOn6Gaj+yiiuUnkz5KYfZRuhuG/2LnsoxNSU3nKM9ldK6t2AiNEA4LzZbynZOAWHApbgYJ2ZSvGv9KV6vtw+5QdhVGydObIfXbLlO5GCtUFNV8HAWcX91K+OCmDr4Jn3md/z5HflE7uU42VLDJvtdqR/vh6ev+cypXvyMrQJuHknTu5SCUZ5Z8A4irwsCrhitjX3Hg3TqRuv1GtqIn/3DW7Ya1OimQjG2H+N1dSrMpF+helk9KcqkxJuK5OV3h7HMN9xLtoeQO3CyId/Hzevkq6TNLBJSgWrVsCFYxhhTrjWfr9efWURkEwRBz5Ycc9y/1Kq7sGcGW5R5AzchVktIw6vJoac3yFdYf1H4iXgTcfZxJSriKtRpY+PZBrcLRJVw4VmVKB0TyC8vuVdd3k2UpEAtokSKYxG4iUhEfUFKVciG0p342vV/agWuWhL1S/IiKNhfaRF0qcEsu7vQJ9g4ivaySjTKjlgoAZ4+InuWnIBtbMnEzCXCoOSGFx0nHKZGlU4c4P+o5OWGmJ34eekFD5aOg1YjtnG6P2K50xGWUwRXJQ7mF0LdDf8qbBnVFj4ZajNU/ISSNn+GyYc4rZJW9E5LZubG0k9wGBKJUdDNQlFREbWmebOynXGY7+/oDaIHZ05aX6emJBYM4lh19Tz8LleJqaaKLsJEqx8TocX9iU6sFW6vm9fzWjtmJhk0q20SS0lcFxCcqybF+Lf6LabXwzbR138hOCeK16RGnFde5AGxeB2Lg4qe1gOyUyke8GrEMVhoPSiC58v3/AxF2pCoqVQsFXmzXTGSYzOm5vvbeYPXulBa60FVKYDExcC+RDWVnkL4cjHOuKkHYuoYU4qoGUXSm78T97pUaXnYvjhqQ6xEa0QhDLF7RiHWZAmJ9urQT12EExuK0Bl3dDJijjUoyz1kELkeX9vO+FeQCDWJociWZXLxIig76zdCkrqZN/s9SoBIeWK4Z2YGOXYn/285m1CRcvqcJMYPcwdwLCdvIW4as8X45VEB0yuOSat+/B9HFnRAzN6SMYZQ/Ykz/H5L1eJBqFblsXzIhwiXufYruKEr7wTl9un8K5OyX8QUS+hRHobdTlsT3BpVeL0UxKvEm0oV5kFVIZcDYmpdu8/rkLEpyWXhY4gKqXHDxbbRt+quTA5SN+AYcPAQwr7VRVtFJWlZc/J/+I2iVO/f4qBaMYfwdeuJRJ0WNLcmJWP2MvmaVIfJl5Kp3irur/IDyHX4eIVs/wL16yHmVZwFziqhJ7F2AD0bMtvk0RXSVzSA94Oy/VbciQFCMOtsCMd004lnKVh43fwlDuX7QsOlmTtHd+0cR5Uw2CcdjNGtBjXZka4KWy3mZ+4Hj3eQgLpNqB/Xq+uGmEJx9ta3niVlM/P8ajGLpGo1ppkxG58584nnpkoYzI+CQC7OvvI+RF3GjCPpd3DlrxOb+iZJRBqRQdtXrFBnPCxuVCVKpSYnQsKoga8OatVG2SHEcNxzkLX6h43H4R24BK8JndgMseo1hD12GT5s8Z+4kdQqxArwuagyXu2gVKtza/axlbW4nfgZPc8Pr1GVmGqNZM7CjF3xFXKL3nnjRYTglABTny2E754Jol6PuuwVLrW1kSqO5+F4RpBIldrj6vPkv3SfFomYGgVV0wnKd+SMSDbeCAGyQhkcLD+nrkAXy1KNmDCo1sW1kqz2K5bk/TpKaFHECAfQmDeMqWTj4BSS1+xJwxHhCZLMhyTd7YLQ5vwrD5Yrs6koeO0xWwbvvvDZ9B3ESnFMbyol1mrOyvPYBquzr9LIuL6cRYBKjvoKi2uliFq3NK/hE7EfBpZ1QaxEuxDEtk/nJNoDkVjY26+K16EO/UROfOaUY2XgQO5XzYWvSfeN3DfmiHtHCWuFT16AmF1ISu2Ran15G4/Y/dNsvygejjL0UrLXtYJJ0u5TnYjVoWWCn/GV61+Zzog6xQd/+2AmB0qdclFL6vgrDfTCXQhBKdTh1MkYxIIFC1iNfb60sXH33iYTXdmezxFeBKpdcvwuL+iOXbzx8xchtBgmSJm9RK+sbC6iLnb4/vEbJinphCtk1yHkRKyeyn7nqrNM0nILNnJ+J/IJKmRnEiU4ucZnHpNI1eJ6FGO9ZkcmkU2uhMbeCt2QA5FEq96/5KGfqwiRjZEN2Z+de5jPyaQ6vIcVjLz2gnUTUqJXTQszgVQE5w1CibN3BX6GZ+IAqjoxErHPwmNkax+SAUt0YdKbp4i1ol7oz2dJCXdVycn7vKTQoVG8BseSVE5V1u2qnXnupiA4H4xGzC5fXavtNLzGL5DcBEUsTCpaaGLCMcFiS/5zmICs6U7p8tkioVPthkSprN/7WiGNXb/rPMSUEZgyH1RCTSeW8F5yrU+NhYOinXX+AffhAoLgP86mkxF1k7yWpGIcXXITRNsjZG4PxAL6UeI8sDfb4CpRS1uEom9xj9ka/Vpi5b+SRCjUQYlIqUP/zGlCt9fEGNHa88zk1IFeSkjQqomFEr35wPVrbe1HTRNJjyJWphPM/tVnuPE9e8UsXiUHrk3ZU1RM8XWBfPCVPXr53NaDesVZfueKgKcmJ5TJ0at3/J8nzrKKf3qP/eQffuJDWKuOG2LbNhCCvr2M8K2rzTb38mxCq4djeBAk+5kb9a2XvF47L5Lk5unK1t2y3ayUlVLoEyF9rOzRM9p8Qlov4YjjJjGdoQieRyeQCKgY+9mrE9lQDohrO3GMTPX2PbIwsbSbS4UIgqs6zD+I9sB4ocVwQNh+txBjlHNO8P3On0Q3xvD59Kw4cp/PTtBs60TB3VWd8BqlMDmwIpM5v8WsnGNu80CrIhLB/UdE20eIreXOwGtzVTiPthO9/eE2Sf7mA1jw2aWxjTHGq+NsxBQ6ofgKTYQ3UwMx4qxM5Dz9OW4bt5+TF2dj4i0/V23OSa9TG0cgVqI2VSIfHJ6B2MpotmNbFCWa5FyHZEvVulDJy7NI8iT+KxQrk/tazVpSOnBKQFl3KxdPr1Ec31EiUitaMsu695ybfMXBJPmdnsYMVY3vNQuxHlTrOnF2XlX/Kjl4KLLdp1fZTw0aReLLPHEAbRNoSj8xbnjqIolPdpKr3dXTGGNaN2YyUzIrr+t18Z3ff8mDUE1ilBeeBWraYaQgJdbPT8QiRMxjD6tiTRjrz2DPcqCYAFD8mhpC/bRkPwr1FBDI0akjPCDKVmQiqOSrW4hKcW47a/LqlIIJ3i4h3at8SBTHYNMVJnjZxEjuwFVURbx7kJNTEaGsMkvlZE+5xEgree3WRaJEQ7pRCKmSGAVVFWv+rEQsQsewKl66iKZ3yu+hVGbew43mEiXb19eKxCg9geC5HIONnMnD9v0XIj3KsXN4VRZLipCtpr8UEbigQA4HLGISEffQ+l7uryBxM2cAkYNjU7kvu4hx8cibvK99+/LvmXdECd3rkAi8XSTbagLC3uJIW5bclxeX+Tz06U/hvinDOAr67BAnXdQUS6EiTHqVxLUaLV0xvwdiDYSJ4D9Z34QTsXiwtS+oJKSLZeDDW2sspYv7tyJ8ufEUq9hMLQnzPFrGnt3ojqyK1IO0+Bz/x/071gp1YiSz+Dm+7OG/F7oWCum4vIJKaT02klioEoZ1l/h+lX58Yi8eSnYSzsYrJIzN28yEpFBzflaf/LwB1UH9VPik5ErDTUk5hUaOr4dYmQBu/B5evNb2vuUMf47aVhEVixpT7LuVh5JatwXE7ZKX3/F9kVhuFuN7jiKxckxmRbsyp+EBHx3JhOFPUTMoK+yOghOhkpmp4vssLloXrZYTxTuxlkJwdhXL3WLSaUwQdR1aLSUK9ULwNbyr8Rm5IUYc1fekRhwVYpOnNpGdLHWsFWDhatQhUI6dqkoOmUFlx7ClFIKaVpfJoeIwpPvE5GjmoiOINW9M1LV1XSbgU+ZZ7+ERghwbu5RtUOdWRHpUYqEShshgQvLzT7E4miq+ky0iYU7Iai5E4IKiuPdtj2Jxk9qde5VC9V7d4rN5RbSzEiqZfVU8E1+7vkkSUc7FWgV0XMtRuPpCTVDxJBoLgogaD1Voh6oe+80gkW5SD/ZAlRhSHtsB2bEEK8wP4gFUCYNybVMci66/uSCWsxGd4a6uYgKiUBEl/HTO5jLqVYSs+zTi4IoXZkiqolL6H3ULsq1UQViQq6VmxZXZ2AvRCrDfE0FCfrubqKae3GWSNrEPK4+zFwj7vnvNdp5SorwgEhWlMRFYliqul2JtmwbRbInqFBGI0MRNTBj/EPf6lt5MDkoGku29agSVHRcKAbaCy8ixsa98Ajm4L0ZDPwgexlzBr1p1icicXynuTVUF6mRPBIwxxn8QyZBLQjl1smKGVZ9kpFCcPf6IlXPwVOqaHLwdj9j+IBZQ6SsPRUxZgSuEJUsufidhs3itVd/dPmGk2jsqYbi/mElUxga0Gji7iEmUSvqUtHjn9SzSlHrmuXUsZuxLTZgoXYcbj7kf5Bc29UrroU9fEiunTKaVQdzhCYg5/sY2yqH0Loj9V4x4Fu1r/cKVFbhLG940yUVmn1UIRimypX1ywhhj2q+ORkxNbNx8IdTijlDt0D7ZcOSBsPgWGg7zensiptwjc6XljbT2Ig+vSj7CA0DIDU8WsLSjsKWO/+Bi+VmNByltDodfeLuodokyx3JyZdbeTdiZjxKtlYHbeci1L8VK+ZMgK9nV87YKE6mN4jvvFkRW+FuRMKZUI3MBbAX5duBm+GAX+64PhC5Cr03c+OyCQ55lmGgoMzelE3HrN/7PsXtIIj16gAef4quoFsdOgU5MDOqBWP8pVpTh0HRyWByFSmSRACrxKY7MkWhWnU0LEk05dJsJXpvuJLSpwmJ4VfIddtn0FJQjaNlmHF1UNtp7rnIfgpiVMWb7ol6IqbaH0oQ4M4oF3oM4IqKqFVKg3w7Lz2rSRy2VMPQJpKZP5ZFs+/wkqvMLk/i74SFsP5p47qWntvFQLlF/hOVnhRI0WSJaDauIuKkJk3ViNP61KNymCNRhwwXuYe4NyGHKldkBsa9d/4pOxON7wjtAOHG+FKNrQQ1ZxVYdwfEwJV6kstH9fbl5KeVFxZOwH+iL9rGdocSG1MrpyIq10Xz2Ti8fYlWsUIcbz3jIqc+vZKm9i1hHhN6Jw1Gt8WuJdDyPFSVwMhKfWoi2SuPChPgLDOa43SuhntdrBQV91nQWuvA2xUo1YeFX3w2xjFnYfom8ys/aow4/V6aU3FjPhnMWW3FYlJ9Ij0oc6avexfpZ1eRE3jocNRxedQRi10SlpJxTo2YKd0plDpbdAbE6QYTH1eiqHe0JDCeqeV+QI1XfffZxok6zhXJs1SYjENu+Yhhiar0TrUvlT9JxuBWddCpHVEv5f9QVyOSWLbz3/VqRJ/LhD7435QC6JJoH0GQhtlayF0ftFcnx+nRrO8ex7gy8Ro0zmt95HyZNRIj/wEjuEc7iO5fjoUKzImgwk5foJ/F8fyltHJ7PvH8PLSFK4NuDKNE5Ib+e3pOtsds7RyMWu38cYgV6Mjka0ZookbuTA2Jfu/6VJEIhDMq6u7pw3svpxN9VExBthbV2Q6HFoNoNamRSQeaTFluJleV+Yz9VOYwaYTVesD2RmKuLeHO9FfbgKmFoNpFEmpKledjs385e9MwG1gotrUArquTkLHIaMXVSW7SfRoq+ozr0w3bxQG/lRTLYpPnsMy4awvn8OWICYJSNvDtYzOfb2zvGGHNrfyRi97ORAZ5FtIvU/Pi2S6xs3bJwox4hJocUZ6HLXKsC5P7hYoS6H/vONQVf5csXPiOhbfjM/Sm+OyWPvGAHe+CfBE+qVFFWbbXzWlsVG8VUk3dVJm4nhSNwFgeiRCdjuXmrhCH2PdEZNc4ZulD4bgixLTvqklQYSz2I53fZQIiIDV9JAard14RK6BW+X4dkRKeWLGRlP1rY2auEYV1PT8TsUwzlapGQfvIIn/0vIonwzsfP/1Ikrm5NyR05sphCVWrZ9R+MMca5LH/32XFrstFlA/f+86JF2aYYiyWPHGzTOQrEImcNtqTUeKjSkwgcTJGr1Lm4h8XOZwH9T9Y3SSLskxdXbrBia7yAsrcZxBjR7ackfuy4RLKZshHPUZuby3NRoS0V7RFlfGVPhpTDZBLhKDg1gpvo5vEcU1XiRY0KcWN9EMsN7X0s2yjJkvDBn9KfiM2Zh9ZKbppwWA32JSKklhKRchOx3UI9cKHQE1FuhHmqsMoqLSY78gnnwfmnrN/T+FpsqyjthM4iETh7kt9T9A3hE1GIG59CQAIHMxHK24awfNAAvq5qPmuVMUHYlDcoyESwnxAqylmZwmW7PdkeufiQyezlW3zWlU6EWkoKu3d56/uLjeX/LCcMvjrOIaoXd5VtoFNhPRH7VbR9fnzO668Ew1aM4+atjLTsY985fuXe12MyK/2XfjyAfVx5XQtm4AHfvCsVSx/vZstkUCWOqV4T33s+QUBWKIadE+JewQ2veRbGAip3D1bT+4XRYDsxracQhjzifCkYR5QwkdjXE+VNmCeSfXkU4Hfk1YPP9JgBVKZNnd8NMalY+UUgIGI6I6Fjn8Z8XRLxTUY8MwSss/z8l7BHfi8c4FSLY1kLwo1qdFPJKKuKaoIvFco6CyJdXjE98NomXtSyHJGOKjl507wSCpO345llzz5AuNVRqH/u28de9LAOHEtSLp6ls3NzufTE+n2u2RSN16wU0r1+woekT0siJ23FOK9yMZ3X2A2xJIn4QM84EoPYIzFGGy8qlEe22fa7pwmPB4/hBqR0MtShrA6viEEcI1MKhUpESiU0iidx8rE1EQzZRU5PgVwce7Qf0sYYU74hK/F58/sgNmIFuQ6JhZ/EJEGsbdKRWicFvPg91fawVm1VsvMzFM/OKi5fbzrRqhbaluNEq8oJLZmBQkZakTfPCGRDkjL9rE6WIUNJPnVOzhZShEjSZi8m+je4M6c9moiCxHMU+UpqLNHdi23g8gWZHM9ZxkSwcQPrHh62OGEuqeYVUaezazhqq+TBI6aRY/DydxaQeQQPrZr4TpTGhn3EMy6K97Til6mErKBoF6WvRR7G8x1scfgIpd+QJm6I5a1BFVslmf3xBMmg/2R9EyQis00ZTmXspUqxslHKls1FTlNTbN5zBNtbaUwsO0MileJsKJVJu8y1ErTZmUk4e4r57CI2mWJjjOlSkd+JSix++okXvktZHgZKNGrBPv690vmtm5xdVMsYY9YKwuQiQRjNkZrZfqKfWcWpBM+tI9GfyyGsUM6LHnjaVNyE7AmDMcY0slXUHQdwMkcd3F17co67zRIerJ18mAjvFvoMSpTq3OkYxMZ1ZOXpKVQ8h86xcgxSp+PBeu4K/2c64fXygwsP/VuCfLxYvLcsqXnwvRFkMIUmtfR0QaxqDuuz3mguK7GIXjzglMKiz1ROZh0bQ2Ru1rEYxOI/MCEt4TcdMeXGqSY2tk+wSnwXzszkfo8gS38Qh9K9JXxGsjaZg1glMbFRozyTIx8hDvbH3/y/Sqb/yyMmr5/+cLP87N3EE69ZKA69QgN2IFa0LeWn540mwXWnENtSCc6SgSyOXHIyUQ2qx9HV8NXWmKMHuWoqsfCZzPFbRco0b7nPqYRBGnUJUmZaDz4TG8Qe/rXrmyQR9qRBjWRWL8CNUBErQ0R1qkZGfUSWXa0SKw/lqKnGQ4duYrU/fIAV5vEVY4qqEnEWG2t/MWHQX1Q7KUTPMjqIHgO/i0N54Dw+NOXK8n/YOQDNS7Nn10SMfapRMKVsd+wWW02tyxOdyCwcQPsLgaBFzYhOFfDn5jKmH9nYdvJm9IN4vGaimGN3Ks4Ds5Pg4fSvx0N5tCCgrutG5OieaBn4tiJpSqEC+8dZ4dAWol147yahZrWeiR670hOIfhqPWGrRCmgw4xBivwqETXEAptkkyDM48Vl168lNdFg7JsJx50lUPP2Ar1MmWvuEwqqazlgsPHyWjOGB7jTR2mNPKeSR2/QKRUxJQWf1YTLj68+Wl1rrtxJ1GF+ThFk7cmKMMf4tOJ2xJ5Ttoaq9rQqVyspeea5s6EE05fXvfA692s1ALHYX2zSJREsyUwq2M3YJHZ7MwjTLPIux/KjEphK8RMIQOIKjq4qAqey8M/mzIPvymvvw7ju8FiUEWv1P1jdJIuzcBmUFvlhW2ISuP37mQaUSELfe7J/1EOjEsVu8WEpGe/d1VgH2sczl0ZTadv6VZMP3AvZUvfPfdnPzOjKeB6GSap0tnPcihpG13EuIVy32s/bTZ4pKrLRQ4pMV9mYe+vdf8Po/FJDejeNsSSljsWZLSQ5VcGgVUbEX7m5ttWXIwqpjvVCsU9LKYaL/+5N4XWFXvo+x+5QVOB/o63uoWqfUI5+/t0K1do8QY4zJkY/JobKz3iSEy+aISaQFzZnMzRVCOjPakBXexJ8aC6/juQmXs41MKrQmZWomFqmEv44yICsj2iPLBIqh2ggNBcnRX5iIDdouXEaDrBNm91sQEVPLvSsnyfbMpnZE/CcmZKFnuV+1b0rE1X0ACX2KvNe+OAnpdQTBO2KytT1Y3IUo2RphP9/UnX/ffQhbDSYF/94BoWJZMxefQ6XPoLgOn2+xcDVJrAnIn6KQS9tkMWKPllN11Lks0YmgseROJMrCwlgJS5VW/AfBk7j+lMXB165/hRNxdCwfXmWYldCxz+5VWE3ndGAVq1jxajz0xEQqynXbwAzdLq2tRkMVY1mJ8rQTin0K4i9fhGjHpv2EDI+MIBtfuZMqYya7uZYSkVKW5BFreOOrcc55QwgZK30ChQpkS81Koc40VrZqtNRHWPp62xJQRSKNOsBrP7EfEzLlTtqqOBExZfw0bDeJlUo5dedeJpbpnSkPvcDmsZJEsP3L+zEhObaSAjROqYjWfRa8pgyiheQvpm68hcvgFbF5HRFMdrvK5K0jRFhUdd4lnNdwUTMWFY9fcX+xa4kYo5OjyjkcEFMkyhVbiUQNbmlNwBYIKfvpTd0QaxXM0di/Rftt3zDuB2qKobfY5z6Lwm1nDyZWWRoTYVFchBXnrUmvEql6vpcaKUqAak5ftsHaj2Ni8fcHHqxxW3ogNv0Qv/fuojWcviwRFt/e1qm2k+e53zatzL9VRhDNS2TjM60mQkwangfSgGsEkVnFf1Aqlrs6E537J+tfSSLexrPq3DiKFfaOG4RbTosxKpVEdJ3Jh0sJVTmnZ7Jx5DCrQpfcPOQW28YtlcCVGkmddzwGsYU7eIjs7s9qpLUw+VItjiUC4n8pCJ3Z0vJQfvTSStQr2mMdXlO5MqspZaylrLtVwqSmOCaJ/rxy1IwTm2ESoc/R35MPsF2UK6vQcFh0igfGhau8D9UGEbySnzVpMh62iZTYWE4mG/XceR/O3s57Z0UHK8xbphlJWfOCOiI2ZTN7sYpjkLv1EsTOz+eBcekJN+/mQzch5pSdVeaJ0YTgT9+3IodhgtOkHGEVYVI5gF54zvdbMhM39GfCETaxQE7zZWRl+0EcynZLb9/8JF8OEgqIe3vyMHesx7772RAKa+25w+pc+Z+8FcjpwMW8r1/cFjo5qXgP23kSoTPJEYkVU3NDenHU0vxK5GjIEMqUqwpbaUcoOe+/3/Icer6VLUT7UZn+/0PdW4Z1mX3R32dCZ6wRxcbAbsXCHMQWu1vEbsFO7MLGblHBQkXsFrGxe2zsRFFHndGJ58Xz6j6f9b8e59L5/ee537EvlO/3vs99zt5rr71WaU617A8fi1jFFoxFrebo5uLT3IfuibaP4kQo7Qhl1PWfHfG0L4UwtJpMktP1OYQCY3JxUQZH82D5KSVfXnW18mSlqNCO4jmZgOTO4PwbirjYUfTJd/Vmb08pQBbsthoxBUGvbstN/tErMvaVQqFSY2w3yglfNmzETPRpPP//FElZsd5+xdbF2k78/9Q4a8RlHhBJEnKjLpDDBbEuo8nG7/YZyngD17ESC+/GvmtnIaF9WbRk6lRnS0KZjQ0bQkb5zoFkT9+J46bx7BFbcttvOpOjdJ4kx7n+yFbbQ+FY+rtAxHp04JprLcSQtgmux7UQ+hgMEL4jWStwo7ZFmPo05v2ds4VJVZMKTPCUD4tycX0qnnUi4eJasfEwxM5s40YdJ5L5ybWcm3ffzUScpjckwTXmtuiJi6r79GP+XmmRHN1/w8O2YwCr2G2LWBXny8CJkqyNZiD2jSWtPEBMw12dSjR4anGuufrVWWiEiVbbm3h+r8zu/P692pP/oLhpSh57TgPnuabGQJVyqNJwUOhX6AIhtS24E636+SEWKyYYTUImjK/O0/34S0c8v0oSkSO3M6tWVuBqOqN4IGEp5bswsz7HNHuJXv/PYkxTyU03L82qaIywtB1pmfVcfMwHVacU/69q0wm/P4gl/H5xLjPq/C1ZZTyO56GseuwzG/A+vf2dVYZNkDoj+Bqq/614ApuvMTn6QcBoqw/GIramMyWox4nWTffSXDu1GoiJkkuEF6fMdc6sh4/nC6Og8GVC2dB7ND0RvhH35LhI5m5tI/GrkSBDKjVGddliRWrUcqPQV3FzFwRnceipa6VggGduw00zdDjbWT2EJ0hkBBOErNmcG/+15zzgN/Ri4qII1Deech96J94Hr/7UZ/jr9jnETAZOXT0WBYmSlrYRi1JZxKhhIA+ROX2JVipNhI792ItPlZ8o4WbRHlD+HEmE188BwYky7+IR+vs7579dF8B3bunJWMR+e897GbGTyda14HqIJRDtvE6iYFDqlMPFREX4PKKzmzafc/x8dym9Puot4Dvd7WeSyvtGCvVfMc6p3k01utlyJRVxzSvuzYqU+aXXV2lnFB/rRBnUiGe+XISllEyzsviuNYdjXsNrEpYRbt4mTzq+rMN20JbZS1S7Oy87D/6yOUjomSWMdJ7eISw1exh5Imr8cmYTD8QO3GUCcv0ZE5rRwka66uQoxApZYj3K4OnkE1Y2ihNw6148Yld3kdCzZj7Hob4ThNH0SZk9NwqmymJQG/a7cwt0KsJS8lstqpgtfQgZq3lvxblJIXwc5giiakdPoiTtV5FP4J2X70knT3fEcndz9plVcqD4BFPGUsXS1g0xxpiQlYR9Ly3kvy0/kmqH0UKW+Og9rmFFSrW5GAMXsHJaJQ5WNyHTPU8omC4S0xR+LZjMJhZ6Jcqq+1UkIe2bInm5/sKJYrXsTzZ9qw5Mvm4+FtbtwjlTkQOHbuXepPbmYMEdySVaRkqUK3VlJse23fa5EywMGjVkqyl8JfcNxWtw70xp6Sszmahkqkj+j3TPFK3RF8fI/0pS0IlYvjvPd0SpX7p3oOto11YsgoZWpDaFksJWvAZFojy6lHtu+YE0h3yzhqPA/+T6KkiEzTtQapIv33BRJhfVg7quX2Fmb0QSMWIzX5r6JdkeuCJkjpUok30NG8eK5dvkYsZ4CGE/dSmtC3VQqVZIJjEeqfrYbjmUxLfzsScVzPZPQhypVTFB8jnLlsSlCMK+g8QY3WWhbLpVtIKSioN6nkA28ghzmZ0Wx+LtK7YklHlTuap8NodXb0Hs6mb2NnuJpCyZMC9T7pGvhRdDFj9W+zkLOKubbYIIV0i0Lp68JZkzULj4Kf5LjalE2CL680BXKrHF0jMBV8jWc4uLEBNUG79j8wuMMebEZb4jY4WL4zJRYUfuYVHRXNg8K6vu7Ze5N0XHst0wzLrH++fS60OtkRKdOGqZXGgsTBb3pIvQ4WjXgWTb5ELifL9AHRQnRBEkx1ooqTJ9Us6Z6lLtnLc3yB1J/ANbBuFLOel1XnjTKGLl1GhywqYtdSagasRTTnpcZSI80LsFYrn9NyH2uQmDmtgo05jP5t9AIr5KEmGLRiliZcqfCOkoboKSvVZmW+rguyPEWg6lZIWyXoirpEzKLDtwvhMBWT6Jm8jtl+QOLNzLF1oJGik1TVvgyhhjgkdzjruqUMU7LhwKCwmJ3FtWdaPsvG+IyYkLJ7jZ3grxQ2zYTv7e7t2E724uYDunxDAKhim3z+N3+Pl+ERuTTV48e4prM2YuK+yEAh6tL8SswsTYbxZB6MovpnjuvOT6V34PaTPzWW/xZ2/XvprW82CsIG20Hwp+TUhLJlE5em1CrJ1QIl0n3q94IdT2u5gAscmFIW1YsVYViGDu1Lzn9QcTkq7bkKjDDJFsqMmhDVd5sCotgg0iKbGTCDW2rRIGlbgUrsHqtNVAJiU/fMs1vHTxAMQevhWKwGICQtmDd7jLFt+Ens5CYFglegmJj2bOiLZ1lV4hiOWqSO5El3C2txWxMm8angeKMB80gdOEttvni/t8p5MkZNLbbwL5JeNF21ZKXBdmcqSMv9SlUBcpcvWF11dpZ9RZ6CRcjahKWL3mOC7KYsUJ8Z48EYuYSiK6rzuHWBoxHrhrp+h3C8+CIaGcC7ZVLJUTp7LafvkrN0wlolQsMxfhqIlk3iZKy5fXtik3xpgVbdmzPixg5FSJnJ/ZfzH5IH41+QzVJIJ7Dh5wqgIMFYjF4mbkv1wVznsLT7E9pMiAdnJkjDFvrcrWvwY3NEXSVNwJNbrpOZwQ98un5DW0bcpnkzopE+HWYlZeuXHaCEje9kQrbizzQyxnZVZnZ7aQ2Z1cTASNEGOq0adJmH33lklJztxMZnsKsa07FqH3pKjqy2R3QUzJfisTsXUCsVBmWMeFYNp0sa5VcnT+GT9zC+u5nr/P3wm/wiJo6eg5iMVs4SSOMhr07sGk5M7aHohtFjokLYpwb1YCdzsFJ8pOQF6soZiZmjBRhFHF/6iaje9h79XnELtzjWtzwUDqKewQ1uoHhA6PrQvhIs6DJWLNqbFaJXD1WBB8C7eYgZhMIn5nIqgInWqy4z8he20jCt1Ws9erBJ4UsfJbAZmdEOx0JUHtWdQFsbgyJEMpsqXibNhTISrBuRzMw0aRt365xYUaLJxNd9UkaaxRcbYRfhOwWX0x9vrkPpMIb29nghA1nB4GMfd5z9/dYLa/dSYnbLb9Qoj34g1+jiihExD5izDcES54Leaxt62Mn2wkQj37G8s5HqeSFKWy90lIAffyZbU7ZdomxM6v7I5Y381EbC5vYsvE1mwY1pOEOaXsqCyolRLl4VgmZEmEyuKT+6zOc+bj8zq+m4lqzGFW7H99ct7PuvWZfBVIRd+BbaINlrshofv7W1jFKyROkZSL9aROzLHp3KiTCkfgDNWc0HLY7K74ndKZyen5OJhjujUmEs5W45dKkO0n0TIZKcY51f7SroQ7Yh5Czv9pmJ/jZ9dSAfgd/zFc+9WF/LSaklEo4bqunLBafUFMprWj6FnDvkRxMmUWMvLrncTXhaJdMi+GPJxtQsxO+WQ070gUI0Fqvku7xnKyZeRuvkuBwn6hCmuNL77+c0jEeB/2Isv0JSyp7MZz5SNUqyYxlM214iJEWT1lRYS8cIBwrjocvhf43amHPKi7TI1CzD70jTFmaQsPxFRVtOESq4xk1iantBOUd4aq9JXbpxr7VPP+ihOh3D6nRHODHFSBY1mtV3AzjDnq7M/O7MP/X41CDt/Iw/yVgP2VVO8hkbgpS2s3V65hJTaldCe+t3r70SOYHFQcT3LYpYlE9XoL1dH9QmwpoRi/Va2Loo2JbOwRviNVmo1E7F6U09K58pSD+B0lyqS8HiJ/4XNQ3IkAH6JT1XNTr0OJLZnvmJRGTWe/29YA6FSC+9KGq0Qi/hRQuxqD7uTJdvEgYSGfOy3f9d8+8W+ECFLmiwf8fM/X8gDeYiEbqq0yZReny84e4PurdCierGT7ceYh7hGj53Dt/P2SiUVdP2oYzWvMyRbbSEuN/O5YQ9RQyXSbhHynpetmCEmkJyNGIpbFlc9VkTJTFCah8z+pEzF8FxevPQZqjDGnTzFra/+c1V76LHyhlYmWImC+Lcoq3ncZ591VMuDT1FndqbHHXoKboRKG4n1YFSqBq5NTidjsE6IxSqZbqXiqa/UJ54s0uCo30be/MSE5d5Iv6ob8TMhU26NIcXfE7lyJRWy50OLoJ5wnFXmvmSef9TNrPSniYo3cTD7DhBdD1jQ89NUBfF6YAW0XegpTBRluxwge8mFiZHC3NXlw9iEJaIHNiHQVHsr2SwlhXb5ZiBxVD6LWy13hpqrIpkkFiuFakqTMExYpO0TAw0FRbF0ojRQlZuYmpjOCBHLY8TxJtD26sg3qnoIclk9iTMzVIgeHCP6SIrgqLtVxQVz/5QnbgPZIojHGfLrPivXkOh42U2ZR6TdqJuWbCwygZPbFICexPI3POPyOGj/dMUPIQwtew0aBMKhptSXD+LwUsTRyTRRik2qTh1Wx7TTHz14dmcz88Jnk01y9OCURvYiKnY3700+jhC/HVBWxUkmX35zN8+VLr6+SRNj23eqAC43hg1fy2OrALJaO0NJxUcXnTMlN3ncas1FlVT52KGF52ylTOaqtFjyEnB1p3vLXax4sL1MSllVKjGcfMrG6eIcbSeVCPAwuCFleW2XyklDxmyxeIjXOeVO8vMrboLYHk8gpdUisbCLGeZ//yk2+eg5WKCuOsHq2tSiOPuB9U1fD2bRbTiamiS4cYxLhlssdsd+URbDa+I/EInbzIhGwJC7OtaNUBxXCUiQfk768QhwrQiTkT2L4bHINYfV0/lE8YjP2M2HaP4JSze9+c258i4X/w01Berx8jK22mMvch3ZP5CbqIvgfpx9z+iuLQD/rjhKH6GwSofuld+4lzYUujTI982rHA2P/Io7uLRK8IX8/QvxP3rAQKlGHugPK2VVxLPx7cg/P18+ZgG2b1w2/02gck9lWwZz+UYJRZYXapxKMchNGiOpgNXE8mxQ53G5B9ZjLhLRwRya9rtXZQnm0hRbnGaqdQ0wlglELiXQrTxCFRNRfxDPsS2Wvv0oSUdka/fpRVOfKlEvB75WycZNrIQ7vu7fZO98VyMwzUEjfvhUkpKDlfKlt2H+JGMmMFp9DiUip6Y+nr1lNi66KhGA39yQxJ3cnkbw8YtWWOZUzg3ZJxMQl+jYTC6XEuUIgBwO9yZ5W7SJ1oD9/xFjqpNwg5orDdpeo9m3Fzkkb2C5w8+VmY8tKG2PMvTdM5haK6Z8Tx3hglh7Bdt6BYTyAlaCVT21qp+R3cyYRiuvRUjDsPUoQ1YkWJLJBrcV0RkVvxFot47uZR/STj29iH/+SIFbOO+Sc9HIR470l8zNZ/iSSNOVNM19oR2xYL1T87rOdZVzZn54/vhliueuy8o5e4fT7OLyD9y2RIG6qhEFNtYysyv53HlHM/P2Je07dXn6IdRLqr74zqdcSJka3V/s794kEApltWJtIhErmZs+hPfhu/wDElImca1KuE6XjoPYm5YrZqogTJXwVw3Zhl3CiSepqsIhrzn8wZeXbCT5Y4bpENuIOkWMhE6Z/4foqSYSdNNwUSIRy2OwsfCKuno9FbFIAYc9RYpyzUxhdIeNEdu/mRgTgj0+s5GwxnBoz+BItF3BrYkGsUuzpH4SgjXIx9chFISGlCRE1lUzmu2958BW2yFBjhBX2m/dUSvNbxfv7XrQHbPttY4y5IjwWiguE6cNTbgYPhGW0SuhSNJiH2Jpxzsqzb31WmN65eX/XnmNlV0CMaVbMQzLY4YOsYtSlNs35QjL8xW/c+L0sx1IlXKUmQkIjziGmDL6yubDHmj8Hv+tl4XbpkZFttTUpOU109jELC5vQ+N133OD9RMI/qB6fq4Ku378jd+RoMJN+5UVitzeNMSaXCyvAdn34/yn9APtSBmfP3vK9mXf8LmLNi7Alp/r/l9eRDOg1gmPVR04y2fLx5gEZXJ/CV/a4pRKRUq2LFtOiEIueSwl1RePr2HUGYsMmkJQatIho2qPlbEukz0K0o27bKY6f/cdRaOzH70UV+JKtq5dCGiB4Krl/ZwVPQvlkuFak6JfiTiw/yzXxpddXIVbm6Ofsn7mIPpYywrL1JYzRGhPRk9lqULyLGgWIYowSKEZWobGg+A4VhjphudsLeUj32EDhk+FVyDEYtJUZ+zPRT17Rhhu/mqlWFevTq/wbqlI6eDPe8fPqNYTlOrcl6rBsLbkkhycRHlbs6RG7eLAqxdIGhflsyguL7zahTGi2dOFUhO13Yo+3GmPM4NUcwRrZhFXhDZGQti9BQluBXhQlWyVGyyKuEMVSdsuRYoyunUVKrh3MyRxlQFVfeNikEATPUY34/a+L718+M9tKF1/w4FPo39Zz/F6PLPJa5VKsiJUmxED/GYhd2sFEQI3RKcdSZQWuFCsVsVJN+9y0rADU1IEyYLr+UNxLYQ62oj2LmWyCw6NUfW1xKGOMeSSULbMI1G3qIhZWfz9xTrucCackc+qf2Bo8HksUMl5MPymJb/MjzxdFylwXSM5R/bZixPETv7+NYtgTN8ZQrdMYY+7fI1/JJkYbY0zMaCLprYSZoRrTVCJSz7ZRsVMJWv0niJV20qCkVVUSsUK4B954KYiVIimpKw4bxZ2YLeZxl59gn3XUHs7AX5vr7G0q+e31nXhwKdRBSWafvc/b/7l6EkpnXqln2gmDMbTH3prSBb/Ttggrx2yufPEzuXJjUW2qKnn5QlcTxNJ+YsRxflQsYhfPMAF92IR93J5BzmRr4RD24VXrootAXRT/IdsojlsdGs9RLcWxWNuNkw2ePSiRGzGOiVpNy5+lX11W4gPEvYy7yQMj7nw8YgmbEm5W/icL3jCZf3KO9y5henfEFHegaB8n4SzBt0zSMibjfvDqBGFqRSINFYnmKJHgqnbD+aX0mHgmCL52wmAMNSCUSmbtSmxJqJbM1T1RiEWWZbJ17SCTvq5Cfl0Rl5W1vLLHjlrHaYSuYc6Db62YEBtQgahG2WzcvwaI4kslDM83BSCmkqN9d8ilUxW7zwSiJ3jWv/L/unQmFrGkyfl5l/fguTTzCNuK18QYvLyEUVcjYZj3b4hN/SvTGeqqVYgoQeAmbspKClox8d2TE24dJWZl6wpC37S6rLKaCzOkT1aFosZF1dVTiIuUyMokQnldDBcbmmIe9xcGUSUz8G/ECSi8WV8nC/jeBm4O9RcQnfARkOng7fy8ylzIW3g7LDjBRMCvOFshpbIRbnfzZdJXdihJbu65nf/f8mNMIGt7MOlRvJ6js9izVBVV0b6bEIuZzGTj0mNWmQoBOveU5Fi7tdBlLNn0iwIpv66s2xVKlDQBK+y450QJlYhUwoSsipWGxzvRCrO1SPadYvKZQLQ41KWeYWPRktw6wBuxeW5M3As3m4qYIg2q9pOfh3Ny6NlroRK6lOiiQjru7xiOWJFBXPvVvcglqj6cUycqmesjLAT2r2XlHSFa14cHO9vPkSKJSNWMaMLfQmxKJQeXhUld5g50RFaj0b++ZoI3O0ioRx5gcnT+rvPzJSnMRED5abwSeh1FMtdFrGZL8Te3k5SZPjnfa5UwfC5i8aXXV0kibK8MTwHx9p5KEopqU9yK50PuIUSUlIrldCHepNw+K2TlxpdY9KdtboMtg22MMTca8TB/LAx4yniRRFZx7Oe1JK6uJrmqzyZWmTYR1BhjlhyIRayhr7Mat5MlY4y5KDLqec2Y4KnKecQKKtQ1FW0ln8JEIm7FE4lq1ZVVQY2aRB1qFWCiEnrc2QMcXZ0VeyYxY100rQtiilj5o+C17BJjmkFRJFsePM2E5s5BThPd28nNO5mX89UNE0jPXYEIPv2V008uSdjiGbWTFUuHeux/N8rPxPKiUGwsm4VVpmrB9BjsNAPafCgWv9NRaCysFL3ed8IBMVx4jDSfz4RZtXO2ewhnWyFfffAOv/+ky85E7ekTJoZqhNK7CRMGdS0Seh31B/Bgdc0i2kNClEslR0vFpIw60DdaWhT1ChDVVHD+2KH1EFMGXyYpi6W6zbwRSygm3ZoUYlHZZAST2bsvWLjZExA35lJoLEMzYd0uSLoZarOF4tWe+iKKROk/nO2yCDEVkuM83wkprf2F11dJIhSPwb6KlCR8pQSoZnbny3BsIuHhEn05Zzug7eeNqrwSm4vSmLhrebQrTkTYGfYxOahkzLidrJz3D2P/LH9LJhEzDsci9lBApsfFYfCnSBDeW3PxLQVRTV1zBbNdSSv3E1WMEqV6KKqxHsv4Wd7Fc8NdKZAY1Uaxk4ijYjT4pIARK+Ym+qHQL9Wm2N6XaEKv0kysX7zlIf/hA9f/7WdMXrx7O5O3JCm5sabPxMSiYzW+hw0ElyipaGclSchN+dMf5LUotcv+i1gptRVulLZS4r29ZOcntSpdY4ypkYMJ5D6hr3HtJfcqpXb55gPX0q5B/LspxTvn04fM/j0znOQ9xcPYKwzTlCdGpmo8WAeO8EMsbhOLj9F7CPEX7kgeVqvpTGbHWDYAxmjZ82q5nMWB0pIIGUyCa9U8LCqGuXG91qvjgZgib84f0wixJiP4Wc7OIW9M6VOkKW0RKQXCoCp9NRHSTIz4KsvwJ0/ZflUEzOAJQgpbTOKk8mQS/aXX/8wKfIPgJijjE6/+JKVVqsKqYIYwa7n5ghuEapl8rsfE/XjnQzh5h1lmznSc9Ig+T/gu9gZJZFfmMJP16BuJmJIMV7yLZad5yLsISPeYVSnt3k84e6AwPoo4yQ2jYFYeVKPFuFnndfQmCazM31PV/vD1zOTbV2Eft4JomZQb4Ew21w6lTXVO4Yiq9EruiymRlcJWflJbJjgbzxP2ffyS1c5zIbb2QRxoy7o4eRxqCkdNDigya/vFRIkK5RVk1uJMLDZe4n2yhZWMMeZcLN+dP8RBusxKDssFcnJA6Ut8FNMP3kPpifLupagU41hhvzrIMc0UNSYjlqOkB2ItK3Bt5rLQrt8Fw1GhNU8FEVQJVfkWotDaOzFxtls4GPco7Y6YQtiUYmerNpxYCZ1n8VrS8nD89Bu/l2q/dezEe/786AzE0rRge0R5dlSeznaWchlVSUmKzM7v8erKOfyO8rBQB/eLI3sQe3aMmiDqjFQoxpmVNPkK2ETS/7/hnfFVkogkjZ0PUB36ahJDqVgu9+XhdStOaEwI1m7ulNw01UNQkx2zGrBX3MTiBdy+xspGwXIr+rJiURV2KQ+++MqSXDHblVGXpw+r2CLCrMZOctxF/3eagK73CXtgNWNdWlTA10U/XekYxExji8ujCys75algW5wbY0yfn51tpJ7ryVdZKdZcQwFxD6lFDsvZx/xelx8xpnxStgqPkTr5uCaKi373ZKt6HBPORMstAxPc6gWJOtQQ00o/D2HvXHmnHF1FBvjGq8LkKgHXSd5UnB7oG+IkZSrG+gdBNsztRyGkHp14wI2pzmeojKV+FpLhC8XkVPNZbMn0acx3p7SbE9nyD2dSPUm5WAppcCUEdW+5L2IjBOqwdDEPL5UINC/ENpVnVqJzGdpQZdFGCvoL4qZnc7ZQMpehzsu9CywCF41l8TV5M5P5MuI7RO7m3q8g/kdRPFjtvU4pcdpOn8YYExdDszFlce7TbT5iSlhKnV9XrvCde3GK30u1QibWYDH3T65/xTtDJQxJk3PDUKOgSifCuzJfSjXOWcqNi9xnNCuZ63N4UGXrRHOdfIWdvdfTu0m+TJuX0rpFxeIdIcxQlK5FzkwuiPkW48Fy8RkPqpsvmN0HlHVH7KAFm9bKw8+rFBYbzeOi9CrMz6ZGQZXIUcMS/LeHbvLliv+VCICrUI9U46G2DO2LD/y/pm7iS/lMmL4pJU53d7YROnmx8iotRiGV8+b5BSRvqn5/55LOv5GrAxOt4d05/RQgyHZKE6NQahfElHlTEoF0lR/HA1j5btzcH4WYzf9YGBOL3/n0J7esmjm5H6QVugtBQmr8sKjs54h2WaxAyTImZYvLp4UgIK5w+iwkF+JgH/5gMhMqPtvqVUxclOtspBghnlCDnCBFXFfFV/a0wq/In8hp3F0nIvp8I9sqahpOCUspRcy5K7gP7xlHomKj6VGI7RjMUevrAsHedJn3LnyG831ViUaGskQEijQncfXsFkGi/Z5rwqsxUbeLiusgpi7UiKdSsfxPIBGnrR6oqk6zpObLZitdGmPMOjFud+AOK2BlhjWmHqWaR2/jzfUtR3JR2iQ8lEZFOLPg1WKcs6hw9js8hb24tMn5/3v02YTYhRlsXeTrThOWgkV5UCmi4tGbPAyvWMZXs9uyEn/6gQnJd4JEplCH04+YCDwXPJTn74gmzRcV2sVp9RBT41BThs5GzGRyJqC2XLQxxjQW6nlvRQvhiCBCVhDKfopjMHUfnSJTJOWaUH93kTCcsjd+pf/wkxKMEm613QWcreScy5VnFb9B6BPYKqHGGFNMTQ695ZrotNyZgDYTqpYrdvNedhIW74EzoxALHU7S66iNrHbDhOjXM6HP0E64ySok4nac899+Eoe0QgnuryXBsccGIkJKHOrYGH7XnG2WIGbespWrLLhr5WSLS4kXhS5zfo9rYfwOajKnvRAfjBU+NJXLkycRPo88AeVZkfpnim0lyMb3/8gUJmXuqZzvU5o6nNYxz1lAm8REeqNWDECsYGbuTa4/MxHw8uVnWyM0YVTbo0dvFtCTBcL6T66vQqy0lScVJ2JAIx7w3wmzErWJZkpGLYIIYf36VizM+iXYx62fn7Fq05nQdK/uXKx7BZyvJK4VcXNhDBeXQkRG7iYEuWwA4cbJwgVvzDx+hx9+5EFlE1Dr9w7B7wwbyGRmXTS/Q5/aRFiUydWGk6yoOoqKXfmanBZiLd3LuPNvVGPVUtTS2d97kPdt52EmJAkT8tWYJYhljYexErtTga0LNVqZTFT2yoJd8QKKejjXcGGBCH0UaNKA8kQi5gnC7JkZTISnHOJ9ytOXvINSRfl+qevKU/aPbVdQhYj1FYdIipKsAHPUoDujp0CEqpbgWHHZ/iRuH5nMdyJU2DxnFtM+NgLSMC8TzaVinDNPDx6OXj8zYdoXSKJi70j2xM2f3F+VPXr0LVbiVQfxnrim5/20vShKDWZCel3wvPILnwzl7JnBhe/XjsUBiKWuPpYf7Qg5FrbCpjHGeNbm4Q3Owrt4/E6C3EyqPz3kCKl3S6pO7g/lcyjSgHuaShiuC/VXdV0Q/kdfev0rstfq2nqBB7CaHBiyg9MJSljKUyy4xyJ5WXeUUG1loYDYpBwPtDk7nQ9/vRijUkBOHzFWutyX/gftVp1DbNdO9uwXCPMuZRgWIVCczC0XIXbpkXPBvdrO7HyzmO1OKRTrFOy55Rz7gmmEGY77T4RHU1mS3MYYUyADM/mACG6QL57EI5bM0p5//ZyHdLNaZOev2cr/v2hGVtPNm/GejxeQ8RLR4mtdhKOKA5dTvnrnUE7xJLAS8NL9N+F3jgQR4q0yltWuUqx8I9CJtMl4yAV34IZ2V0zdTBQtoxuXeE/S9XEmzBNXE5mqI0SZ+o3rgZhCpvYJUS5l3rRwFcmmCrNVUxYPhaRxxE7nvvZR8DAWjeAUmuJ5ebUin6BxUVb7B6LYMihS3gOxW0/ZpjkmjPvSZGTic2kSD7liw51tJMVrOCWItqGz1iFmm14Zo1sNv4lW0LMdNBY7LJRI1dgnsV/udXFRTFLStSZHxPxE9M+/OwneI4XO0dmNTMAyrN/Mv5GM56HyzpjVkLybL73+lekMWzfCGGO2DWVvR01iHJ3KCqih0Il4I0a1jgdR0EdNbGRJwU1TTWfYAkkrzxHOnh7C/pzyLFATG/v7s2ddbQa/6/wW7M9WEaNKS/p6I1YiExeXPcWhpJvDzjL58i1K6D7iMuHMMCHolE+YMlXI7oKY6gsrrseU+YTvg/qxGnv/0bnJ77rIBEfZSHcTXJI+YTzgn9znutk4jBvEr59YAU4UY7/TBWIRI9pDU6yJle39vfE7Q3fw4P5d3N98glhbOhOhVdscyxhj7t2nJsK7tzxEVSKkdh7Pus6NP1ctvtMFc3JTHutDSLa2EJZ6K/r/h0dyb/pLfLjctSkG1K4fOSwKZUhiEbDV/++ajFMthVvPQcw/gMmh4gl8ehuP2KtI+j34iXU9Wxw2Sj1S8TPMKydhuFb7eviVbVvOIaZQjatT+fzPiWr6/q9EtfbfEInKMibRiqipvDiKNHJ+ls9ttQQLkrriThgXJjPmW45Vx+0kYvGn4Al9rgDVl3Ii/hXFSkWiVAnDBTGf22YFpxhUK0QhGyphyJGKmXzxPryR7kKC2aeXM9a9NPuz9cVss+J/7M7CTXnGIZK8LhxgBVTmBDPUEb1IEBq/lb+ndPYTWCIsijehoPCz93l/lY20608ktBVIx3sSuJqIjRotnNWAG9rQyp0QU5th5Abn5hoxgUnqq49sP2VJwc/7Jp4bVb2a/GwvhWLhnXgerGo8Nr0LEZv8wpRtZEtnsvGt4CHt28cK8PwsbpjqsP30J1GSi+eZHMYEsXp+/IpJX61JUYjNFvoEQcEBjp/V2G6vDUTrfhUttGDhh5NQtFAnRJFjofgJ/QL9EPMvxz0h8goLhuMWbyw0mEJQ5zeyclYTV9GXhOeIMJFS5EWVvOwXLb4igmPx4hb3K3vs0Rhj5lky7QrVOCSKxatx/D3VklAIQxUvTkokyUeUzDzhs1Zoj+JJnF3rPMMa9+Wkw6GTLL4yLGHLz/zAfdP8wULDqzkT3GuP2Loo24fYycOVFC/7peqX8R/U9a8kEfkEeUtdSk1SOYB+EnLTSp1SiQ0pC+6c+dizVaTM7E2cIiHKmyJJMi4GJXGsFurEzawUlVPgqjZshcyI5sugeCLNlzEbrZDfWSllciFvQql6XhcTIb8LyCyn6AkvOsxNSSUMj18QWlWtgLB93NCUnsI3CZzfLangOkT+Qni0cg5WBUriuXwOF8RajuB4pIIW74TSi6GaIBuPa8y1Xim78/MV6sXeeS9fEoHVAa/EltTvbdrP3q4iyCX5kdWTkhvOlZrvhK07sWgX/+b67uQhzDzGNRIazoKkUwv2rPce59oMG89kq2U7GnpNET4OS2eztdDNmqZpvqQPfqfiKI4825MOxmiypWoP3BeGaf4RHAXeFsgx2rNP4xGLvumO2MHjsYhVyuVcmwdu8/8q11UQPH8VGh5iYiFWqEkumheAWINC3Oddy3JN5EjLZ/jpGou5sTOcz+z8Q67puMdE4VPkYAttUGuq/7YtzoRMoQlrL3M03EOIOWaoSOMzJYb1YZ/4vX9w/SuciBEi2+kmFvTpU3xBlLCSIhvuusyedaAYo5x/LBYxZQ9efzizxWQZnQ9VSW23DeFD/l1U8cmT8GWwiZvGGLPxrKgyxIaeMjEfnUoYlPRvauuzqGmaDCmIJihfjxkCqmsu1Ng8xChkOtFjzyHGWdtO4sjgfNG6yZtKsJst4aMc7TkKaftrGGOMEhseWJmENiVU5VNbJH31hV+LeF4P7zKhcUvGpOy95UVRtTJHje0xUGM0O1+NB6pe/w8/8nk1EWO/ShVTuZimSEz4fsPmc46fGwp1wmFCknvrKooDLZpA0nPHMRwjbNeGYkAqYUjnxapQtZEU72RFL+ffGCbM0UL9mcxFidZwob7sia/rR22a42fYanx6itMk/usIj7cowtblnB1M6JQ/R+p6Mxw/p8rO8e64zQGIKY+NbD/x/fJsPR2xfgOJaiuIX13+wkLgzkH+jazlnR5DikTZTSTuZ0WCN3ACC40SwdT6kFMXn5kcmAQsDocN4bjpl15fJYmw0QP/9SRDXTrDylGJUqmxr9aCeb5ScAwUVJlNkAEVn+LhCj7AliuczGDVO1dKlL7icFBufJt7UsXz+a+sppUVuHLZU22EtWIEb5slcjRiJZ9XlyFrEHMrxOe1PBOryVVK7VJwJ5Q+xWuBJtWoxkSl4yQeGkqLwpbbXj2SqnjNhpJ1HijG9JQDYKvJ/BxKlOneY0K1s4QXyTShbbDwFCHSvGmd6zpOtK1SiR67MhEr4y+gdaFXEezL9oDiieRxFdV5DFshk9Iy6Sta0nkonbzM92tpO65p/7JsK8T/zr3EvCbSmVJMyShBp36NuCaaLSAXIbMgfdt6D8oe2nb6NMaYrp5EYReLQ69KAAl9CrFYcIJVcfCRWMT2CmRnSWcekF2FiJ6NKLw4xiIgXWtyaeb2Jwrr3YMiYjvmU4Bpp+AnfCNG0qNWByJme2IYo63QG/d3tlDr5SeSekH4JkUvEmRLIZldOAsTAVWQqoRBoR2vzp/gZ7nGpHRoJSb9/+T6n8leqxbHyzf8veRCRMhfmFcpxcqpO4hYqORFcTGihG69PZ3RvhIPqXJCJ2HHTfI1mhQktDbzaCxiA8rzbxToSaja25toz461fFmVbe7jtc6XQbGzWwtXU2VdPXov+67JRMUaVJOV8tFYvviuYiS1it8UxBp2ZUY9pQ5bUrbwUUWxKa/awDEyzzJEHZTA1aTa/JvRd7iWgjaRlPatyA6DmrAXe+8tkTNbxfT2SyYRGX7ic8go9EqUPHbFfmTK9+hAIvDsEZRCVhW7sge/up5TQaUGORHBLsJzxSszD+kDwgiqSHqu/QLpuAHvvMHDW1WK34h36eXadojt/YX/ny38pESfngiJ61BRLNUXSr9KWEmREmvOJXI0qgbfzVbBbKup8et9I9gK6WZpvfz+O1teanTzxiomB6od7d6Z/f+3N5TEc1/ElIvrrsFMXjzqEIu0ORbKsXPpUqI6nYNYaBwMIuLuLrh0SuvBvGMC9iyKbp+qFZJWcK5WtOCe80+ur4JE2CqTycSm9PINX8DgRtwgbM0JY4xpJYR0SpViYrFQEKkaitaFktHuL+RrbcOt3YKvodAJdTVfzKwwlUBJaolJFCUstaAJ790bcaCpEUzbd2OxEFFqIkR+bB8KY4xJkFAkDCLZ6B3J6sk2AjPGmLmNuaCVj4HPHG6Gqo9/76oziTwslBMVd0DJNC8WxNUrwro8meBd3DylZvb5/aemFsquwoviWIyzFXh4DCdC6s6kOZjS9VB+Gplzc82pHnv4ckKriuvw+j1RN6XYaY/MKpfQEp1YnabNweS7kliHicWzSSne4XYdOOnTqiA/y3bRn54iNFzGWmZjykRryiSabamEQSlHJvuJe8lL0co8e4JcKs8evE+NqjHJWTB6HmLTDnM9Fc/uLKzCtvDdV/yH2aL1HDyZYn6KWPnNN+SwdBOiXE+PRSHm4UMdFpv/YIwxMyw9iVkiYVCien8IDxPlTfK5lxKbWi1UZ6cIgzvPRmMQ+08kEXbSoKzAFU9CTWwoomKJku6IjRGWzueexSPWuz6zbGXKpRw6X1qthbcfuRjUpMeHp4TulwbR5jUwjCzzn35ipag0JjK35kaqevGTRWJx0hI0uniHEFcRoepZuwYXW6DgCdQXidDDWCZg4YE8+FQSFXuT/3aLGKO88YptqloNnMJaSkJ73QGiVfcOsxJTPhG1RZXRoxEnNpRq3z1xKCsIXplc7RjiHJncIPrJJwLJQ1gvJizChNvlR7HWL4sZ+1zCi0KZYfUTZkDffMftx82SwleSxGcWkRVftDaTmSTC9ltNYoyqwjWcSiBiFf2Z9OyYxraPEk0qaI3R5qrM6ldpYvRvxncukysThtlij1DtrGKlCV0rvRrFp1B6B0rbIYHlvCldN++xXTKsEp9D8Hz+zdF7maQ1ysspub0HyeEYOLYzYrvPcf0/f8f1f3K8sxVqcySM0Y6dDRZzjeRsRHTVqyHfV4U6rG/HqabAXUSEn79jK1ARvL/0+ipJhG2kpbwzvPZwEylQlNXDKtHDV3Dj03esOnsHE6pSBllKT8K2/TaGbYlWQhyox1uiGnnL8YWuL9oZq3Nx46/rwcqj8gQiMZ7lmWVWz88X7r0YD/Sd4CR+pUzLTS+zIPP1Lkdy5F8C6VBW2EqJsZCbC2LlRLVXy5PVvt8iIjube/PQ+KGYM+P3X8we7smxTEgyN2SC57eUjG2lFLliLw+qKSsILc7y5+f1ESPDSuTKRphCxN+cvpbfobYQairrTm7Czcds0ynXTfVutvDge1JVCPosakFOSOGOyx0/5/dksXB5HxPNIk0pvqb2CDW6qYSfXBITnVDtjOSideeTm/dupHXwXd9KcuS2MELopbLz3Zywj4ejSyJOxNTsyAMtVWHuTVuUFoNQhJ0WzXdzx1IWUXVqOVFSRdx+FkGdBJuQaYwxCZLzXtYU8tu5ROtKXb8J6/rOFYm6dunINkLDjU5E9ORWkm87CbfiPuV4zpm33A+jN7AgiQpjcqzaFCmEJf2CCeS1NQ4g9+9Lr6/CiUjX0dmzV0jEPpFEKG6CGtNUJloKnXgtyGVzmnggdk0QK7tMjULMHgVd3YF6+rbTpzHG7BWHaI8N/P5XhC3vS1GdKkMv5bKZtznd4uaP5z22D6Ae43l/byzzQ+zKE2bFa84z21UKgJ59iDr5VCNRU0HrowWKdT2Oz7BZF37/OztGOn5uvYLtsrOnYhG7MIOQ4UHBdZgfxX87sTafjRojU/4fG6IZOzOaHINBlidMzlQkavUL2oGYIla+E6iDkm6+w+HNGAABAABJREFU8CgesaHhXNdqImh1d0LmycVBvcoyF0rwHQ+gYoLXcFkgFiqxKufBZF7Jng9uyrVZRvCflHfE7KmszoPGOO97xmR8Xv6LmKQqdU6FnCi1Xs/ORCtTZGRCHtqbXBdlGR4cSOGrVgPZgrlpkYhHCNTYp8MMxKJCyGE4cJfo15Un5HDtP0w08XowRbmEA7t0Iv30WqCzFZwJWDfBkesknImfhvkhlqY0Rb8UiiE5ESIB8fJjO0cJS2UuTwTsWhB5Lf/k+leQiEfPWJ3fWNQSsaL9mY0roap3b7loPtfFM4OQW1YVypU5fAg2d6DUQH5exc1QqMbshtyU1OjqMcHQblaMSUTRAC6QEYN48CmDrCjrMLy0kEI1ndedQ2xOI0Krtx4TRhsj4MaPL5hspEjKquipEGXaLqrd0QvY71fcicJDdzl+Vm6SbRuxIi4k7q+auji3gf1ZNYI4pAI3fnXZQmDGaP6HTZBaL+yB1aVEadSI685+PFh6LiGK00GY91TNxkpRWV83K0PEooNVgORsG4LfGdiN44xZU/JQTpeW3AyFuhTPxPbTmYfcc/y7T0NsTQj74nGd6yE2MNA5Whw2gxohq8WIp+I0ZWpKMuvSsURitk3lnrtatK7Si6mu3aeEsFgk3y8l8mV7wpRoRplulTDkz8hn81wYAc5cy7V0czaJiq51ZiCmkA01lhm2nUToHBldHD/XzU8UsuNtEoj/+IuiT2o6QyUMaQtwz50vzOHqt2d75P5ePi974vBrXF8lifjNWkhqOiPxD9wc1ZUuHSu2ue1ppJMrDTeIY/eYPapR0FWRhHmrVhScDUtIKKM72wUKYVnSnIdS2BkSX8oIFUs1zqomJdyEkl/6nwhpKZypSFoXx88vxFjtg0es7NqIBRhzkKSp30ryXt5aR/jS5mYYY0wRN0L3auzzeFVW+ylq0Fznm2TOTaNOHT6bVoV4zzcfikWsTnWiOh4N+aJW9GUFVKbBMMR6jCJPYpvo47dVlvEWslHFj6Ti+A/c4FuKlpyC7o/e5LukCGJZXLgZjhFKiUUEBB04l22J6tOtw/AT95LZq7gOf0zMz/FeTLW4p+H+YmuJGGNMX6FEecWXvCk1HjywByW+RwQ6OVF5U/PdV0q3t58xmRnWh2PK0beJEk6uxXWtxuCLtmRy5NOKf8OzI314wibynWgxx7leG3elOmXvDUwElD32/mUkOF4LroeYqyftxo9u4sRCzfFCidSLiIKabKqZy9lqVAnejjWURs/SLgyxtKW9EVMKro39qetSvz3b9hFL+iGWqaJwABWIxZde/4rY1K+vufDdfElKUuiE0md3TUSSk+IJeAmm/Nbd/P8UJyJAqGcuORDr+HmZHx9yhaGssNddYBa/7AAh0/ECnVAw8v5BrLxChFDXutOsMoK3ExXYaEHLqg2i5HaLZGMWH3MQIZM1AzfIvN3Isl40gESindd5P2dt46G0SWhsKNKk3ccv4U4oXMkDnxjJgyBHV1bx17awj620Tp6WYxLRZSF5HYWFjPiz53yf6lgjs8ceMiGrLfgVtkaIMcbEivHQZUIMqbkYBVTw7ZJhhEfHhPP/+3iNyMbffzuTiD0ziJItFNLC08R4r6rYW4okfa2Qka40nv3pyqXZpv29HJNZRcpLncS5R6qEYecVfg6/CTz0kiZnIrQrkC2vtqup4bF1LV/Y+ZP9EOviPx+xzOWIlLQM3ITY/mlOkS+VpC4/xzbQuo58R8495BTH/hskGg+bEoBYmVYsKpQCZtIfieBWFCaNdrFVoBpHlBXC8PwQP0eM0JwpIQT5FNlScSdKZiUKn8qTBYlqcZhuRDb+yfU/M+DaJaRVy/Sl/kH6LNz4XMXBekdA3DuGkyAX94EbpHIAtScxjOHkRa/WTCI2H+eG1qUqOQH2XL8xxvwmWOzpBKNajQweuBWPWKAQDbHdHo0xJkdnp7jQisEcZ1NOjLlScPPyyOSCWHuxef0q0IR2P3MCJJ8rExA1261klE9MIgJgVwt2i8oYY8r0pIplv25MIo6L6jxRQiJsF69yk3tyh5umawa25H5y4Vr3rcz1FHMn3vFzu5JMoKfuIyegsFj7AeXcEeu/hRNMv9zi9x/SgId3wTRM1KYJG/FBFfi9go86SdlLp/DZqLaVQk4Sfc9nU7EpRyvV1IFJzO+gxJumRLMXnyk53+HYV859SJEDs4nx3mZiNHyBMOQLElMnDQpyfaURiE0CoVey+DT3NWVe9XxTAGI2x+DTS+7VN9YSmWy2hN/1dCT/5qNdfIZdw4kuL23hgZhrWXHwC7QrVx22R2zE/f5NvtONGlJob7DgiGUU4/1papKomSovk9QJbdkGXnmCn+XiecaUANX/bwy4FPSjHDu7i178cl8+mELdyTytOY5VkZLRVq2FUUtIajo1zZmhqpbMjtNsl/j3XYhYzFr2Tu3eoTEablRiU8cm10NM3GJpBX4vzEmG2nyV36FKNm5A54Sevi3mZMznCzq5iMPxjkCxvhHs7oWCDFZyQCRie0Y5rYrbLyezWZlyzRJku6uiUlTjnLMFd6T9KiZW+UUCNrEmSWglRnEjnWptkJG/kID2VKjnLdjEKmbBaP5b48qkRNnPJxPTTz3Xc0NXgkNVx3PtPL3rXIvfpOMaWStm4ruMYFshaDDNwZQr6PTmHojdjOe9y+RDqLpKa/6N2Oe8J49fOlsrCnFSEtfphE17jYl8husC+D58KxQb9wpRvfgPTKwVYhMspKpVUt6onrNl+J14f5UmxOl9RKaUA6gqjIaJUXNly/0oigfmNJEILhHI9KsY53pt2Jek0p4CrSramoTJPfNpca4Ik1emcH2l8eZZ0rgXUf1Zo1lU99xAYvGXXv8zA65b4qUsloHwzZMn/D1l1BUxmjwJ32mE6ipOZsxLvCBZc3IEbYcFratEI68Y3fw2AxEBz3YUajm+uAtiClpXCIh6kcqNZBJVqhJFqX63EJCG4jukb85enF9rthBsMSdjjHkhjLU+CYXRS4KA+53Y+I6MIFJSWbhCFinujpgt6jJeWByHnmUSNa0uW00fa7LqbiVGTctnZttnkTio5ghp4YvCWruesCW/b9ltjxSbaKVsLohtFZM+c0UilLEDk/SFojWmbL/nd6MR3GAxblqqKNfdsAHejp/VtNYV4fZYrAK5LiPF5NSeMdw3HgjuRP+Z1AkZO9YPsYqCm/TqA9tZl144P/Oxe+QceWYi0qdGEgd6eyPm3Ws5Ygo5aTabPJRjo9gKCdxJYbXPRUpsi2xFelQ+GeZZLELHT5GvkFq0ZBQiomS0M1Qbxb/7Kw9vxW1Yetq5ryuL7+fKNTk1E3LFG1Jy1gqdUOqUabwGIBY+U/AQhTbLl7Yz/pUk4sp1VjYEJY1x+Zn9qdw5uQE/FhVV2iSE5RTqoFQmVfLStSShdQ9f50hT5+7MCtU0xV+fxJiqcOdU8tiV8vD7++Rii6fMEBqGKYngp2+FF4d1TufqzvHLOyvaIpa11WLE0mYl6rBtyznESpQTMt1n2Z9/+ZKH0ul7PFif3OcaOyjkaz2HO6cz1DTBWB/Gloi+u2pnpBSwZELha1IukGO0imOgKmAl3zx4lfNQ9uzJNkWuVCQfr541G7HTov1SXRh6tSrC5Lv/mnOIufxAOD+gNu9xodTcNO17t1rwFdRhO7oWE7wmlwjnKrtpL9H/jppQDzFFjjUCKVGHtz0VUSIzn83Bm/GINRBTaN4dZiIWtZgjgz2EYuPFiSRMKn0GZfHdR5BNx4tk+werwHGtyPbDqwM8pM+Poex18Eiiuqr9sOA4kUM1HrxmLp/Nhotc/57ZeEbUGeHcc8f7CNSwN/fSP//8PIGnVPmJYL64Si6RQvWfRXMCppoQ7ju7cdtnfZZ/cv3PvDMe3+VmUETYlyorcMWnOPGI2WPl7EQT1l3kRjJpGbNnJUplcywUQai3UOLr8bM7YheFjbbiSeRLw2y/qpC+ffqaGW9zMcWRXugTHD7orDIGtGfluPsCn4MiVu4T5lDKxTHsEImgdo/RGGN61WRFve0iIdiB3vwbIYKs9dayB58oPDyUmdlpYZCkbM+Vh0vf2Rw/tdsqxhiz8SrfiamLyP9QI5iTWjgTxlDRVkv8A9d0f8FErzE5CrGEgofjKpQSg0XiGvOI966w4EkEijG6VJYBmSLLqrbSzZn1ELshUE3VQjzzgJ/32H0mG7MXsv1ych6JnyXaEnVMm9e57pSbZrt+1PBomJdJhNRwWBiFWIIfWWh9ekr06/4WwuOKlKrUOX1asLLfv9YZy5KKPJ+Sw6hhoqD7PpvJzVHcDKUIO0ygKUrF8sxk/t2sNSkPbX63ECuRzDw/TpL6lit8N1Uhq3gSrtWJOiyaRMEoxYn4XAfQL+VE/OcMuFQSUaw4UYKfBWKRTHAWVkTzpRlTj1XL9ut8MaOt8dAHwjDq+hz2idUkSvEyFI2J2cH5f4VYzBYQvJpiUQZUD0Vlb0+AKAntUhVYYeSx5qSNMaabQHBUJe7RiXCrLUltjG5nKA14NfbYVxD1ui52tqD+Fln8kOa8v8djeYhs2sbKLl0mrustYkzzO1EVVZtEWDbuKQ80tyyslOuXdd53lXz2Wcj227ZBZHuHXuAmN3sC1/Ca+Ryjy+XKivroA75LPYM4vpfgByblmbM7UbcJTVmdXYsjbyarMBZSJMKDYgz8t09cE02Fcqry3Yj7lcn8W8H/2GChPWdvMDE+e/AcYgrVyFSbB4t5w71JCUFVzMnDSx1oasLo5BOuzZ/F+r/8wokcdgwQaEJS/k2VCBy4TZRg8CLymnwFIqKcOOc35rsec5vfq7iYlLCPygRin0vTiu/Np2t8D5WwVKEBRJfz5SMKPVr4mnh3ohCYksxWstcfYqgx8U+u/1kSocY+R7dnr3/rBS4alWwoJUo17aG8OEL7c2TycyY2IkRGuV8Q2lT7pUk5woMRJzgKOldoTGy5zsTq5jP2cZVS5IhdzMajopyxMV04zrkuhpltvsx8sWxLamOMaV6YLY6FMbGITVrCamztUJKBlN30n39y2Sq/C5Paed/PzWc1pe5R5MwQxJr3p0DQ5p2EG4+KEWKVWKmWyS9PiFhdv8NNzm6j3LjG9yav2IBalSIPwfVHth88hF6HmkRYMINjr0dDAhBLn4IHupJMrzbVmVgp2+8Lz7k5lsnIoqK9MPPrWYXviJKkV9MediJgjFaP/OUxn6Ft1e3fnevcU1hSK0RETXZkEqJ66p4r3QmfCSRqru/tjZi331TEls8ir6vDRGfCqEZSJ3Xicz0oJs6+BHXo6skCp7kwWlTE7SeXiYCY586CVKEO6jhVI6nNAli4fePC9/Xv+/wcSuvhc1EHk8YdoQ+bBcnzH1xfhRNhj3S+jedLpA7zkhl4cA+aQyh4fl9vxJR7pmqPqMmOpgL2V1LVNy0pXe8szLrnbeHiVSOpExYTdUiRmht1uQAS2pQEtUdvzvsubkZouVMpvkiFMjnHKC89YULSsjQh9E/i4Fbz1Mo9UCEMV+dSvMdnOuH8O5c4vlalFp+rb1XyOFp6OL+Hqv471eBB0Eq4Uw5YRYEc1aaoOIoEV+8y7CcfEe6pRQpwI1HOm3b//MULHg7NPMlhOCuUGLO5snIumYWH8oJJZLsrdOIPoS2s5Ma7/szEeltv53uYpyOFetq2Yvtt5xUm85UEiTRUJMd/imQmp3AijhPFjLLvrhFIG/Ei5T0cP7crxvfrwSuihkXdeAArLwolIV5zLpP0mQ1F3/0Y2zTet5gwpsjngViVXGy1dm7lRBgb5OHvRF7nwRo6jxM2z3eSh5K3L5WDV/Yk+jcvhi3Up1eJ4N5ZH4BY1vJst+St75zWE5OxxrUeOUeelTmS+WwbhaDSVBmJWKt+fojdE++6TBgEUdM84V76pddXSSLspEFZgdvS2MYYEyjkgRV7upvQHdgVwEmB61dI1FOyrGkFy1jpRDSz1M2OT6mH31Gum2uFLGmbFbzVqp0RPLoJYsNFpdyqvgdi5SZSgEuhQl0tktuPokpOJvrp4WfYix4yh4d+0ZKs9gZX5UFtV53GGLOrL0fVFsYwEToi2k/thWfLqD3OiYLDwwjn5xUjtAfGch2GdebhdUa0H46O9UFsk0CxjggF2jNCllhxG9JbSpEnxQRLyTGsMHNlZeKqJLPni0kMZVXdzE/0bBdyFj+XGzc0r+xMQG89dW6QIcLp1SbuGWPMD98ywT8tvF4ypGCCr6ThD98T7YFiTMo+CIO7T++5ydsJTeHOpJrvn8J3f+Qacq6UPsHf7wV0LVocz6uR4JogJw+5E9OEoZmYPPDfRCTObhnk6MHk4MAoPlfTn0WFquxfHCE6UVyYiBXOxDWnzNZeiO9lMjBx32wJ3ClxMK+a3PuVOFQ18TnMJ36OndE89F+cFxuHaFOoMdIqnZjkfOn1f9UKXBlrKbdP78rsiSt/igldqIGuCJizGjAbz6CgP8sePFsnqi7O6cNDL0QItfgUZoU5uzEf8u1XbIXEi8q+vCXJbYwxL94S2alTgBv1TMuYyKcIK7ZHb7igow/xYDkzgxoLn9v/71WHa0Ixj4OmbELMrzMRgKy+yxA7v8DZvrCFtozRTPzRezmC9UxUindjmUTsEaOLpy4KZdNeTITbCafQrIKYZvfsywjNhQriczTKx2S+uXj+ozYSRj19nwhj/vr1EHMRXIcrgqiqnrVLEue/PfGY61BNdXwUm2iDvPxevTaS1zLtSCxiitBYszmnDLL68PAyf7IgGVjBiZLmTs32Q5MZfEcyiRZinZ/LIjZnGRFc1aceHMH9tWkDilelSsbiSKlsKkEv16pjnYE/eD9KBHCf+3SDh+NAb0py7w8fi9hhYVNfIIOY/hHeNOmSc+9XRmU5qzmr/XRl2RZX4+iel1gYnN3Ftooav1Rk00ZLeZYUERyOKn2JapsPvO9fen2VJCKjBX0qDkNTxVgfyYot6Y/8SN8IKPyUkPnNlIwv5mzhgVAsHW94wW48XCYFOBfJgLbMMnsLyFCNmirjE6VYmUH4X9QsyERg7h7CjRu6sFKuI3qANp/gQTyTlA3buNn0bs0Wwo3nXJRZhUBOfkGsrS8MbJSwlhI56l6WUwa9hNBLvWDn95/Zxxu/c+8NK8c86YimtSnOQ7lxHxKp/hSjkMfE5vJAkF4/fuSaaFKAh6H9njx7wt55y9asMOedIMSrlCML5uTzOiD+rdIYUK0LpZTZYD7fnYUtnQfaol1k0988z1jdhiwgmnhwsz28l3oVMYm5b5jGXOtLl3KK4blI8AceZDJQc64TdRwnRlKX92BS2WQiq241Vvlde/7b4Dks0i6sZxv0ojvboO2K8hB1E9MDjaZHIRa329mCUG2VHOmpTBu6jOii0sNpOJkJ86sr5xB7tmckYuEz+L4aw2kHW1jKGGMS5HbyOMa04n1T3Cc1+Re1kOOs68W0lrL9jg5nuzT6WyZHj7YMREy2Pb7w+ld0IlIKVzglIjVkB/tTinmaPS0PJXVld2X/MJtw8lM9RXUFzne++GeEPXTqpKy6lO23IluGXGFfcIIfiZWqjaBsydXX8hf9/qJWEhUt7Har9yZHpLOYO359l/PZYZNJXpzbmOhPgKiKlBJnffF3j1uyz8YYc08Q2kpZMHIu0WqrK/wfLgfzWWeuzkq0XHNWCqmEzXPEZULQL9+z1bZnoDdiSnnwuYUUKc0JdZ28zLVUeA03+ZNzWiC2Pg0r0TH7eKB/+I2VZ6SQZVZjpPYmvK4rSb+l+vE7KE+UGvmZfJn7hN8jwuh/0kaIMo2aSPRLjUJGraDwT80xzh57fBXyt5qM4Az/prFcX2HCVDA0lG1F1Yvf1o0cltTVWdmrg3pdP1befiIZst0zG7dmC3FHFNfNorEkDKb+ma2xoGk8gN/+zv1FcQzUWKYSjWpXjDoWQyKd+1U3cY+KleZzbVaNrZFOK6jOef0wpQfidjJxjS7PAmr6QRaVn3vOfen1VaYzFh53slYX7uUX+tyJDcWdOHuCC250D7YRFPFRJSBKXEmhItdeOg+l4sJqXN2+cKHGprQpalTj4vUUVsV7BWnswmVObCzswsQiT1r+fzWnO6cYGgpdi6BgEouUe6BNXDRGty7Kiur8sjCh8fUSrbBFJMJ++siDqpew9B1qKTkqRcipYurgrTgIVSK4XEwPKBXLvcJa++JDfpaaA9YhdnQWk7Iy9Zybi6qSUyQkqrVTTB0ootaOpaxYPRvx+Stej4JllaLguXvxiFXp75z2sNtRxhhTTXB/lgkUzqcLx96K+PA5LGnFw3a2QF2UyJUiDKspg7r5nGjin2LfUFofwfWIOthKusYYU1LsTS6J+fxjxIirW1ImhwUzc98YvYftzNO3+Q6v9HXeT6W5oJw9N20+h1jGbESTIkQb8KXQExmyjS05NcWkpjPOioQxcxsnivFwJS2+M/xM11FlyqVIj37d6iEWuZt8JeViKhGLEE5O9RhOXtNkIcD3T66vkkTUWej8AjEnqc2gtB6eCnfCq+djEVOTHUqfoXggK8q1Pdg/PC5aIUrdbMVh50ZSqygPwidCEXLBHLKzlcR12xA++Ngb3CC8vfmQy+ZgS6Z+Pn6+A3f40vQY74Q5PcszmVFCUEpfQyUp1acwiSgv2Ogv3qqqgJumsgxXFsy2J4gxxrRY7sz4z56Kxe9MFWuk17QoxBRhNKtAuoaLsb/NV9kXTZeUfeeTD4im9BUCUf0sER413ttCyD7f3B+FWMTCAMRUS0qNwirRL1snwBhjxqwjAnB6NFshtrth+wVMIBWXxKvH58k+//aJ7aJSQ7cjtkZ4s6iEQY0MZnDjO3F2rbNw+Ua0EP6+Te2TfhNoVNW6CNtqauRZed0oc7RgwQkJncVkVmk7mN+YWCdI6ywEWjflKL+y2l4nNH1GCIM3hTClKEfofuBojmT39eJ7ojhcyqhrx0pnK2CpmK4aIeTnbfdPY4zJJVRolU7En4KAubAn96vDQtX3rOBrKZLnh31f1uL4V5KIfYIcqSY2FHfAZmcbY0yVQN7cA+MI86n2iEpU7t2m0IuyB/9k2UjXFIfjeNEX23yJ/7+vYHbnSsN70kewnVe1YaWUogbtZROmYtZesKg7YpULOX9vsfibg1t6IKaIdapiVyqDSgjKLTl7rOP2sdq584j9/vnCyVBxG9pPjXL8HNSN8PjUTcz2lWBUpXF8AX/4kZuh0qvYE9IPMWX7nrsdD8PObdlayuTirDIDZ0bhd4Z247+rmo38GkXm/FbMryk0RVXUNYTrqmqrHb/L9VTEzZm8ZEjKKm7yHiKTXbzdEVN8BTWSXKLOUMTSeTHBeXKL6MT5RaxGbSdSY+hj0nIIq8RtU2miZMtlG2PMhBps+Sp1TiWsVVfYw2cS67BqMJ/h+k5E+gZt57tz3+JJnT7G5/XpNT/bjhm8l0p+eoJooU0ZvgAxVXXPDqS2Q6qy5Cspp0x77FclAspNtUdpd8SU0/H6dky2ZEtG2JmnyMVCUDl2KgTkP5FEfI7YVLQYrYu4TPguZ0pWQEUyciGpzcujL10cVXskuBEP/hRJCP3ZZEvlOqoYy8qvo4fo6//xScg+C7Ot5oVYecwQ1cNAb1asu4Vlure1kSqYskgmJjife1BtFrP4n0RGnVGQF9eJF0ltkMrQ7Ogioj1+1gEZe4NrzlZJNMaYV0IVsZHg6zyJJzmyTHYXxBrk5zMMPcspnkM3uLmeOMZ2S53qzk1jvzDzKip0ElSb4toWcgI+CdJvO6ES6iWmGMoKd1JXAa23EW0fWxNk0QgWC2r6o3FPoYqYnO9+ucrsnR9eRlK1SiJGtuS/DTnCZzhG8FOevXfuiSl/JAqVVkxEDN9N9OehMK5TIlrvxTvXoy/9b5SfRPaUPCCfiVFIJcFdN5dzTSw9w4pdiUglSM5R2+SpeOipVkMhoR1RvzqfQ5BIwJTeQ5dwTvHYpMyo1YH4He9GTEiVOmWGxkJhUqA6mYszmTk1ikmPbGes4LveY1g7xL60nfGviE2pg/vSY8ItS/Zxc1TKjq6J+HJ1Fmp0SuRqThP6biw7y0NuVSRZ2+mzOA8XmyNhjDG9NvDfrW7Lg1AhHc2FA17qJNwgS/ffhNiVOSQhvRaOh+GnWMk0KexsLShjpWJitGyrF19A9XmVTkZSoXVQfCjZ4zl6bUIsiZi6SZefMGcZfx4GVWo4iaobuxOJUKzzqw/5rL0H87MlSMjvf/kmN8NsLkw2c4kKUE3sTK/HtbPlF2fba/RIHnrx71mJZ09LJnrXcIpotfJk0rOyDScWngqxpQ4hJI0VE8lGUTFueueU87N07MVkcdFMjkYrrsOk+pQ4bjKFfAp1DRNS6Cp5USquanT1gdW6U0hEv57kZSkzu9OzqKcwUySRr4Qkt49fXcSqCDGo6UKfoKLgnLUsxL1j5tFYx88dilHBNpTT2Ka0Fw+zDe3JOcrQhqJnijsxURjrjRVIZ/BQGpo17t8JsW0rnLyjKYeEcFNK3o8M3my1KERAGXDdO0jy5h9/VUYserUw1hLqlAXScc/50ut/Np1RfzhbEkphsoqAW5WeRImS7ogtEUhBhaHkJ2TLzQpNWYHbExBK9OmtyM4TCw8PJUpTWmyiypRLcSKyNpqB2NXVZF4rcZVnFrP/jXAdLT2KlULv+szslWWy/3tW582bkfhWQiQvp84z6Tk4lH4iBXqRHFu3PpM323djl+CchK5mpfS9GC2b3IuoS608XEuKw+GWjC9vXiFzPGwteT1ZU/J9amxJNdtGY8YYU6IJhaD8+hAyHyk0XFSLo5k3VTc7ebojFtqRSeQKYY6WJCHvcWSwn+Pn/muYpCsb7bg4rrkqzUYiZtyYCPcb1wMx5fXhIfar/GJ0tYDgRNhS3WlzCCO0HNz7ms6kAJUSfQoQdvEPBUqmpk6ML1uDc9bxvo99wPckaiZbEL9biXCVoUSI98z0Q0wJIaXeQuKumuL4TpAjVSsgbDYTUCVfnac3P3MGS+BtaTMP/s1gylkrJGKp4A0O689JH5OM66uZSNIjlHLs3yxIGneg7kabLzTg+ipJhC0upYiV0ZNJhPTqz4NguID01DXehweaEpb63KtbFb7UthbFaKH2lr8lF2D6M+zZXV3CCrBgeh4siYUYSgynKKV2wprz3Kgr5GcFWGOyk9uhVDebV+aGqczMlANogTSEQpUoTeMxTA6rVmVv750gearrwjVyUQZtc/JkZjckcTOFqDDzp2WloPqdCjlQpkQBG4U+wXoS+lRroc1Kom47Ljsndg6fEJXowXGIFR66C7He5dwRSycIo22LkRxdcRIre6Xj0Lk9xwMbCYJcF6tXfOMSv9d8oX/hk5ObbUnRQlXqhGoS4+9YojOPMzPpvy9EtDqVYOU9cIKzmFk0miPEZwQRMq8wOEsidAeUr4lyHX5xWazD2+T/KGfLm2I6KX9GJkzhfk6tF//BnLBR0uDmR+4b98N5OFaaTG7aNsFhilnNUdu54llXFx4zF4XIU4ayTpJrdHMmeGm9qMSZoTYP6cbtqYgbsYyIRf32n2eO1W4mOSxqikMpW37p9X/VgEspWx4XvvC58nGzSS6SjZkCvizQSsh8xjGjfnyYGdq6887fU94RN14I7fxchLOVZXSF7DzglRa/4musvcDv0LwwJyB6bGBv75Y1Wnf9LNUZ74SS2VxFWEarw+aN2KhvXSPC8NefPIB//43/9lQwX1bVZ+0uxKa8RzsryixC2c23LDf9dwI5ei+EoPIKCXX35IyVaj4RsW/SsY+dKQfbCFNbeyD2/TfOKj5bKv7NoTtIeuv3s3A6DWOS8kqoc1YvRyQiZDYLgWsbuHkrN0Y17TB+g3PqpKEX/2ZbAY9POMDEpZ+Yaqk0mkiPGvHbKPx6vJoKe+jUTKxeRfZCbKplQb33Eu/H8ZBViDUf2Bmx1ULXQ+1pe5b2Rmy+OEQXCqfU9wIRvS/QHtXie7jMmTSoFkJjcXD/kIDI1LwYck6Uh8mipuS5TRUtGW/hCfNYIKdpExH9C9rvfIbHoolMK7OxzyU4FqnGqaOpQl1ZeYLUy08Uq+UgKlY+2sC1mSIxC7x/cn2VJKLcFGcW9F705hWJrkwOVg87zhNuTqoyaqH296c4lGy+hjFaIKlcHWayd6wRmTeCE1GuLDdl1YuMEDwBNYny/B3/bc7UXJiq76peQsVFiLR8HOyRT2OM+TYB73ncahpcXXvEe5LWhS/gGwG3X33GqYtiGbkm1Gx7n6U8+N685P+3YqCzGvUTPfEK3hSDmSuMispPYH8yQEh3/yBU6xbs55qb05TCYgtPcdMMmUYTKtvHoraQeC4/hpD8y6dE6w5P4pTU7ls85BYKPw2l/6EErQbWI3KoIOjyFulX8XwUqbpEV/bJzUMmUcMmsbJ99IZ/o3xWbvLKWr2tsKmvIFocNXs7SXmR01id1+1HTk/QYFbESvZbCQutv0JSda8y7oilTsYiRakEKwLiiF0sQNZYnkjVxVilQmuGiaT3iUA/8mbj/XUXyfzcFRwP7tOOyGnQQLYbGvblZMeGJU7yZtRiHsgVBjCpVnoSynMkfCbfc4UcpChCXteG/mz5Vuws2iMfmYB9OERhrX9yfZV2hs2BUBoDV65TMEltBk0EoWvfLzxE7ooxTZUcfJuc0HKtFoQ5D0azkhlrHfx1hA5DI+EIuk6oSTZeQvasYoWPnca58BZC+lY5m1YVhNb0Tclab9jEuQhzFeZLrqYYHorETSUz84/HIta9NCvKYeuIkpQqyMOwYAZuEE9PsRpr3rMZYlP3OauRGT2Z7R+JZfKhrMu3C6fXfeKw7Ssk3peI5xUkVPsm1SZhdH8M/65NSs7uwnukpgmUi6eS6p2+lrD35I7knORzJZzd6zHvp6dIDr8Xp1KcNR6cMx0T6PICzr6xvD1itteBMcbMj+DmrVCHV7+RlBp3jElZyW48lFS74cwSJ1GvWE/68DzfyATH1s0wxhi/ueQJbB3gjdjS1Ux6lHLoVD9yIlQVq5Qnbz6IR2yzdaCV6UYWZfZUnLC4KNqxr57y3FCTXvOEIm4tYZm+9QbPjbgYtqRVcmR7gPwlzq+nYX6IqcmJMF+25JIl4r9NmYhrqVJWoikVW5H/ZBLx3TEJhfDVF17/CrFSuWSq6wfRJ1cTG2+EGZS6ClUgk/fCAb5IKmFQLZPeU52V556ahMy+EwQ85f9gm3kZYwzpQcZsPccqTilbthlJouqIXnzJg4dQZdAmbyoL8Tx9+f+P28/71r0UWwjthLDYEFFl3LvF7/r4PhPGmCzcDHJU9EbMIyNfmtWrnESyp6KyKZSb/38FMaapEoZKoiX1/i3N4cpmFV4Ut+MRU+jBk+vc+O+tcY7lPRLtB4VgVctFGPmEQOviznPj+/MvTmeUajMDsYGDmcwpvPPmC6JYdpvGs/Yi/M75EEL8qv/vWpwJ42p/JmQxj8hruPKM9/PGfrY8Lz3i1NmHP3jI+QY7i40TokUXK5RDw4Uy7Z9/CufQP4TY1Cz+jR8FWqm0HtS4pYLMf8/L39t+0/mZH4VTpjq/IC62F+3oKUPZjt4wl+Tg64/5XldpwhFMr46tEVMJwyghVT17uvMALiD4IAdvMklRo5Z1BFp9dgvffcUn8Wk9HrH9q2iZ/r0Q0boSxwT/S6//mWKlbdJljFanVI6d18Ts/IBGrNgGzWEFmK8wYbM5TTwQU3oPI3c74Vs1BqpGN68/4+ZYv3cIYmqaQolN1S3Mg+pX0bN8/o6wbG7xvWyHzlq5ebAoePRWHF/UcTv5AirHUkW2fPqeL9KIEGoR3JxZD7HWofy93bt579zcnejMhOasWE6Jcc4fE/D7tykqVFcFh2XQVsrt3rzFNRzUhu0MpVi57wwrtOSW8+ByQTZUrQBFLAtZzso+aAAJYmGH+G8V1+XSTJJ+FZ/m5kUih7bMdeEGJIeeCSfCoFDNc0/iEcudkm3Vv9gFNd5NSHBtN4w6JM0LcK1XCWBrxVbPVETIpoJo+uoDERElQHU5lohFHjF+OrM+icVqcixzE1bnSgyqzggWG59uO/fJXD4cXX0ubNqTCTTt3lHu6d+I0UUpQV2WqK4SlqpQhijpnAa8T13XO5HTP0T73L8s/y+lavr0Es8Sr4YsAjuX5Z5TSpyl2euTvGkboRljjOvPgxD78IXTGV8licjRz+mz4CJ64j8Kd041CqoSkCxi7DOVmO0/eSIWsT5CF1+NkTYSCm39GjkTGiWN7T+c8rCXQjky1n8LDxab4GiMlmC9dpH35AchVvNTSmbGfjXZsz9y3Xmg5RfiQAOEyYvS7FfOqYXc+P+FCWElZaJVS1iXP3jNZEMd6H+I0yAoyrlZh6zkC718JJnSivSauSWr4qwF2Ap6JqaENg2lXslQkWwo8aaZorf7dIWzolKeIGpMc7IYS3v1kQdVyYzcqFRSojx+gi2dAGO0U2gaMRU01EpKzwr4+Z44MJUB2ex5nEQxT4jqbBMGXOqg9hdjlIocmkTsdZssHlILDxY3mWoTkg6fRb2CvivPIbZeSCF7duR6VR4muXpRQj7+RTxi+4I4UaLsy4M7OhFh5c0x/TCTqMiFRHD9hzI5qJ6dqF56Yedtj2QaY4ybXyhin67xPVGciFlWYtFAiKUFVOS+ueEiEcz5jYm61F/Ez6FQDJOA782iGVwnHbvO4L8VI6Nfqlj5VdoZ+SybZ2UFrqYpVMKgBKP+/JMbmkIn1BVxgqzlURP5YEYM4gtiu3gWLCqmSYQnRmNhcezuRjJUhPBs2HuL8GUlYS4ULzb0ikMIEZYRCcJliwx5XmzKh7MwIYn/QK7LwLmUgi5S3B2xVUKoSGlifG7CoPQeZm4j8e9EoDO7V1V33lT8rsN3E2E5M59juskFjK50IgZEkP+hNAZSJ+UruXYoUYElVsLsmYFVp7IV77KQG19iMf2jpiJypOKmXFfYuSsfj7nHiWKo/vxKS5a8v/gcSriui7CbVsZHdw5wZO7uc7afupXku+6Wggnzzmtch+M3Mjkc1ch5AAUIxPGblOSDJRUE5yL5mGiGXSCHSbUkBorWxavr/CwmMfcrxU9R9uUZrftUuAbN4dQ4p+I0Da3IUfNXYu+LvsNks4Er76dSwHxxm+tkQxhJ1Hbr9vh6EtLnJvg8rsdtUaQpYa3UiwRhWEx2dOxO5KhxAPertCJx/9LrqyQRdjKgWhcKdVDeGW6+9Htf4ssDqMpIuky+fcHEIpUQpUqUlourqPC3PzXNmVhUDSKzXxELrx7m5MCuDRy3UvbQSryo/jxukAlEb7NSJbZ41GipLej05A4/x5kT3OCHd2bSc2Asq/imgvilpjMyuXBB1xTfP+QUD6DTwnDm+lZK3xa2SL5Xl3HC5HdhyqQmIrxmUx44seD1qAmTlgKWVBD8ol3knSQQ2iHPnjh7m0qSO+4pe/2HxpPt/+vvTA5twSBjNHLgMYjvoSL5JRMCbJkzuyBmCw4dDQnA7yT+nttWB2Hn/PwdUbi9QgZ+/w3ep9Ur+a6r0c2FQjtlW2/yLppZ6rTZMvAgKFuB76/yjrj7VhgXCg7HwI5k8StiqXnHd2nHfPIY1Lj4YoFs7bbUVHuM4ntT3t0FMVclBd4yBLGNo7mGOwaQQN7NjQmIGsH0G0gpaD8PnhG2pPX9QzPwO2riyDuIbeASDTku7OXLQvbZMappdt9Ibyo1ERa6gPuhSchE+D/h4mnrRGQQ/W81naG0IxQSoYSqhu9iRv25AlTDRDWW0Z0Q2fquzpdQEcE8RTWZrROZ15/rxHlWmFwFCmc4xVlQ3gYJxQG0qLmH42dFGFRuh0psSol0KWEpj/QuiBXuSLOpUpVI8kwloMqfxb17+Z6H4fQQZytAiWNdFDyExGI0NlcaoTopSMSKY7Ehmv1/W+LZGO3/4buY7QybgLpQuE72WsB17pqanIBB9ZiA1C/ITVTZLaskWpFDbYTBGL3x2dLyqcTB0mA4hYoUUXGJcFmsnJ3rRlX7qZISnVFGXSYTk5c7K5io2u+r2nXLjSWqV7kUk8+lizmtpcy7anbliJ8aS1SCUakrsp/euDvJ4dGCY2OPERcQJoAKhVPk2NlzKMh2YxUTnNKBTGZ3D6E8dMdV3CPLCeVgJYVtT3Eop0/VLni2jTyENN5EZ/aHMrbiPBEmZQ9esDDfVyWF/WjXCMT+kzoRywVyEH6JNyOb4DX0msMqNqkQ71HEyoV72WcrJ0YG2wor3U7iAL5jVS0XZhA5UT1RVcV9FDHFlFamZOuEoVVkFzrq+a7kdxgnesX2Z9lyndXZ5EXkDozuwYNqhdA/ULyOMDH22m8Lq6Kbt1kVZsjAg89NWFXnTc/Yg3jnwVc8ExPcHsOY9J1bwY0qSyomERWnUfY7nfhs2dPy7+4UG/DDWMKya4aQDLbG0lPZvJP3MlkK3rcZ7cgRWn2G/f+JtbhulJ35wIE0dKrVkUm/8oBIk5Gw/Kvnzuffy5frfMpcJilLR5Hg3G4UN9Ho6TwIn75j+7VQBhfEgg5yfzlwklyfgQ147zJZvIAUiZikqFHIPTM4TaAO23Qi0Vby++fvEnUomImoiDoW0pQlmrpoIQ/Sg7fiHT8rs60Umdku+lZMulUsxyLl8Uu2n8aKAlLJbXcT6yl4KrkYSp/B9rZ4cYTfS7XQHkWRuPhcCPI9EiKNPm34byOW0BH4/R8soFr2oO+MV3O2W3Z14978T67/q4qVo9tz7nzrBVbFI4S2f/a03KhzdafQx56RZAaX6ctFo6ZCKuZxohMRJ3mYr2jD77DuIn+vmcgUPxcB6DeKZj2qJTPdn4JZI8PIAi5iMcq9cwtxHDEKWKAT+3MDu1HOWPEwtl9nq6lkZh5yqj2gKvuVO6gWl0zA7YENnc91zgEmPZfP8yBQAlQemVixhYmRZLcM/L20LkyYt2zns4maUA8x5bFhy1cHC/+DfKJFp6ZJfkrEQ6mJaKGlFEl/8exsXc4eIURuhDrnyYWEke2JCqUvMVkc5j65+TnSJ+HnbTwtCrH5Qushi5gU8Gw9HbF2vejX85dAZ5pa71wukVQqvY46ojV49jATxnthJAJm8WNr+O/3TCIKeXHtTBBTHOlFSzqFQGxydXLq3zSqxykkNSVyThDNq/iRw5KqCLkD63t7I6YcNZUmxJ9CiVi1DC7ddKLpTx7G43d86/J7xT7n2Re5mGTWG5uJ/ijL8DV+LNIzVBTkSMGdMG+JzH+I+Txp7f/T9VWSiHQdnYeyaknUr8uF+ka4DI6pTmhVQabpBfN22E4eLFt3X0VMmXfNEvKivsudo6tKROu2GHFTDpvKMOue4Em8+8i/UXkC+7Nz23MhZUnBja+TWIT2COa5+5wdHl2diVtm4TpZZjwJSIpEum8fyWZFS/JgKSxgToXsqCmL2UNIQHSzDpJSQu1Oyfn22cRN5OoVkuh+e89DebwgwlYXSdm3AsV6LjRRuggI1m4jbb1EBGNAed5fNbFhJ1rGGHNfJBslBXkz/ne+w43bcI59xyrCqJdfcN3FvnJ+/6fifmQRycxLQfodVYVtwExNmeCsmchWSBohe6yk1ivm5D15/o73ZLol550+PRPDlX4sSM4/jkesZeAmxJRlerH0/GxFW1Lrwr8/0ZngWURxPteq2yZb1hKIgEKhrkxhlazcRFXirnhDCwUi7t1cSJeLaYfM5chraV7J+c4FDScKZ35nwiCtwKuNQkyhBIpsKVGimpTVT5GDZ+nu4XT7LeAmRKn+wfV1FCtTOyseRaw8fo4w/f4hlOrM25n68clc+MIpFOOFmAo5NlEQyUQyEHGFny+4kbM/r3gYP/7IUa1ooaaZLCPhu8zVubEaF/bnVL/TXUDmagRzlxj9+sPKvA/fJF9FkeiqzeLM9mahALlREEajoviSp0jKvxEgzKDG7SPZUPWdFQFzzk7nv1VtlfkCkr4nRibjbnL6I3waGdDBUUQ7/EdxIqhzF6JkynflwjEmYCOfOclaytdiwGZBohOXmk7pNoNtmk8fSY6d2ccbsVo9OZbnM5Don0r6bGfPa3fZ3mpYUIzf/sT3QY1Mhs2gJ8zw9bxP67oyEWxXlN40FZvyHb4XNRWxRgWcyGGfSP7N+0IwbKMYDzTPYhGqLrReigxiInAylIVLiWaTEFO+G5HX+FnCREvy2EPnM0uZlon7WF8PxFw9qZuTIDcP0X0TaGfuL+zsb78hoVFxFs6vCkBMjYwWHOjkZ/QbybU0dRGlAuT1O1sybilZpCnfkeEiOY5ayParOq8mCRRvRQsW0P/k+p8hEZWqEOZRZls/CTGYdGK0SI2MKj+NG1d4oCkrcAVBLrMqA9U7zZGKn1c5ez6O7INYlvZMmDxKsAeoxJvmRxJhmdSWaM+a00RKVrVx9sWVnHWBDiGI3VpBaeFCATwcd42kSmYLAY+PbMY1UUD4Aqh+bxNRUcfG8sDpYDGPbY6EMcakSiJ6zMkYayjIhufuxyOWR/jEKIRh2w1uykFziTplzeeOWH5rrHrrIrbyXAsz0Z7TlT3hIm6sWIeIUcAuJUny67qCtsTKJ+Nz2xIxlkKjOsxH7CLiOLsh5+6bC8vkZp4cSVUurlldxDijsDMfITb0DI3nIJYgmYvj509PhTvpZD/EFAqXISnfhx03CFMPFqO2OSuTw6B0Mmr6MgFr3ofJoa/glw2JdKJ4u0Wb9fIDolDefky+TFKuTf+erNjDtnM/jHvMFuqLNSw+cvRga0FV7Db/rWhNum6OncF9vpNAvi+J77/xF3LTMrmwXbRNtPylnoRoZyj30P9EEmFzIpSw1CfR64+LYzambKmblGMVrwSjRu3m5vJaQIszhbnSYSG3vN1y2pvTiP9O9dOUeU3BbvTJ8CzHlsHxbaz2k2dhlXlwDA/qJGKiIJUw1wk746zY18QQhTm8mgz4ZLk5OZE4GbPnooWYpM0V2vYVJ/LAHNmEiYWqlG+/YpWhqtFmVk95Qy8iM4ocO1yspanCbCm331LE5g/ni6pGV/eIccNiomXQUHhx+FV2HhBZBeciOpZoSjZXvl8DAynAEzGbUyJJE3J91RtHQSeFWHy8xgM9MpQ9YHvayRafMsaYxoJNbx9cxhhTSaxDZY6lpolyCM7CLoH03RStMJUIPlrlTMCHCE5PYCWOJC47TXQt/gNJf1JY6w0RRqX22KA+ybZKJyFVdhY4V6eS0GofKeVEO/b+ba79XaOZHKjCLfS0mFiYI8yrPvHfKmRDjX0qkueGvk7+V8Q1fodnolg4IAjUTy4QOVGKlSo5iDvE1oW/GN0tIThnh29zT/jSJOJf8c548oQbvEoO1gqxpdNPWE0uORCLWJfS7ogpPoU9MmaMMcvOsqI4JZTx6pdwZtnbfhHtgsv8dzNFVTSzPxeItzsToW9aEE34JORV1aTArqv8fHdfc5OzP/McccDXe8RM+b1IyKYJtv/bT2wXNV1C5GB5R7YWEiXkhl4ygMTSv15zg4yY7ofYvcNOWJ5zA+x1GmPM8MokVsa95fdPl53VueuPTNwWx7DybOFBeLz9KnJYmnkLC+69zl7xgYEkuL4XHg47rzJZViJHkb9wXf8izJa8fmYlriZRZi/knlAkIxOmHdY7tnTsfPzO4Vo8uHb0ZrVbtD/n5Cv05X16+4lJz8i9hJF9CxHFiBTthkTJ+P0z1HTyRG5sZBWbtxunhFQrd88wTuvEteb36licrVY1iXFKIHgbVvM9/F3I1CsypC2s5pmfSd/1GJKKpwop8OijYvpL8B/u7CVyMkcopw4WiVrmjrzv786Tc+Xd1/ms7cTQGE1wTODO4kO5aSry9bMofi81WurlRx6e0onw70si8Jde/8qIpyIgdqrMjXrSevZ6u9Zmdf5JVPtKiXJXAPvzSo2u2hhm7c1qsQJuXdi5aXj1J2ScJBmrX+WnESAUCxVKsl707FeL6QGVvJTIyk05Xxp+vjoFnN9Lzf+rCmjDEcYUEtOrJg+W/kI//sNTJnMNfQkjnhe92FSp+L2WtWIC9ssTZxLZdTGTmYSiwrbbBcYYE32IB0ud6twgfhCbXFIxblclO6vifOm4yb8TYlBtrTZCiFAELdyZCEO5ykwYe5R3R8x/MZEDe/zSGGOuzafK4ONXgmx6gPdu6yzqhEyZ6ezFKyOsOMF9ilwnetHfsU2hRkH/FK1MNSXk8gOTQ4ViRF7nei2X2flcG/ekOFKrrhwhD67P9eVaZwZizyLoE6GUHXPXpu3zjqV9EUsikvkGU6MQe3Gewnon1wxw/PzuNyazSpvCcxRHJhe2ZUsuuZgmmiwSkGl1KAMQfJhJyZThCxD7JhP/7bzBzuStS0eOX17aNRmxIr1YBJ2YxnKmaANhyS1aEoowqXQiLl9iK/viFHIEv1Qn4qsgES+tnvpHYeiiNBxsuWxjjKmXlxDkaeGyp7wz3giGtkoYFClT2XzbBEQ1YRIRKQyjhCjVgyciFstq+olgxUddY7/THj81xpgaOZnxTxMvzU+WuI63cLFUiVu0qHZvCVfM1AJ12lOZffI7j7jw2xVndR6TgZVdfeG6OuNwLGJ2T/nJLSZCSsVSaSLEvWFlN60uN5s+kUyOM4repmsi3qdzD7nWl59ishVnwejKVjttFq5plTAoS/bWPkzmp0zbhNi2X3ifSroxOXoh1rXSGOg0frfj56KlmZB29HZHLPIR2x6JClDgqqfwyGlal206hYAoqeZ0nvwb4wVp0E4aivhQc2XdJqJQoas44pnLk4lg3j6sOpWfiBqPVMJ199+w+BrUnPep7XQmZTbfwbsHW37KzCusM/kvSl/HszmJoOYn7od7D5KQfUG0X2oIB8x5MdwnQo8730M5dSGQCP/hRCyUlo5CLG4taoGY0hdS0xmqPZLBmwjYf2LE00YiahXl5rV4O19yZdS1thOJXyqJUGNUqjpXGhNuIgFRxMoEVl8svz/7U2pc9LSYEjg1iYtXVZjqpTn2gBD0ozfC3U+MPilSaibLIvqGIAc2KcMDM+xgLGJXd1Fl79sMhAxPCUXBsgM5+qWUPfO7sWr5OYsLYko9tL6lTqpGSBVP4NwDJkedS7B1oYyEBnrz+yutB+VEqrQopq8kKvDupfOdyFGYf3NIAyY47gI567uR0PLwmjyA6g8lAS1XYWGsJVQ8bZVUY2iOZgwRm/ViMufJZSZpafPy845qzUNPyUPnFJ4gxdMR1VMHqxKlOiW8U/ZZtu+h4XymijcSvZ7VqVcD6h9sW82RQTVC7NOH6FSrNpySm1CD1a4q0vI3YeVt/nAiIKkKs+X5OVwKY/Rhu0cQEJXJ1X7xbsbdYVGlhK+UAZl7bmeBc2fvbvzOonkB/HeCq1WlC4WgHm3hAa9EqXoK+XHFnTi5gVboZfry996s4YTZP7n+Z2JTveuLTUmY9yhzndHbyBRfL5INNWWgtA3einaLEog6etO5GXwu56JqbiICLVcQ9ovaSzJM/45syfgVEwf6ObZzdl/gy3XtCitF2xW1fQV3/E7AZCYHL9dSHEjxMBQU/v4tN+ByZXkAZRZtihXredimy8TKQ82K/2U5e948z0PpxnJWCj+PJrQ6rwOruCMiAbvzgt+1789s530vNshGYoz23lke8qVqOvlEPQVvongmJkzKqEj19UeL5Pvc03jEkiUgmJk2iTA0usq1qUR44qxN08Odh7manLn9kpvt0pkcK92zkA67VfoTbi5Shu/62Uiimn59OH7tW5j7WrJEzvtUtj8TssgRJBaqQ7+54D8ol1Q1/RKxnQTUhKJNc2AUx289alKWWU52dHRW6K4FRZtxOsc0N1zknqYIyavOCZXQnpzsUL4T5SdFIVYgB/eS8jlcELM5bCmF0Jaq9OOOMNFK15rCfdIc7BSRKOWxMVp45ygEyHzkGfmfcPG0q3iFMKw+9nl9feWxcWoM++TVZrDHrlocChU4PpHs+ZSJeSuypXVWjztucrPdd4XfQakixuzgYhg7lH2xoOU8gAdVJKRbXVhVu4ipmH1CZa5LGWdFff8tF9bZOex1p2jA7Fl5XUT2JVSbSHACzgkhnSe/8jBQFufRQmNEoTiVrU0jc14e5qcfsHI8NJzktb9Evr1EaExs30bm9ehqPJRPCITp+SPG5o/ns7CFhJoL59hVAh5Wvf78Qlb87ismQu16UKjpUgSh4CmHuP57lWa19/MQTgDtGeU8SFddJBN/WB/CyOm8uEfc28xDL/YFExeFptQsxkQgWwaiaUr07NtvSfK0Lc0jhnO6SplthQdRCOqEGA8s3IyH6P5F1F0on90Fse5TOT0xRXAMlGCYSnJs5OHkeH5XNeK54zL3/qFLWXy1qkWEbc86ikil8RqAmJKgzlCWfJI5IgHxt5xXHwr5bfOtKmT4a/XqeCCm2i9KCCt6C8+SCvuEJoxIGBKkZrv4S6+vkkRktObiHz0jFKx0HT7XlKvdqnOI2b4WxhjzSZhoKc2KokLbQJH8lk9yVhlq/E65SQ4ScHY3gX7sFBVg1Yo8bJTt9/GHPPhypmQV/1sOruBx1tjcn2L6w6cDtSmSpOT3V26fy0TLYGRVJkLxd/i9IoSuRZ/G7BUWH0ob3v3DaLiz2lKPzC0OzBdi6qLmDPbOQ8U0iRoPDexKtbv8HSlBrPT5ld14k3ncNG7uj3L8rGyUlYyycsBUSFdSMS6s+v/zRe9Y6W5UGUtkxzUt19NDC7FSaz9rNaETIBKmzHXIbF86jWhan9qcxFHPddxcCnAphv71x9z/KmVzcfx85w33uXqtKQ51aS6TCOX+quS3FdLlkc4FsZPTWcw8EMJXKslp3NIbsfCVThRzieXybIwxY0fyfVBtD+XO+tsf/P72RIgxxuwJY9snf2+2UJXfhRrTXx3kJGB6daSviTLRSl2D63DHXI5Qh4dFIXZvO5EexYkYIND6kMkkLn+K57lpzH+gnZGjn9NBTSERytnzpWBZnz3BbOxzXTzDfLkI1XSGcvZUDpBNLHGh4ULkplURViwjNrNn++kTD4xkIrHyLcsNfdtFoh1RUfwsCcVo4ZnJ7D3OO+58qVsJ29ufh2xFrFszauBnTclnXS4zk7lLT5lsHbD6xMYY8ySem1fBjDz4bz3n7915yoSxk5ezAlbw++C1bBcoKejwc2zdlMrqgtiwqYS9Y+Zyw1EE1AtCjz9XGn7/ujOdbY9OVVlNNynEqiNHZ+qVKEXBdb3YVlPkTfUdVLWvFFAVcmTrM9x5xv9LIRjvbvAQMUlcEAqb3AqxPTfJudqyjxyuc5OIYAZFMYkO38NJlJw5ne/E4b1cc+Y+q0mVML19w7WvvCNOPOY+d+0599zJtQiFK6MuRTaUFtS24ZaozpWGRQJh3V3ai0XVIVF1/32fe67SidixhhyTYoJfpawWzlrjrF2XETW+d4rIyaJJPKQvPeW5FDx6CWJFGvD5K/Gul4IjWGowk9JX13nvPhwgd+KfXF8FibCTBsWJGCA8y+N/Y5WhLjVa2bQhR9rUHL8a/fEVUOWVp4SRbSls5fXRYiIrLPecrOKvHubiqthQuGIeITyuFCvTunggNqEG77Ey9LLNq6aMCcHv3NtJolbPjdyoVRVbuCd7zL39yGFRhMbLgmOQNxW/v3KAHSJEXYo183D8rEZSVaxMFiZC8wSx1NZrMEYre36uaFCBdOTwpH3HRO2pRTauLNpbylr6bDDnyTOk4P+fudM6xCYI59ge/kSEatXju7l1OTe0w8sII9uS9Gozd8vCaaLsP7NP/CSOCYga01QE58EtPRDzGMDEeudQol8/ioN1SrDz37Zqy3ZZ2Fpux6rQODWK/zZGuN8OnMBkK1VWtpWaF+D7VaUdzcYi5rM9skWgyUnSOnkM2wIp764cNj9d4/j1xCCOva4VPJmhFf0QU6qQFVuMRWyNcMXsOpvonz1GGdiEhYZLaw/EvHPy3fTKyrMkWIxzbhNaSqnLBCCm0BQjhMWil9IK/kuvr5JEKJTBvpYLXYdrN3hwF8rLG64EV7qX4svQRkjwXhfEwtJZ+bAWzOELV6uFc0RmRWsShNz2kKhky2UbY8zkbPREUH3y5otPIKb4Gu1L8PvPOMSEaebKk4jN7+vt+HlRTh6YZx9wUxrnw4qlgbBub9GQiFAywYlQrYusafmsr4rKVsHNO8UIapmBztE3pabonpNJZT/hOzGtHkXEAsRkg/IwWSP8NHYJ7ojN4TDGmDuXmKh0bu/8rqqqn9SKfBUBJpi1gqg2rB3XcI+u7Ltnrsx+t5Lg3r+c45zlAtYg5prB+f6/fMpq+uAUIpOZBIFa3ZObotUaLZLPaXVILFSaFUoDYWhltu6aFnS6bJboRNKbag0ME+JII3YRJSmcnq3MpWN5nwYs4R75TJjIKUdJz0FMon59zfv5aLkTdVOCVAWKuiN29jXPg42CuK2uB4JUXziLcLEUV4DgXaiKfX1wPcfPaUqLAzkpUT1lrKWcOMODP0+8KmIFn039XosQa9WKiMU7Ib/wpde/Mp2hkgrFf1CKlQp1UElEseIctxsvPOUV3Kqq81LWYWOMMX9YyovX5pJYpQ7buv4hiN1ZH4DYa9Hv/UH0u0YLePTWY2bZn9sKeWaR5tRI7rrD7GOu6cxK9LY44DvM4YRBAuFP0MaHveiDV/l5/cT3KipG8MoNIOP943vn5qJ8KJR1t9JTaCZGHGs1IE9CjWnWyMGJnf2x/K5KJ2XoDrbuWllomt8UkuNmCdhTjUbXExopqv1w6g7XuvLOsHkoxhgz8QAToeRJiArYJO2Q8RQCUnoN0aEk0WUVo6aKJ7BfiEPFCPv54DlEXW6Esrd9XbTVVl9wJsxKklhNRPXtyGe4+RiTniOCaKxcjdU4a79hnBRYPp0H2ozdbDXvFUqhRYY5Rx/vXWCrQelEDBRI59Xz3Ifm9ud33S20dNKKNdwgD99DNQr7UyIWbkWbWqTMX/k3U3jysymFzQuiNZahNkmfaQtQEyS30PVRI55K7VKRTb9UJ+KrIBHKK8O+FGGyo9iA1BXQnL34QwLF6BTGUUClYtl8GavzHcNZefiMdm4a6y4QTSmXiQhD5+5UBftNcCIOikPEfzhhZJ+mXJi21oMxWhXy5FTCgdWsanfXRZJtJjZm1a3IdlmFm2i0GA9Tkwg/C9lvhVgom+tZO7mhHZ7E72onFkq6W1l8/yBG5gb2IHTdTiSzRfsw2agxitXI5cd8J+I/cI1FbjiOWPOizu+6YwQhY2X7va4ryZGJhTphikZUVDTPuaGf30jyWr1grsP9g4gSqfdpyznnWvzGnWjK37Gcfll6RoxoXyDSdSKQAjwK6fIUuh49ulZDrMkiPpv2QgzLvurnJw9pag7GlMV5cAvuh8rtsXhG7hE5RUFmErNiH7icwldK9lqpZ4ZPdgokufzA0WiFJD4SfCB1JRS+FupSrcE8glitpjNUe+D5Ieeopqq/TwoJ8YUC6VJW4CYh/+bWAd6IlWjFVpMa+1QaG5Kf8oXXV0kibJnrK0+IOuQQ2gnrhMRz0f7M7sbMIys6YjQzOTWf7ruSiUUTT76s6rLlq5OJZEkxpVdFEuJWs+2XHhEKTJSWn+134YFQSFS79Wry4FcL6eEFZwvGzY0HS+AmVg8rhATt+SfxiCmuS2Zh1LX8DF8uJa0dLirbogHUAPAZTzJYpUrOcbBXYoRUadb3X3MOsUOi2psqZvEHt+WmOUBYJo8Q7SxlaHV0FsmAflaCsMWfyXKe7ExwswoZ9IvC9lxdaYvzORTuSAZ4+HhuaMrFdM1RtlE6V3TqXdy8xeRz11xWWKp1Udad70hvoSbaVHACfFpwkw8KDkDsnCCCX8zNlqwt3hR9i4lxycJEoYq68XmFnefYa+g8Jq6ZPbkOK5di0msEY//Q8M9DWJIIorI9Cq1kwJXU+OsXXIefRItj5Dq2kOPjuJeGT6aJWBeRHCxdyokKNQqdurJzxPXZnpH4nVJCyr5mX5qDPdrFcdlmwnVWJVup8hOdiN5AFOuv9nz+/8b1VdoZdRY6K/sYMdKzbSjnuFXrwrsyySptSpJl3mMmq509I1mNJRUHf9OFrB5uX2PVktIaQdsteu5qYuPKbS58dzdm+zvWcpErFEOZg7X1IidCydcq2N92wPSdQHKo3QYwxpi69ZlEKOg+iyDqXRNTMmUyuSC25jxRgbciKRkrhL+2XuO/nbDMedgqFr86HG02vTHGNC7OTb5Eem4aKZIyYTwj2l7D1vKz7BWVhz1NY4wx1bI7P5+raA2kEGI4G4SoWpbkTKJux/N5bTjJwytfZq6v6UIKXI3RKkGvpNZnVuZjdfPw0G84ky20LX0ItReuwQOjx6huiJ0SycvxTdyo72/h/6d2VHtiZaHQF9kZzZZPJnF/i+QkgqecTX06zEBs0YxOiHUcTijcti43Ruu1VCxH3ZUMFtE+eBZJtdfCeM+viBatmnSbUJ8+R71Xn0Ps4CBvxNTY88V7/LvK28M2QlQIhmpnvLrJduSzbYMQS9syBLGfK/E8jA4hcV0hDGrctGIfTmd92NyV/98/uL4KEmHrQiRNLkyphK7BjUVUe1OKlYXcXBC7HMxq556wFldky3VipvztBx5UgTudDz+lOBzqFOALXUB4Paj2y8B+9RC7+YzfwacIDy+VySv+Q1eRIOQp7O74+ekKjh+mqE3IbJSonIv2pAOempxRHI4OghzaOxkPtBYLKKTUZB5juYQBmW3z+86VCWmpokR/lHS1ms9WKo4pfuXhXVQ4Vk5ozooiu18IYvOHMTm2yXB1Ru/A7yhVz4ZePJRVTzydB0nEyqisfxXep4XHSSIdOHAxYqoVEmMJf/0uNEzUNa8t15yq4pIXZWLx6+9E+n4XExudAzjZckM4FqvKu2Fe5yEfOottyz1LeyOmplOUwFNkFoEwJCJ0f+we0QTzhMnLk00zEEvfhn9XXfUt1PmAF9eSavl9K1i/hYvyexXKyILspUAiVDKXowf/bsvaPKgHbSVyeDxklePnsTP64HeG9acg27Noen0oHYpfxHk4RrjJmmQsXJSI1MjdLHDNs1jGvvD6KkmE7XehvC5milE4pVippKVDhOrkjNXs2QUKxqvSnUjZXRjzCJb9rAbOTf5XwcTO7sKEQaEkNknTGGOWNOemNP94LGJti/FFihPOm8oV9cpCGrgMs0Y834q+65klrFgGb7uK2JAugrz3K/+/odVJolSCTsoB9vw49qJT1KCUbJrU/Cy2kdSmIyRbPRbKc7+8FFbogteyR1hr79hFuLVqVW5UNjnSGG2a1cWfZlCuhZ2okGplHRecgAZ5WcV33ECyldrkk6XgoaRGJi1dpf/3Esmbn1BnDW7s5EB49WaS+s133LZm9CfXYYxACetXJ0qiyJv569dDzMudh9dRURwdOM/7Xt1Cjs6FsxK9I0ZS1Qilulb04trfcZNEcyXedf8gp25cq3IUMm8FEuGr5uaBZrcz9vWh+JpSrFS6FgPHbUJsWykm/X+Kd7OQGMm9OZu8qS7hRARPH+O5Yctop6kyEr9zfgt1KNQUhzLvmisQx9ApIYipJELpaXyun8aXXl8libDbA0onQhlBqSviF0LSqYUCnu3/YIwx2y+xArg8vzli686T0DWzPjfh1RbxS1U2atRStVVURVF6BA1cetTji19LJCWD6jDZUu2WPpuYUZ+xDpdPtfg3K4xgZVu5PEfXfvv0eZyQflPrIWb7WhhjTEVPTmJUE34SEdP9EKs/mDyJOY2dLHDFbF8reodqmqBgevI6RlRhcmT7PxhjzNZwPsPL1/kMn15lohazlrDk3XjngdO4M2V6r22h2t2mK2xJDA6OQqxGTRIaGxQmZK4QkGUDCOmenEe0yxaWMsaYbuudG7pKGOrUIbFwTOg5xJqJgqSRSKJ815L/8KNg1L/6wMS9YBp+vq2JuV/VHeWE9PeOowhc1F0WX7ZctjHGJElNzoWb4PW8F1Noylhrp2gDzp/sh1iXsXzW7oL03nhalONnH4HqKQ6HEqB6fHgaYumrClJiUiJ9zzcF8PfE1a4YE1wpQW1dmcswqbr05PP4RbaEtjHGhC9h0iNlusXY57FogToIRdy+kfy7u7qRm/hPrn9lOmOX6Ov23sTqrEwOZlTK7VNNdswUaMKkrbyRNaaSlHn3BvvCiotx8kSs4+cz4iBM8D0Ti8P3WZ16CfGiY6PIE1FuorM2EmEIXM3sOYlItnb1ZhXQyFIKVaQ3lTC8FxBvi0KsnNsKAapLj/hypRJmW2euc9OsKlRBX33khn54JuHA4daY2/VjJNoO2c5NefNOvmwVvJkwPBG9/tmN2KbwPEpYUo2W3hFM+c9xcVWS1L88ZbV3O47Peu5ATp0s2M+WRLIErACHduDY7wtx2P75gjD6T4m4Xn+wDu/s+biWIhcyWfwmHadpVm9nQpZJWLLXEWO1Shp/83AWB2Wykrz6/TeE5TdY3AY1flr/LyZpaqz05EJKdyuvi9BQIn2lxWhp7pSMeTViArpfJFsNBXnx+kxntb/vOombwbupdaBG2XtFCE8IkTA8iyA/YdQeniULQqnD8+kpEQDzjvtVmirnHD8rcqTiSRzdRCJwHXHfzq8KQMw7KAoxNYmhiJU7VjLZ8GnDpMR8YRLxrxAr1cSCMsIqU4r92cNHWAFmFJ4Y3woS4eVowqPfJue/TZ+F1cjLp6wCKlVyZu2PxShYcCNWbH2EjntCUdlMqcPERSUgK6K5yFeJ6tk1GTfI+cdiEbPVHou7MZnz7L8JsYJF2FZR1tqb9jOLPyoSprzdCFU3qSeqzOqE6voJwtXiZnwWz6wEKbcfRX4ig+g70Ff4tezoQ3EoRawdXoUJWN729ApYKlwbIy8QTTtxjujB9v7ejp+VHsr9OJJjy3QhN2HNJKJ1w9dz875xieswkxhLDBXKlheec1NWvJ7CqV0cPzcU5lAXp5B8PPcYk56wfTxYY0ZQ7TF1KSox+g0j8W90VSaRu4SwmIvQRLE9S1In5fO6EcdE69h9JoKz53GCJ0I8w2wiSVctpIaCuJ5ATHVVE1onNtnQGNpNt25KQrZyWO03kP4vOYSuRePC/LyqJRE+h/tLigIUwnt1loJ5/iPZzv3RKhi9szCB/EGMnypuQqBAMAtnYgGhWiZqFDRVXp4lL44xUVGjqx+Oi8TiH1z/CrFStTPUiGelPHwID4WinLKqbiIW0vwyPOSUaJKSklWtgBVnnQxq5ZOgJiKUhkNeoSinWhz9gggZXlrsh5iq4gZv52IdIQ60ihOdG/Od82QPd+7EQ/+AmMWvUZXPcN8pMs/LiNZNL18eNueFup1CZx6K/vGT11x3m686WzdLRxFGVhMh6YRyZs62Ify3Y/j/7bvFRMC85yGq2mN+xbmuh1biM4yx/F+apmHF7jOWh82emX6ItV9MPQk12fDxD1Ysah0O2MIET03Y2EifMcYstRI1ZSG/7So5B8ocyzU912bqiqyAv83Bg2VMNW7yndZSn0JJa18+xz3n41WrAhZsev8x3RErLaafak7jyK86vJSY3TJf8sYeCr8aNbqZROjEKBTTThqCRAtl6ULukVOCqGD6bAfJt0qxU10Knbs8iQqrbcLcEZu7ghN8Nkm76QhytZTRXP4CRLqWn+VeGtqFLskS7RAaEx9+5TM03/Hd/Deur5JEfM6VUlhSK3twZec9fzfRiSUHYhG7e5tQuHLxXDaUD18BMkFTNjl+TpaR/IdxgjA5oC03W58chMxVEnEntANiTZdwk48U1V6gkMjtFk5+QkAdZ2VfXpgt7RUH4Sax2dQVY2Q3tnLhK7jVPSWTuV+ecHNNKUYVy+clJ6ZtKFsVtsvo8SmEApcKv5IFTT0QiyjIZ5hIzJPXycv2S+IgElzHbGC1r3w8youe7fJVzk3uQTe2rRIl5bvUXdyjXQOIsCiLc0XKVATMd/GsnjPn5ruzSLTa7FZA+6Y84BXS+fdLbsoXVlIV8cANIni9FhDiztSCMsJK/yL0NFGiEOGKWbiRE6pXo5ZqcmKjcPrdsPogYtumspWX8G8mFomEsJiadrj1lMlRcqHiuPEy77vN4zgVywIyVXaOhq4L4DpUOjez52xHLEFyJoxNG3AqRLVMlglex53KTCKnH3aiXWodxp0QyNmf/F7RMQIlSMl9Q2lHmE9M3GpUJWE4/Ar/bfRqtji+9PpXZK8/l1ip5JYjhMdGXx9WYkq+98YL4QoqNBtaluamrJCNT5blrFo0ynXx4jNuBitEj7mg0CLYe5CLPG8B3qfzp2IR6+vHDTJYqHjabpybj/PAUP4fqoWkqpNK49mfs+f/jTHm5olziPXoxcpe9bEVGXDDSAqQ2WTLrAXYOy8kZGSn1SU8+FFAt0r/oXB6F8QUJ+iD0LEvlYObYT0h1fvYqjzUlESV/pwnT5iYiYWSlfcUvBYXoUWh5LHzpuHfGLGSVfxYXw/EjsQ6ExCvbDzgQmN4cE2vR+0ABd1fF8TSM9PI2FceG+lFITRbqBEqqN42Ppp0kIWRIt8endsWsUyuvL8KhTshJkd6Bu1FrGVT7huzGvB+7hI+FnlSEymJf+dEQLybkF9xYy+nq+6LEf0CQq9BjUcqhClzOSapb+OZHL26R+RIyXIvPe08m8InU9U1LmYWYq5l6RuTypNInxTbesjWsEQnBNnyc7kTH/Z9WWLxVZCIB3edB7Wq/vPl4qKsIiYsGosDs/QgmmOpCYjtl0ik6l6BvAvFAcjWif2zbLmdMNTevlyUo4WP+/CahO9URr1hBSF+t0K8TylE/3RyT6IHFx/zJXz7Mh6x6SHOKjZFahKVYgWZtVhG3rdBYuzz7Ss+/5EtyWTeKhQV2xVlMqeSly3lOVFSv9MMxArVcrZlIgUh9/ErbsDKd2Cs4GZceMrDZp2wDJ/ZkNM/bVbQ+EeZN80QIkTvPjoTmqYFCZkO68kpibHBhFtnCmLliPVMetQcv7IgV9ok7rn5XDv2W4ZY+Cxnhd5TGEYtEwqmnYXCaEgbQveVxvCzKdnvZCI5VnLeKzoREfzYlUnJWUtPZKrgQ/mX5V6lJkL2nybiOmxYCGJBE5iA3A2hLXXdeeQEpGlFDo8N5xujNRZspEAZRpUaSjQhvI83Yt03ch2Gh0UhZn7je3jvAJ91u8H0BPnrL+7Xntm4J9qchbkNmTAopENZkl8RvJ40NScitnRmZ8QkOiGu1iXJV5pS5+u7eH4VJCJdR2fmrZKIvJbAkTHGLBH9OaUwqWab4z4Q0pl9KBaxl2/4AH3LkTtROTurvVNWJq/0H34SzObcOXk4HjvMjFIx25WNcHYX8imUZ0WEcCz9TcgB222aq6tJLFOjofv2sdeteA0/JuCh30aIxsQLa/X9d7hBZnPhaOXkPbyf80ULwu5RzunKz5v5J97LKiOosndpJmHqbb/wns/YwgREOXb6C3TiluCEvBQVWqhlXqdQh3KVOSXy7DmTQ6Xs12MDP5t/WXfE2ixiK2BnP37X8mNYAbsLS+eelkKlSsjuCfllWy7bGM05OfWAh01JMbEQfZtV4f4YInaKO9J6Kb15iudxtsKWThHCTeIgTFGc9/LCVKJ1ahdX6ERJf4pcKSSiZWEWcytEH3/9Jur17BlX1/GzUn9UUusbf+EUxyjBTVF+HdumMzkqIdZXArG/pijRAzGl42CPZYbPYKJlhJ23kql+cYfoh1dNtsGLiO8QPEGsHUG2VBMmyh78P6FYaZMmb4qRVeXsqQyz4sSGuUH07FtNZu/p2ERmd+GXCF9Gnudi7T2VParcBZ193NnicyhU45VotXQWm7dKGPr1olLkvSiKwTQSluGrhbfFJOHtYF8qYZjZgJXzciG280n08KeGkMNx6zn5FPuP8UX6RqAOahQ2TQpCukfFKORvlrLjsHVkca8SCqZdm7EXbxNSjdFjmhuEO+1t8fyVZXapJpzYUDyJ2DfO/+/qEm6ihXsysVDqpMdvEfZWlzJgs/k1xmhi5ZNbhP1HtuTmmtUSbzt8gmsk7hF5AgmrEBGZtYcIzhrh16OQqHazOcXToy9dfBV5Uckyt5ntLEDUlED96kTXloVSmVUlB+mS8xDx7MzvsGYiv8PWq9RnOC08cVZPo0+K+YEJfsQ15/768Ffu6VWFdLmfSEiV66Ya5zx2h+9+mvpMBPw6kA/3+Ch/L3Nb+l2cnOGc4gqfzOfwaBsnHZQzc7QQEVN23jVHceqmcVdOk4XP5OcNX0xFzVnRsYh96fWvECuVEFQ2wXZX9uD5cpEn0F5IV+ctSKhm5w0mB+p6LCDohyu4CbcUcLN9qREndSlvjmNiPPLVCS7oFsv5ORTErySTj8/kIhywzvkSqsmJ3DtJyDw+nQqbK86xOlk1iGN0D98JUmZ+IlEdp5Nl79E3ErFTk1iN/SHEq9yyONfi5GY8uGzClDF6miCwsdCxFxWrSlyjxEZdtxM3g82bWdkprYSb1vhm4u/Jzfj4OJb/Tqx9n/5s5RUpx+9aY3IUYmNacaxWCXBduEaEqVouHiT2yKQiqiXMzXVTJScPm5FriKbkbkZRrv1zOyKmqseuJUkOVUCuzyhOWNmmbGqE8tpzHkoHpxD9Uv4PmXyolLhjcQBiyX8kYz90OdGJ8KCmiBlX7rkKASho+QQl+ZHtojOx8YjtGeiNmFJxVNoUlcuTVK6SDWWF7edBFcdP11gIedRzFlsJcn+ewZXYlsyR+/GIueYmOXLgCHpdtOrMvc8IUbZHv3I9/RvXV0ki7MkL1UK48YSM7VNjWGHm6UW29+eady1tSTauSiyU2mPxQB6kttvlyRPcRMqVZQWkNtEPt4VoiuFGnaHtKsQuzORhE3qW0KqC8+++YgV8whoPLCHEnGaNYcbuIpT4kiTkhjZVqD0uas7P9ssTwtKp0rkgpip7pc+wYfM5xNpa42bjdnI8LH1KVlNDKpCbsP0m11J/L7LM686kyI9CO9oIq26PktwMfxAIwGILPZrfjf9/kiz8DiXqcGTO/MTEvV81/ttRQvRs2IpziD29yySqXRvC/kqJdYe/8/ei1/NwTC7WYaam9CxQI27bZlKoqcUcKqLGPWZlO+EAW2hKAVIRNXPXHef4ec1c6lCUEGZ5yuJ86wH23eP2c+zv9jNhNS+Qk6DBRHA7CZXYpeOJYtTsTUh//hjnftWwIPkwfdezSFGE/Md3+c5NF9yJgzfjERsn9GoUP+GwQDCVnsKiOc62b00hUnb9MZP09YKQOlxwn2JuExGMvsZ3bpTQK0n3kx9iuYRMffQK8Z78FxQrP0cnQl3Kpltdp5+wyoqezAy9UHfOGR+dygNY8S4Uj2F8K+fYlOJEKMGo4n2odjd2PAk9DQWJVJl3NZxPSPPCAR5A68oRIp3YmG2JnZedVbGyFVcwrUoiguayUlSGUcqfo0AGtkemteS4lTo0lKGXutbvchJfS3uSm/FzDm7eKmFYE0XEooHYSOYJro8Sg1Jqomrjuyyqlp8snojfFD6HoG4kkaZNTD0UN2HTfu8NDyBlN65ktDMm4zpUkLkiKttaJ0eF/8egejy4i5T3QOzxYyapB2K5UStjsb/FGN1NseaUZLQa1by/wzmhcOEBEaylZziZ1qkEUShlFqi0E2ZP4AGfqgirZ+U7kfBHTuLUzsf9Sl07rP2lp1ibykvoaZgfYpeEx4YS1VOTea0EryNY6HN0LUM+zTDBbejYwUl8VLyJD3/wXs4OYqvh6RueS9Hb2M7xakhPmOzVhf+FkLiutVr8nvheX3r9zxQrn4qesEo2CuXlLL6yzC5Xh5WNixgjVES1/f1JVqo1hwxl27xLjcK9fkqYtlBpwlJ3BCKyoi839FtiBKmU4F2cexaPmFIAfPmeL+uTt85NaMFoipzMX9APsd7BrLAVOVSNs45rzD6xIkcqoa5AkbXXFwndnSuxiEVPd8KyN+NZKSgovEIQN75NYiKm8gSuTUUYDKhIxOKsOORSJhZeESJRSWIdfEo5sbtQe4yeWA+xrWJtKg6Lkj2PPspn/fF3coJc0/KeHBjM9W+31o4LROyjIAufus/kwOZXGGPMDTE5lCEJ+TVhInmxtTmMMWarRSI0xpia7en3cHKd0/9kniBpKp+Ms+s3I2ZSMxF+FUnWfbT4/3Kk4h6mEBZlS/632F+Ueuh4KxFWyGzq6jT4UoqVn8TfPBsrisot3L/VmGYOwc0bsoMTdpsEqnnE0pj5VZgFVmzMSZTzO+ni+epXJoLeLccjdmYjx2MzCi0lNdkRt5OeO64VOR764RDRvn9y/StIxNXzsfgddQAry3C14J69IjGncXFurFuFZHDsDW6uMaIauS4mGy7OdfIJ1l0ktKh6m/t/YdV14QF7e03HURc/T0FuEM+LccHlS8N7VywDN+rGAsWwFTuHTeJ0Ro3cvL/H63kgpr7/UkHwbL2QG7BCHbosZDa+NyuzZ0U27NdFVNkWAdOrFV9oRWbcEiDcSYU639nx1REr0JcjySXFPTlwOx6xylnZWsjblqOQ5qFz41NJX+bs5ByU6sUeaxIXIlEh/XgvlwoNF/fs/Lx5MnMd+hZhP/1XkZTYxFo1/aK0DnIWYKvxRCCrODUyWaXTbMTa9WKl2KA+EZZcgusVtYJ99xKdnCTHWo2ZkM5pyvfh+xZs0aZ3IdR+R7Qu4n7jd90jiKq18op2lmjTlQig/sWBG9xzh1R0tuRS15uB37kmnGMV/yFWFJ9ThYZLb5FsFBfJvJhSNl0FOqk0ICZHezh+Vg6mJiljhVvMQOzZNrq4qmua4Gtt2ycUO9/yTKu/iGh1qsJcw196/SsGXPZUgzHGNCnHmBKWqjaGUr0rhGeB6m2fOsqYamcopUh1zTwa6/hZwcp/CGLlEvHiXy9HyKzFRM4x7wrg5hJ2hlWLEtwZcp2CPtvEuJ09+XboLpOeCKFEN9CbG4tqU/iM5yZ/bhKFoPbf5AY0uyMP25JCo37IHKIiZ+5y0zjp5tzkj67iy1vGnwdrOqEnsUEQJhWJbqrgcKjJDqVEWaU7vS0yFyHJ716c892pkI0IXrX+TCJKj+DBoipMDzfeyx2RbNNFB1OJM/hILGKpBErYcDb77h1qOac9cou+ruKNKA5HipIk1u1YxUosfyW+c4kFo75VKe5hSrFx0HQ+60WjnVWsann8JBQhQ0SLo6v4HJlc2ZIq2Ye8scpVeAArnkSzAXwnajXlXqJEzvL3dhKho2aTh5JCtCgVwvBEEIHH7iUn5PBa6k70Et4hsxsSEc2TgWtsYBDXTtBAZ/vCZykrff/BlCQPnkzicpqGTFzV1UecGwolUvbgaYWza3QM901jiKb9k+urtDPKTXF+sJvXCI9mFAeBQiwCu7JPevQmsyw12fHmJV9M1Xs7OZXEJwVNDdnhFFKa1YCbua0lYYw24FFJz2/ib34S/cmrhzmdcWMtF7nydujclvdzZFXnhjvjEMdAQ7aRuPjquTIpY+tGeT0oHkqWVNz4fERb6eJZjgceGMukRPmYbLR8FlzE56gt2gVXRP878hfCwyGLmfQqUpZSytwuOAF1Z/JgVe6slQo5P3Oo6IlXLs3DpoTQRKgjet3qXh6PJQEtbRJ+1/pi/DqF0DXJI8TG5jZ0vmO9hXVx9bz8d53GkxhdtgLX5vJWTPD3CP5LnhREZ7w7cLLj+U7C1+dECzXymjNhnj1CENyEE6kayVQuqUVFuygoim2KuoWYbA4Qgl4vzrKKtVsyxhhzXbiz+lliY92ElozSOji/ngl+auFztPIM94NzQv9DJQw5epC4fy24HmKn78YjFn7FuU5aCYE31c4YO4OjlkXSEl3tuozPoWRh/o2nwn4gegUTfMWTUMnGlypW/s9kr9Xo5ucKQQ1fQvGWYsX5e2G+hGqUBrzaIPcKkSNbA2FaKA/zFnWZWPQq446YSjY8M/GBKhVDhbBUq86/uyOSL77iZ+TM5OL4WSlnBg0ngjMtnBv6/E5k9romZnXSTkwiPIzlPS9c3B2xp6IaUfoMihOTKpnzkHv1K1sSicX0wzlhSX50CBUgU5TntMO1LexjKo8Je/zUGGOaePHgb5Sfh/wNa/NW0PXIMDLgF3Qisa5nCAnO9y4xiVQSzJGCWJjJhRt/nxn0e+jUgp9l9lTnuOGtiIH4nUaiNaaQiJbt2Cfes2YkYqsv8Tt0EYTG52LtrFbET28mA8csd95i6XnoLxfj0qqtkKkV9R9cMzA5CPVnkqoQobRCzluNAiu0I2cdchue73VOijwSh97VZ0zSFeKYre1KxBo1JHF5jpDpnhTFij1kK6cdBjXnmHK/HlMQW2ohD3UFMV4lKb++5r38dJvv5qMoakxkqM2YIluOrkayseJYmBREJz/s6M3f+wfXV2lnfGc5yD2+K1wRhXfGkye8ucXEmFMGcdgqBci6ApZLLvT+V7RmNbJwDiGyWX7O3xsh7Lff/s5sL39LyqGWqkmIu1wbJlbK16NINr5cKlFRfJJRe5iAbNnuXMAVGxKmbF6Ym2gnYd2+WUD89XvzRVLqiX6VudmuPsS+6AfBRm9Xlp+vqNiYXa1Ns9JkHmavxSanxl57R3IDUmZj+26xsh0uRI6aFOKzVptmfFuunRYFnZ9PTWekycD3Jn0yQpyvhE331RU0iCoXSA7PnmHUBFFcB8XPUGJrEbO7OH7OXp+baPIcFGUqLu5vu2FdEJsvvC6UdftwIXteMCNRnOaFWCnaCYMxxnTsZZGXXUjmVahDkUFUTjX3mcy36uSN2K+f+N5EXeZn6yc0Fr4Vap/KT+TSBqITqRvPd/w8exg5R72nRSHWqB45IUpNM3QZ28Dh88jX2LOUh2MNYfJVsQUToSLN+Sx+sAgVrp7kkj07RrSqkVAwvSgkxJUolbpUmyJXev5/JzdwOqNEwzGf9Tf+yfVVkgjlnmlfysVTXQolyCcO0UVijM5nNDc5pWKpRKR2CO7AXuswCJxPqF05dj6OJHwVeZmHrddYmqF4CSvogaKyOXCHfILECYRDnxjf7DTUSQas3zsEv7OuACubZQdI8lnflfoEabPwAO4oEKb7QnlvvIAgl8awLxx+honqiVSEVpP94LwnLoKUtku0FU7c5WbrKzwhaubm2nzwmhWrkv1WFucngrl5VRi2FbEB5Z1rIn0mfg5FPlXaFAfHcpPvL1QntwxkBdRsAVGB9lVYPd+8yLWzWyBWx2867/uiKUQ/lhxmIlBmGLkpR8dy1Dh3bTLRkyWiA2bkBn6vHlM5PTAgggqo+/twPZ0f7BRl6iiQDjVWnVi0i9Q1cwmnlR6Jij2DWP9qUkIRSxV8r8avzZ/O75FVyMorh01FGNw9nBpBPrn5HNySEiWpMpQidY+WU7FVqW6Or8t9qPUsi08g2k+FBnMdXpjAdfjHX3w2yqhL6VrMF2P7ikSpzLb+jeurJBGeJZwQ7IiqlMIdbs3rG2PM6d18UU0TD4SUs+Xu/awUlPBTG6F2+ekTyZA7xIicj6WoZxtyGWNM6qR8iTquJcHRLQUX6k9COyBXGv5eMtHHXxPDpGSSMMNxFfPeLYKci0slPQdvMjEME9XeQdEGevOSUGWF7ExKRLFjNl4ipLtl6znEfJvxs7gkYhKVO7Xzfg6tzKpetSR2LO2L2Bwxkjt4LWHJwIZ8DupqvowVStVCrFC3BXITOn3PyU8pJTb4uvnYLlFEuEQ/8L79ICzOV13kmlMJWLnRJNaqyZllm1lRP03gXOuTBTs/tCOffbkBRL/k2Gd5FgvtinJypN/Pfoh1WE010cxiOiNFIzL7T85xElCDjxJxWzp6DmImA9HFoOAAxAqkYrFQcwCVKDPnZYL3TUp+/x4lmfS2F+1cZXLWvLXzWbeaTvRPOWcq75DQ8zzMgwN5n1KVZquxtBfPoYKDSMBUQl3pWhMR/PTcWcyMHc5kRhmhdd/IhFG1X+T1AxMwpYC5qJkHYsn8+Gx+ecRC60uv/xknYkAj9uZV66LmOPbndwVyVjxwJ5OS8qIqDFJ2wHMoVPVSzO3a1f7Gs0w0ovZyI4wYTdLfL3F8Qarl4IHRXPR7/WsQbu0yhMJaA/vVQyz+A9stm6w57rTpuBEOqcUX8JKAM0/HEgpXI7mvBerQsgI3tNUHYxELaUdI83MNsvJ1d/pHpMvEFpKq2HcN4GGjfs9NzGy3DiXHYLqobCKFUNMmscamCZvrqy+cidr3IiMrJXrMebuRKX5yOu+bqorjhGHahN2sHj2Fxb1qXSjn0RLdnYqtDRsxYdgYwcNsyTDuEUo3Zf8NkoNXr2IVb96SuH0mjMl20dokpakJkPnW+GLkQsLv7fqR2a/Qqp1i7O+k0NO4IdrFjUUbIWduJvi/i5ZUfiHTr9o5Nfs6xZX2zGD1n1nwK9SIZ9h2ugQry+x6dTwQ6y5kyp9/4D7UuDUh/hSeTEpsAqZyZn73G/fbRMIlNvXPRB28/GgrINGEj8Kz4zPtwf+znAh7xFNxIoYvYUVhIxjGaO0Ie0rCGGOuCKZ8mRxc5JmVj4ew/f4+AW9FVkuEqH0Fd/yOIrSkEDwMxWI/L0xuvITKWhWRbEQG+yE2KJzQqq0JYYwxT6867+e+oXSxU6pwkZd5zxUpMY1AXS6eiUVslIC4763kONgKwcYuWISVklLUtH08lPupgmSrCJ+IdKLqvHqFa/3wGGpHKCXKAul4nw7vZrVb4VQsY97OCjW/GFNTMtVhQwgPJxaKjSuFY2ODvNyAVMJQ1I392UwCbv7wkRuubV+uFEHVWLUy21ooZPCr5+Z3qJiTxcxLwcNRCcO1PdQdOfuQiYqr1c4Nm8t3Lr0QvbouHJGLZyKcnakaD5HG3el/sWMIbd/tUXZjjFm7kYnw2QNM3poL74y4TU6ugGs9csS++ZFrZPv4eoht/on3ZH1vb8R8RfE1rBK5HvUnfR7EryY2bN8NRYTMXIPtsrRFhcfGZypHPt9OzknevhQgCxIkUnl9JP/rS69/xTujiJjjVmOf6tDft0eY5ghJ6sFNWZ0pZGPSMooX+Tbi5tJWiOFUGensb4WJtkLlVjzgla+DUl2smpv/9rlwAF19npyADKIVokZB83sJ7khT50Z9+B6rruDtbCF1r87nunAfE4HE4lDu7ccxr3svmVFnbk3mea16/A7rBDqR1pcQpJu78x63rET0o4BQsfsg9C/UVU5UO7VncBZb+X8oX5eICexFd13MfmdjD+dhePIBDxulEqr0H5Rx2bw1XEtdZzRArK+YHqg2lSZqG4Xuxhtxj8tndr7rRRuTYa4O4LOP+QwVxqpkqjuOojiYgv2VOd4zIUCWy5UJXdAOJ2IjxwObMhHYFsZJnw1XyYdSRM1pdYj+qmk1danReNesJFYnE0WEvZx2TCPC4tOFLYm1YkqmeAEmfYrr8Ok1OUxLT/PzvrpyDrG0Xkz6c/tvQuxZtDNhVM6hEhEoy3F8NQauRLRS15iAmJrOCB69BLG4Q5xOyt1bKKB+4fWv6EQo/YMHgqj2VmTZ6bNw0ajxUMW7UKRM5Vng0WcTYn1acTy0ieUU2nMj+991C/PlbVKY5EilkhmwklXnk/s80K/MIcz1nYCvMzekjbinDzfvmL3OA6JQOY44NSnDPl5j4ZwaEMGkr1IeJn39JrNNlbcokxJljrb5EhGQCrl4GKoxwojhNRw/h1/mwX1YjNYpiWvVE88q0AkFjydJyc9rownGGBP/K5NIZV7mbfEOIoQg2yGxlpbsoSbIOkGOtZU+jTGmqpA9V5yAdII93l4Ia/0mNFGuxDnbNEpzRbXVlCW9bVJmjDHHx9VA7EfBii8RSP2PJ9Fcw2pk1FUgkeeexjt+bteHyXLcbmoMbLzAtemZkcXXI9FC9mk3FbF+gX6I/SZkxJUAlX9Zd8TK9KU+Qfoszj0xRHBY4n5j8rXuAt/NZIn4/KfW5nROigpMtp7tGYlYGm9W9uZ3JlbKF8OttdMK3SWVC37n1VmS71WbonNZIqmJv2dC1nEe/7+WNfj964uC1LuT4Ngk5Lv5pe2Mf8U7I+Yke1uj21OJcIVgWdt+FcYYkyQZIegSJd35N0RrIUqoMVbOyhZHhaGsRk5Nc1Ze/QQRbMcWVmwjejFTHDWRL5tqSaw4zT55aSH7nFpsVFeE9O3m41S77F/bmYC9F5v5OwE11xTWze/F7/UIJ7FUJZbdBItfTTb89olLVDmA7t7N57NisLOdkSc1CWhlBzE7TyaUEpOKGftKxZlsvRFQ+P0XfDYqOUiXnBWKXxiTF1twJkwQ3LLXJGEsbXEmDKrqnNmZG3/FXOyd33lG/oufmAC5vpnEx0WLKS7UsdNkx89FmpKvMaQGC4hcqfm8WiwiCmm7hBqjvROUO+elhyQM+/ShaNLJhWzJlejqRMn82jDp6yXEweIEMlnU3QWx0XuIHDbMy4OlwdQoxF7cYmKZIDkLgU8PuTdHzOeYY0Jr5P9zRZTGVudzzd2Q7aI7kVw3Y/bxsx04yb3vxHC2c0YLBcxGonVn85+SCEJyieFMNN+/ZQuhYGEWZIr/oNoZF++TE6LGVI0wG/vGjff4/Qau139yfZV2hp005BBZkfK1UAnD9L4ktAwTfgrqUkiEdxaiGCq7zZmPD9X2yvjlFtGURMkIoy7eTrLZ2KHcDOv6hyCm2g/K+lWN4MUJ8S7Fsbj23Lnxq0RDIQJRQhxK8TWUidaG9XyGvS4yiQwPJLR48hFfmut32Hce043owQPrngxbR96IuoqLTa5WATXtwLU0Yz835Vgh6fu9EPIfJza0uLdMrJZZyosJvuP/9ergOMSO3uQabjeP/irKdXPPTX6Hb8U7p4iwiQXaoaaOzmxxti/uCpJu/U4zEFs6m9baUf29GRNeDzuEsqPi16jWjXIPtX0yjDEmerbTDErxcJQ2RRMPHmZFhvGgOiJ8Qh4LdOLa9DqIuTacj1jyVCxcWvqyLZFRoE4lajkP+T3rSFxcLjg3j18J9+c3XIe5OlGSWyU45nve4z//5n1SttyqnbHKsiCvMYS/83AlTb+2Waq5xhiz+xqRadWmSF1eeGwIPsX+VUSxVGLx93vupV96fZUkwr6UJoTiOijuhEoY9oxUc7asThUBU4lS2QiDMcb4CqVAW0jqo6i6f0rJyvbUGJLXFDxYL5S93QKtqKl+WkxKqEuJd7GGNeatdSgplKCjICApFv+EAyT0qFZDKiG/nS8tNyB1tS1G6G/6SlY3W84RsbJVLNd3JzfhzGMejpVFctREVNjvxXN9JuD2jQFCPVCQVzsKM6Dibqyy87Z32jyP7c0Ka9hUQvJ3Qjsglky0/EZX45orNZTjcRH9ObrZfS1X3TlRMChDqw3TnQewMofLVZmFhkdaF8QGbifCcOKyGOX25j6ktFlmC8fSZqLtp9Qzn75zHpAK6Ytcx3ZRrQLcq1R7oJAg2ymlRCXopLQIVLJxJjYesQdCqC1qvTN59W7OJCJm40jEPFuzHauM5br04B75LIrcgTSl6WxasD81V5b3YPHhJezBt1muqD9XIodBERyHCRsAj3QuiKkW4rRsbF1NGUfu17wYFmQmAd/rf4NY+T8b8VSKlYpsuW0oD+BuohetmNdl+nJs6sIczvKWHsTWRSmhxtjK04lOKCLkb0Jz4r1QsVR8ip8FYdQWRzJGi1wdm1yP/1ZUdgrStlUW1WEWJiYiegzjVMuaqRzfUhbX00PIno6aUA8xJf3bWQjz9NpIROGsmGKoU935ogfVZD+x8zq2X2IfMmNXomdjfXjYqlaLIkfaZlPGGDNvA5Ntxag/88SZ+ARtZAKtRtBunudhnjYr729WsXlNqsNN85rwqxmzjm2lQnmJ4mxdzjHdpdOc0GoyMTV14gHbCi8FSXPpWFbYSiBIkdzOL2DVHfuSLalkCVjtDtrC72/vifv6s52x/DTfucCZUYjFzKQg2X6h11IoNStWe9TUGC1n7ZODCG6p7FwTylraVopUglxqXLRDMa5D7x5Eda6FEXVSxUxYOAuNEKu9aYwx/kKoqYJIIuY2dE7FjN1H1HBoRSakKplRa075WjzaQtl32+DMGN0eaViUKJZ/AD1bPhznlMk/ub4KEpHBYrcrEqWv0ImIFOOHXv3pPKc4EeqKnsxKedYxvjRq7FNpTNiTEnFv2Z88/YhVbBfRd8wnZKRt4qYxWjLbrRBZ9oO38dBQ45YjxrDftdhqP5WxvDSMMaZcZm4iS4Po2Dgqgm0VNcXx8T0z4O/FIVfEjc96z21C0Mon49NHogJ18zufdcVJlIdu5s0Nw0VwTtyE2l/H1ecQU1yHt68Eh0MQyeLOU4AqXXLqjgwd7+Ti7B/B5FvN4vuF8bleuMYDaLWwLleaBR1CuFGrq01xrvUhFQIQS/C9c00og6fD4vPmyeiCWI9RPGzaFSXBM30KPtfjtwk3F89ChO2OEMO6K1pXqy2ibqbyFDNrNbAjYgvFSK6LUPosmZ4HUO8NTI7PHjyHmDJqivZikXb1PPfSxl3/v12SJ9XnSKpam7nrsv2mrKtV0aO0M1o35RqOecj1dEE4DGdoRsGw8EXW4R3P93eokL1WmhOhvZlEBokxcNmmFOTN6Jt8/of2MYn4N65/hVj5p/gvT59ilq08MVSPNXN6tgwOH2HmmSsf+9iKd/HXa/bZEqXlJlewqLPFoWD/uDj2bLMKH3t16BXLzEqhS2l3xOqLFk/X8vy9Yhn4d78RUxxvLeKfDbUaY0zjMZQQT5Ga/385gRIsbsZpjyUnYhEbsYjohBKMeviSCYhyAK0QxATB9udYKEZX710lh0G5bpYSwjqKDPZR6BjY7QdjjJk9hPwPVT0eE+ZtR2/FO36eIlCCmmLUdFA9cl2U58hBwX959IZJdJH0bLUoPsVekcyPacV1YhtTqRHP+cH0xOgqJMnbtOBYcd08LCA6zKFzamZRKa8Riq3qQFOCQ5mbWRXgc+6HCbIJl+BgHtKvhDCeFFHqvwqxo/PZznolXEFDzhARDJ/KMcJHh6YhNveY80B/9IafN6WwPVdTIsoPqOESIgdq2qGlH5MSk5TPdf8yioj9Lt7hYllcHD+n8eH/v2chW9Rbb/BdWhFJxFFJfEuvC8GJSJWX7//2QeRYLDlNuYAZdbkn/JPrXxnxVH3iiULv+4ywW95xnj1LdXiXzicMbLbywSi1S8WnGCTc3Q5vdn6vb5OzivOuzIfXpiSrndAYvpT2YW6MMUtasAIoNZD9zhVCgrnFRG6kqu2RNrkTAVondCgW7uXBqpjt7z7y2SQViIiykVaH7avfeU+83bnxbxJkpYri96ZaNufvhRLfvn189kcm0y4+lUDOiguDpASCbLlrEJ+XcjKsJljhL8XY53Sr8oqI4vP6Q0zdqD75LPFclXhTnsxMNhR3otJEJnPNhT5HamFxbtuybxKqnhXEc26xgOTQecJf5+A9rsOxw5chlqIAK+CyIsFXo9adhGR0D8uv586VWPxOrsJMXMuIxLWp0E5IIlQR1XuoBLP2r2XLs9JATpP9LWSpW7URVfY85yRO1GLC+Ssu8LmqVm7wfHKzFo2gH1Jd4XSrjK+it7CKV5Mo/n4kAg+s4ERYu21gm0YZgc2fToSpTj5+XqUnERdDZFppPbyIYcGgpjNUAvKfsAK3kQhl8Z1cbMCPhd1sAmEitSuAxBfVWqg2KQqxDjWYyWYTUsV5hfa8Paqo3DTvidG9XTvJf6hfl8nB9l3sna4Zwp5djlSs9hT/4ZM4lLM34bzzjbXOxbr9Gg9kJdw1UbDYZzVgcqjm/xXsr5QHlUOdck+89ZzoRH/Bnl9ruYyqg6u8O5PDi8/IiRgvFCCViNRtsSZ+F5Bx55nUkzg4hjoGz8V0RhU/p1WxEmA6dp9JipKfbpSPh1JuoYCZM4C92LTp+N70FO2sXkJuOXIEjb8KuDn/v7JjeIgorkf7avybs8TzenqXh9e1pWTUq9HCdB58h5sKB9BQUZDE3XUiD7NH1MPvDJ5PZO7tDRZGrXqSE/G5fIL9s2ho9rkiV8qLQ42qTq3j5B1Vns4DLrgxUajy/djKbtuKh/lEwUOy1SSNMZIw2rg/3Wl7l2U7s+Z4FmSTOjmnjpSqaWthtJelXRhin2K59z8/SHGosuP3I3b9MJHp8OD2iM2KjkXsdAzbPi9CyBv8J9dXSSLSdXRmX0pEKktOtgteCNnnsZ0IGZYUlsaHhd1uKTf+npKgvin6rM3EohnawQmHKrGlerMJhV49wRf/8fruiD0VmghjxIhfO+HsOSNaiAa1Yw9QESSXRTuhZSVJ/fEFEaGg4YRWbVjdGGP2HuCo2oGx7Dv6jKdRk5KMtufOjTGmzAiOue0ewqpo42VngrRsFxOhSQJWr5SLSFfqihyjOrqKI1i+i3kY3NzKA9hkIXztU5sV8I71VIBcOt55kOwRI2NdRUW8VMDU914wmV8gjPBiRXK0WqgMjhIHa0Oh2XDvXjxiaSx+lUIhKwjDrMMXmQgPEMTVNInIf5hzLBYxJfqlkt7jK0g2/sad6+n2MicBeZcw/PMU+9w00ev3EfwtJZmtBJ3ypmHSpzghauyzXzcSfHuJAzh7R2cbZZ0wkFOjoZG/8J5ce8p2cfhMHsqL5nCKZ+4+7pFVPYjs+AhzQO8O5DaYP5xJg1tJJjiNKhJNCh5JfkUqT6J/V6YQYUlTk4mFGgVdI8y2FAGzpTBpnPyZ03//p+tfcfFUSISaxFBGWMqm++V7biRj5nFj7Siy1lWRRAWUuM6BcXyAJx45N+bczbiwLodx8fZzI2RUcTLVFJWvRRdvd8SuxjHpUYIza89R72HebsLSzX92Pq+2YrxVESvvvuIhckhoB8wV44y9NvA5qGRTaScM2EoSqTINmygY2vY0xr4r7E8qBcQSgq9zZ8dIxBTqMlk46nUVh9KTOzzQFRKTJC03Ppv06yo4N4rrskdwExKJ/rRqtc0WHgtKxyCpQMn6VObmaktBG2PMu3fOvxveje904QbsRSslxpHrmMxvCeDmvXXWcsQyVyYidP8mn9f9g1SFVGTLrK0WO35WkLxKGLoJWXVFSFbjkdvmkVhaoO0ixPYH0/9ij7A9V739zE0It9vtgfpd+DvKT2JDb+4bj97wnrsW5ZpQ7Qw1RukzgchWkFCnVIhFcD3nAZzBm5MTK4SwVNyRyYgp626VMEQtZPGZPyMTwZdClMzWtTDGGJ82nMSYXOvLpjP+r454+pZjpTR8CftYAc0526ySiEpVOMWQTcjyqsSiakVmY7MbOv+/JTHcgPf/QhKZ0qZQSYo6WCvkZ1acLw0nFhR5VXEM5gqZ4wsHnAtYJUKrL5AnofQaeoi+4CjRJ28jNBZK5ucBlEq0GxQb/4WoijsKSNvuFStpbJ9qwiVTsPNzZWWLZ9uWc4hdWcgplh9Fm27DRW6QysXTQxB1mxVwJhbq4L4Tx3uUUwiBVRrHjTWxQPDexLMqVATEx2LE9+pkti7WCy6OLd7lN4X8ilUDWYmlEJb3Xq3YkjCpeSir6YQbywkPxwg+xc9i0iuzNycvzm936hikFPd3sNC1UE6kI4X4XNBBvuddPdnieCZaY98KXkciYQWvTK7uXWDrxr+n81krSe5Nm88h9ukp91clBa6ssNUxlqbKSMTOrOXBrzR8Kjbm37XHMo+Gsw2kOGIKEeqxgMicnBJpTOlqr5pE6y+e517y6ibXk3nHNu1/YsTza17NanFDP3qTG3pgV2atPjl4AFcbQ8EdJZldJBOTDTdfJ6P+4tzm+J2GBZgBtxGLUpE5lbJj0JRNiBWqwKz9oJgzjxKH7R1h8pS3nBMyL96HJKr5fb0RUwnDBKG7cPwBN1vXlJymSJuMCUPINrZCFHI0oAUh44jThLRTWTLSatQ0Z1rhOilG0PKkIUpw+TpbTZce80UtmpGJgE0iNMaYfgNYKebo0xKxyQedqIvipnj2YY85c3YmbsEdCIUqdKa9cN09cIvjtz8L4mO0qGIV3NzSYtlvGkpidHKhOFvSn/16Za1dOjPf847Duf5zVqZVs0Id7sdxPeWqRaGmB6+cv6cO1m37iMzUrMSE4elr/ts+wtfi/ON4xFoGbkIsajqT3oKZWe3GPSXqaH5lbK0lwX12PFuU4SuFxPNOHtyuVam62LhjXcQGlCcfKnMZ8pUUn6aJKCyeiVHNB9aUWEnxfn26xmJJ+XCsC+D+3UyMSzdvTUL26hmUWleJsNKd8B/O5PhLr6+CRCRp7GQ3K0RA+WkoeezgRjwchu9iRjXeh4eX7bppjD6AlGLl3ls8bN2TOw8SJVN9SahOKu2I++LFn7eFB2ahvEyEPtefI+IEK7sVYt6/kyXe1cSTPeZlBwit3rjC/79hHQ/EptWlJoiquufsJGJTpxSrp8uPWNmqnvUIgYCcsYyPRi9mBaBsxQcKKdynYoxOyV53n8eKrWtDvhMtPZiA5G3LSYGjs3gY5rVULFOUH4rfSedJ8zXl/zGhKbkZyrr+/hsiEQXSsXWnbMQ7C1heHdS27HW9YJJPFwjuj60maIwx98X49eyGTLYCd/Hw3iE4R0uFdPcw4aezsQt/L9CStD5yjgTPwMbsV7sLjZxkov2kWnlKdVPJbdcW93hHb7Z9VMK0+hIT96WrnQep2oOl/LJISFLk80Ds/BQmaSMFl2xsNSZgyhpBjcGnLkV01p6U6BLOoqpqbh7cHfvxnZaTE2+FFLYw74rexj3MvzsTNeXsmao494T7s5mU/ZPrqyARyVycG5qSuH64gn23kbv54NWlEob2K5i1KZ2IK+fJE1Ajk8eDuDDt/GrKCD5QlTDE/0Yk4ux9HoTKnXRBEyZRp0vxkMuWipuLb1EewKoqXu7rRCI2XOKGpoSFlJ3307f8rorXsn8Ds30lonVBTBQkFBMFCuKvOYKStk9XOAltAwcuxu/cSMwD82FpQWYVSZ86gH9yIYpxTnyvNkX5vYb5czpHXTYEmyQnD8ftwjviuuDX3BZtikIZXBDrt4nv9ULRaqyTm4lww/kcwWzen5oFMRYP6XfxLvkM5BidGo9sLrRUlJ9EWXdW3amSMCFVRlJLOhAlbCC+69nDzmSjXFXet3Yd2H7ZsYqQeayYHEou2iMKnVFjmmHjua8p1dU0gsP1ToxMP1rufOcEzcm41pmBWAI3tiMvTOW+fEPI+28WKI5vIaLEkjApRKOUQBTUOX/ne3O/JQtUlTCkK8R9/sKEz7N3yLCCyJm6vHz5WRTn6kuvr5JEJE3uPNAyZiF7uNYczuf2EmSr0094KFfKxk3pO8HYV+TND6/5wk0ZyIcVIebR23s6q6eGYjojX/dwxPaMYW/LRjWMMabVZPZ7ews1uos3yLu4vpWJ0Llt1I+PEETCbsmcC+nyYzGmKkhOvwsxmJYh5LCcOsoXemC/eoilTMzlp+bd1eFtDBOw6In8G0VtV70kLvgdNRHyQUiXP69AyFRxU6a15AFx+gnXoSiKTFXRYx8gZJTzWyqj7+KZpPw8hPLuMUI3RKmOBs5ldarExh4LhC2DUPZUfiKJRVVs9/szieq/ZnsKHGVx4z2//5polZKk33iO+8aOjZy6qtWYo+YT9rMQ2t+H7856Sydj0BImJGqqQ1XO6lLiTfOExPP4cD5rr+xcc1MEEtM0P4u06XWJnthJg6rYW7XlZ1OmZ5kak5RpRCK0fxGRA6XYmSIXP+/sbkxmlRS2bS2uxkpnNWJRUSKEol+z2rOtoGzKH+2n2JpKDoKnMrFOkJqFkDIqW9GCn/mfXF8lidg1wNvxs6rOe4kkoq1Qk1QTFu7JlZ4Ekwh7SsQYYx49Y0JTLhNjKuN7aSnDKQSjdDlmz1UCWRGnTMsNWI2z2qZfxhiTIw0TkM3fEYLaK/rTIQsohpQlhXMRDhcjecpPQvEfIrsQnZhTiG2qYgL2Dj3LxG2i+Bt9bhHFWC0g4+rjODLa1lJynCJEfrxH8981FvdEuTg2Fep585t6IPb+D1Zs/qKyb1WM1VNtD97PRgWcCa2yH9+8k8lH3Zmc2VdoilsytgxUMuMqKuBnb0gks0c3jTGmlUB77GmXHOLffSP8LwZX5POq2Ias+LN1ybFQh77Pr/wOF64yIf8oiHQRonW39ZLz37oK6/KJ7clN6bSMSfqdXXynU5Vm5VxH8CmU26dqaAfPoWJt/ZnU0+gdyTVRLpvzXe8pLM7VhEG61jSWUh4TNnHTGGMqtmViaZJyz32+KQCx/mL6S41bnr4b7/i5cQDRdWWipVCNxj059ml+ZzF3VoxBf+716TaJ+7KN8oXXv6IToQ7zz3XxnCPm0xXXoUVdbnythe214lM0KcaMuncwN1ebO2FbgxujZarDzrCFUj0nDwIljjWmJb9X6cxMen4Xxl8evmTy+jTlAm5mff+3YiN0E3PnE3arkTxWe5uEU2adWaxsb/3C+3ltPkfLNguUKENSbi6nHrEat9stgZW45k7eZy/y8F0iBwPK8/A6+4AJc99V5xCrJ4hvaurkqRBgyy/aXgeinM+id2seQDWEE2n9aUzIVM96jdD2VwlDEjEVEi3MoJYfI5/mmRiFvL7XKa4THcpqzz+cCa5KBM6LZ9hsNtfhk2hqjphMrFiVU+rtl8KmPZTtjHvLnQfOpYdcqz59SJjbNpWk2tUXyEOwVSKNMcYk47oJG1MPsVxCzG6s4Bi4p2YLde4K8n/sdsYj4fQ5eg///w1hFFYqJDw8DvTjs5YqjufZVlUtCJUMzGnAVqttpLU/nKTPkwJJHziC1uWZi1MP5vgIri9FtnQTJPWdB3g/X50ndyJmfSBiBTMyUf8n11dBIux5f0WiVGRLpSehXAHVNIUa02xbhO2G0dWoC66QgpNTKXNsX0WFh4dKGBSasE+YSD28wMSq9GCycftsYrbfSfAk7KkLY4yJE/e4zUjn93fLQS7F80dsobQVhjZK5GetGA9d3YmIhRLWUlwM5dnQpDCr2OAokkEP73aSSF+85f14ISB5ZUA18wj//2WCWHd8HDUGlFDTboHEPHvEhGZCcyaW1fM5D4ipm8Q4l7hmd+T32niJa/PZe94Tm6RqjJagzp+KqNPh1fMQu7aFqojvOjvXiY/wQ/llKtuFfmF0+lUTKyNFkl6sHxOm5oLXkFaQUmvn4bSLnweLmUqWToxqRy5dzIRJETdjb/HdbNeLQnBK9EtZVbccwpZsulxMmJMJRCF9FiaqMXeca7jeSCIndqJhjDELBSIWc5uHsprYMD/yIFTmYEqWuqsn99IrwqjLRkUKCDRFjYaq6Qy31tQmUQlD9AZOsfj35feqW5XnXIhIImpM5P/3nyRWfgkS0UNIAaskQlVP6lI24mo6o6rYrFys3u5acRDGC6+Ht78z8/YfTpJTZLAfYg1E20eJUqVOwth+MfbZTlTFCRM7UYb4F2IksSQ3kYk1uVBfCIi/tzCXURLE80U7J7svGcXBQ3goK1LuQ4FEzB7mhD4nbSB0WVHM07cW5FBVOe8Tpjl/iEF2VcVXLcLDpmRt3uPzT7mh2SiD0nBYvJVckvG+HoiVz+GC2GMB5yunyM6rziD2VmgRDBzhh5gaVcxhjdv2ERMLp+7wYPlecKQyVycpUelE3FtJp1slZ/6TGC1VSa/SgChnJRbXWcdITYh+1ZgItBxyDrGqOci6v/CA7/WCUB4sJxfy+wcfiUUsT1pWwC3FpIxtN65g9VF7iGrOnrMdMcV/uLaByVaejlSxVMnB/Mb0CcnRgyjOteB6iMVsHOn4OV8/co78x9EnRHliKCMwt5S8l0qdUk1dKE8MJaOt/D6+9PpXvDNWtCYEZWsuGMPkwxhjihXng1fiTd8nECp7D4iAXF1Nwo2q7FW//7ePTkRBSW0nEHPHV54yiehVxh2xJsI0SEn1XnnGw0uZ1dQTugNFA5h5V63q3JiHV2bv1LMHyUAKsfASktxVxJjT0iNEbFqVInK04zKrrBRJmTAdFG50qQXcah9oW3uRHFcogGxnpU+gKnGFOrUuwvukNrm+HTlGp5wMNx+KRSxhQuehubQdpwSaiIT8b3FQqYQ8p5iwWCkMrdSYZqFGTNLH1OPYbyZBNh5n2SFvmMfk+/4uHgTRt9hCUZoIalx27gnuG13EAfT8HZMj5YkyfD33F1t5U3n/hApUr6EY+Vb8mpKCzK6ktZUmhvLxyJ6clX2p7Hyv07Tivv7ptXOfHNGfExZ+Yp9vJMSsdvbk+5r6Z6451ZI4cJTIoRJ0uv6YiYp3I45M2yOet8W+XHU0W2O+dYnCy0QgEe+5V2MWKQqdMB+ZkNtEUGOMqSb2hKMD2B76J9dXQSIeWczr4oG8kSphUDoRyhVvTBdm2aMEoU25bHZfzyw4zJew/3yhn2/rLijnUEUaCjvG6qyfgLNVFaMShogj9L+4f5uM8mFPyTEwiZmhemRywnDKAdFGK4wx5tgIMqrVdIIt8WuMMQ2b8BnefMGFHzkzBLFybSnytb0vF/7rd0SF6k13KpuqhOHIRG5yw3ayPRBcj5uB8vDYK9oDIYGcANl4ns+wh0g21eVveRYM30XU4UkMUa3zG7k5Fm7H5zWuHd8RZXsdtpTeIarHruSGVUIT6u98rr7FAvA7XsKUKKAOk28lLf1RJGkJhZroz32ZfI/p5Y2Yi5iKSCJUV20599cCwVSFQfqfyP05J5JZWwjJGGMyCF5TioxM+k/d5yH67iOTozpihHrfBELhtgLmg7dEybLWpMV1zGoiDLLGFVV3+AwmM5krcL/yFwVk+GSSHJV7ps2xqdh5Ln7n0RYqYmaoSJdMNWHR08sdMe+cTCJ/E+fXe/G8+mwm+nv2gOCJ/BeSiAwWg/rBXVbsCmF4LWDP48eZPapWyIU5JOC5ik0ufV2ydtsJSdeHYgTtk8UUP3ub36vEeiYMA9oSplcbRGpB8DwgDK2un2cfM39xwpzjhQNo7Gu+wHb1nE5IgxcWleg9Id7TT7Qu7BaCMcbsvEKEYagQdJoyhtm4alPk60SkRMlNr+zmTF6q9F2D31HKjlfnNkXsuiA97hpM4uqum0wOfkrAg0UZlZ26yOpRWXr7ejhRnJOX+e/qdmLv9JIYNe3cidVOBTFW/fYDK+DfRevmzz+58W8UCqhejciJ+OE75+/lSc+1OVtsotH3yCV591GQj4WfgrrUeGTNPHxfMzXlQRIexLXjNcI57aDEx+KEgJq6rghTKqUS2n0tW7mHx7I1mOYnIn37rnMNN6rHMVo1ZWFrQBydzxFKJSL1g5i4s5EpY4xJkJaFW9bcRDWv7yAh3xg+V6VO6Vqd4/LmpZPDpPw11JWu9Ocd0mpiI1V+8kQmtOX67xjAfxsVQvn10GncJ770+ipJhE2QPDKOh4ga+wyNYeWcWczJj29IsqGabHAVUsXJs9BlbkQVwveqVWEftodu8HcUv2KmMCqKuRPP3xPELyVUtSGlC2ILWnEhleu0ADFFOMpVxPn9g5pwoTYcyapjcTPOsa8TMPqcY0wE1aXMq86EM2ufKUyj3oupkApjWe1WsJwslcjPNIEwKB+SW6+ZRBx5wMMrTMg577XGoI0xJqQf17VCdtpOYuVto0c3L/KeKy+Rlt1mI3ZyHefTywzjBqz4H+pAm7WHSW/ninwPS/nysP3wh3NN3H3O/1+5uuZOzXf/cCyTz7L92f/eO45IlFLnVAnD0bm01q4ygkRCV2vEe+wAVrp567Kq3y54CK0FgTxKELczi+JA8VDKj6I1QPlS7oglEhouI4Tap30pl1B1FW7EHr75nsm3kr1W2iTXN/O7nhrFJMIe3TTGmOfb+U7Y+hc+s4n0Kdvvu0s5YaNIlOYD95cXMZwarD6R5+u1SCKMuRtTpv0bty9z7FTXV+FE5Ojn3HBsQqIxGp1Q7YyUAr57KirguUIpz2c0Z5uVFkOkgJFVi8OWar74mJ8jnfB/UOZgZ2Zxw1QeEx5pXBCzIXljjClbjLDk/edchDEHCd8lSuZMLLy9ubBiH7JiHVGffe2bL8Vmm5zPsM0AvlzK+KviWGo2VBQto/dCKe/nHJwLH7HI2WdVEtefO1a5ezfv5fz+RCKSCb5OFhfyNf4QFXvGlISglalPOuseK5Ro+uFYxJIKRKxSVva6PSwxK2OMKT+OyUxgExIfO/biJMalCLLWC3QIQcw2vvIRI6kL25CAtus2ORGTFnADntibiVu9fCS4Pn7FA+jhr2Kt/8RD/q1Ym71Xn3P8bBMtjdHTFM3FYXN4B1u55gkTt8hQ3vPwi9z71HhoER+StCfVZ9Gj9HX23XHuawMrMJlVBL/5jfn/K+0Im3NhjNaOCJ7AkVnXguTrfSMEvXYP4bhlJSvZujydyYwSB7NHQ40xUv/iZMRIxBRJN3t1jmmqFs+wIU0Qi77Ge7erG8/If3J9FSTClm+2ORL/p2trd/bJlWRyXx++XMcfsgLM6M6NX6ldHhcVyqUHjBVP5zyUMiXjBp8rDbP9Ua8J3fsK0RgfISy09BA5HEUKcIws9gk/r3s6QovfVmCVHdbGSZDzEhV8FXFwH7gdj1jqpFxCXaZGIaYShloiOVIvdO9yrGJTiJdr+zUS0z68c/aKFYv/xZN4xAZ05Iu1shU3IHV4VxU9e2VzfPc1+S+qJdd/C3ubo6s6Ez8lZ60Shp0nyK+ZvZgHdcQ4jjx3qsH3MGNSHqLK+EpNNvTrxo3aJmrOnkdINvatsNpOyU25Th0WGoOmcwrr52mUfX4nyKbv/yBypqpzpWOxz5qcytSCRmu5U/M7jBWS/4uFAFe7oiQWRl4nOlE3H5HedendEYsTPhlVOhHFOreaz2fKLGdRefelN35nrvAwUVoPSmFRiUiFbuU7MmIUxbEUoTOrz0jEitbcg5g9qukdFIXfuXON6LoSm7o5m++Xa1kSRpV3xudevcpycm76SoGA/BeSCPv6UQjQKE5ExcncvBIIktMkMarWqAz/PzUKOUtA4cogSo1CdrH+hjIl6mhVGP+nS0n8zhebzbahhIwnRvFFeiL04/cGkO2/Wfhi5LQmBVJn4MbyVigg9hcGV0rFUxFhFeAVISYltl5jz071SuPfs53RoABh3gCrUnIVa6RWVW7U6wTHILXoHdeexmpXja4eEaiT0lhQtsxV8pB5X7SLk0h2LYRjeurQ2ybQj1shfohVm8p38+b+KMSOriKxUk0UDNlBoqpK6BLlc967VImYVDUL5JpTY5r5XJlU50nPA/jC83jEhi5lMWPr4RhjTOQIVsBn15Jj84tVxSdJyYMwpUi0lNdDv4Hkgz1+x0O/bi4+ByUt/fG10GLwYBExdRY5AEqh8VF4d8fPw0TLo+AgjnO+uMU2YNx+TuKoZOPkeHI9lgi9ogFCnTJFAaLQEQM4WmlrbBwWmj4KdRizgITR+kJWO0E2tpWfCJRUOnaK6Qwlo60Qiy+9vkoSYY90Kp+Mp2LGPmM6VvHTRX9aJQLZBOx77QorUZ/CrOIV2uHvxWrX9rZQSMcbIfHr6cND9M5tIiev77KPnVa0AhRR7fFdHnIZ2pJsqLxD7oV1dPz89jdWXfVn0zsgcR0mXyv6CnEsIfwz5QNbAY2EeuSpWzxsS2bghnslTnhFfMPnU7O2h+NndXAp2e/ifTch9qMwArt3jWtz9DauzfVCY8RzCDfSvPm4XhVn49XGro6f774gIqIutZZUwlDOgwnZhKbcIJW1QxLRzulUgmOvxwSaONka6fOdwIrQPOc9z+JHdv4vi9iL3nGaSfWE+ry/daswYVbtBsWTOLl5HGK2iZxSGD0oSNXmDVHNennYBo66y99TSWR2wyTq+UaihKmrU9Dpo9Cs6BVBYvXq5c6W5PwxJPhOnsRD/9ojonUwvTKalDn/eCxiS8R0wqDm5HWFxxA5zOdWD7Hph51JjuJSKJ0IlQirS3En1GSHSjbqCTdlNbHyb1xfJYnwXemcUEguqr00KQh73nssnA2FO+fp3ZwfvlyHVbdtBGaMMesOc8O5dpGxX9+z8v7WOnCyZ3bB7xTLzMxOWXL3b8KNatQSbvytxfc/fyoWsWVCx6CYOGyjYtkrthnPNXKx0u1Tm+TTfuKlHC3QiaNCnz99c85FD/Tmd9jjxk1OuXOuHcqRyRRCUXCY5amglAhDhDfJ1Vnc+I7GcqNOl5WHbUgbHhCKqJlEtMdyCFXUu/FMwKcfdiagFXPy2ZdwI9ehSD5Wp5Eb+H49FkTjDsW48bdaxH+rEItb23gYVEhAJOaYhdjkFxXxmtns9SrCoLK4rlqCXCJ1VcrmgthvQmq+XQcS9Tx7/X+7Z76K5GGjRLT8RUKixmX/FCTlV6eYHA6bxIShcBbuYQrtqKrUOUWS17i18/0/fJuFTJduVHFMW9obMa/mRHqiwzlWnTIxW1fK/0K1rdV18ynfuRLuzvvUKpjt2A2iqPL2I8HRfGLx+UQUCwo56ObLgqR6dhZQwVFBiGVoKFxMv/D6V6YzFDnSM6sLYoq817w0Kxbl2PlGjIfmzsnD8PQp9oDVFbOD6Mml0B6On0sPokLZCyG/HCf65P9Pe98dl2P7v/9+7K1EEaWI7C0ryZYRmWVm771HVlaZ2WQmQpKVsiuErLIjJIqkYVPG74/npd9zXceBcHs+vp/Pfb5ez+v1dLq7uu/7us7zfL+P9/E+DqfVeP1i5tgy5lADDyUmtmRFuljiiM1xfVM8NHJnUWaA5QoRiAtBHerYx5w9O6xH/kfYaqyTV5uMRFgmaVxyDhKYGkzaC3MpbxDSfeiphLl3DEKUaOZRhFv33cSMlWUUQ9pgKaQNObwY2XjPcCzn7L6JX/zoLWEwZ1NbebiOIN4kQzojTDuvJb7fffsQORpoj7/bnvjLMC0K37UjYG4a8V2pV1wH5pb5KV/HEBEm1MSQqQltUP3TTAeDVDvipssMsm5fxs8wpB/WuxkCYt5YCWkfvYUEx5LkbzINj6c+Q2COtUI2If4nnmH4XLNsP39FvP8LXLA9+shafC9VTHQUPzNRJs+NJPgma5NpU7R2xD2iekEMolmnU3kj3OtcliGvY90lTARnNVUmVoevY4LGyLfyChG3dqP7wlyVNgR1qYzfiR1pSLDugm6fHYbhcygpuEf+6vjXDLiY/gOTsw48irD3J0JUZMZSgYHInWC23IxBm5vUIy3G7lH8XN8as3P3TgiPhUbhQ9PBGQ/M0EXtYG4VIb6VMcCMNfENliAY6nKQ8CTUIleZSZD2hGR2JQriBtxqNWaiLJseUxfLRVkJ/2UdqWMyjQ1WWhjjgm2JBqbKoDQT+ZtZCDlua390CR3qHQZz8aQFMTchRzIlUkfyTBgY4wbRtSk+d2VUrX9+ROmzdCFE5orkxYC0nikGpKV7IxQauBA7jNotxAOYmXe9Ih0mzNDNooQyo6plhM9SfSLAs+USrhv3Q3iwMvdXJnBXpRXCyKwltYwxHl42JRAB6tBfmQEy35BIQkhnHBl2sKa+TIY5pkSZlaz143cQAfFaswfmug5EMuDc5hioqX1CShfD70MtliYikomo/1p1QlEq0cMAhHVneBANm9tL8TM0XISIQmxMMsxFLFa2AjdajEF1bpLwBbsTd1Iiex2+C/lFs47hM8zMwY7fQRKtfd/F+HcJsvH2GD7rPzL+oy6ewfPxEO3viXyF9URulzl75smHkTxDJ5a1xZoS+xruJigXtf0chO5WExGdpUex3aq7JRJBmbFUAaJ2d4coO0YTBUz/HVjbmzIeF82jZOXfDTiFAR5rId1/EDtHhhFozS8UJa4TCToT9wCzouWTsEwxZMYemDOtiJtXADFSqjJK2b62kHgiVCFZDEMnmE03a3GtbIALVZegGLcSMXsur4+/y9q8Zp9QPmNjCadH3QYqwrU5CjXCA61CSyT4mhrigd6xEkLc5Yjt++7riLB0JfLg6nLeyg4YpCcQjZANRAb9LimXJpL7dXxc+vQ6mJ/KcGv83ksQxc7HqqDc7w5mscvX4vqN9x4AczeJ+Fpb0hHFFEETzmHQ9zAI4fYFwUhyZERN6lrppGqtTEbUxX0dHphMMClzYeRNPdmC5l1qgSsRkcr1EU0JO4eHcvt2eL6cC8fnNfqEcv8P9MJWy5KEuFt2JKKmSZFINH7qh9+J5Vy8X0zXZ3EQ3i/j/JhEeC7CgObtWSx7/MjQSBBRbZbygyYTWP2CM25KO8Nx4af3YPU6gwcVK6MU1sMv0o60OU3wxr7lLvVMFD8zX4OWxOJ7kj8ygJeSHus6k1GUJnsuRB2OTUKOQVlHXHBh61EZzo5opbdTHTg7T+AD6OyA75dZhnsSi2fG4Xh7A41/clfEA/01ad+rVhszcSZVrHbsFBFxGacMShZ5I9KVVwe/c7ZQ7UZugrntC3FDY5ntBsKT6VAFD+Cx7lgKYq6g6u6UeScwcGXlpwauuClZVSFSyLcwsxnfHO9DlSIYgJ0i3JGqhfB1m8OwHa60vvJeVCigA685dBff24ylyBNobYd6EkwllCGMB3Ygn4AdSvsIBJ9IgpxKg5SlgMj1WN5jipVviDdLKlEJZXoNzOsimXC/qozFMu3+idh+y0qIvlPx2VT/XdZN0cwKDf6YXsWQ0ch/WT4XUbLYIzNhjmo2NJ4Oc6zcELwbuSilVUF0O2K9wGy6+1bDYHlVKCJnlAiZG++hvEYaQMRB/PyLTmJyuMEL3/OL7dge/CPjt7R47iDZHnNdZNbd5wRv6FRSY2ftVr4zsXTBXDbNSKbAuizKql63kjjbtS+L2en5c/i6DqRVZ3ZfVHt8mIzvw2EdHsDZ8yGRphlxIqU1e5VR16UHmE0wNIXpejhvRXTiLfHw8N6MkBnL9tj9ekU20mTSUWKgg+/vjUr62HcUohUjduNn2HsLM0VWQmPdAykPMMsYMhEXajw5bHRJ0NtiCcKmakl2Jo5Veij6PzSqj2UVhmL0jMZngrH948m6YdLSjWfh97S0P7bCrjqpLGftH4Ab8DLic2NsjuinCTFke52MWfxCWwy2mI14JFnD7PMvJyVJNbFy1Vks2/WvgZ8h/hXuc9mJbH/HRbj2WzTE4GjrDjxEPj+Ngrmi+VHFMyUCSd8WphgMqe27d420htfce4Hf5Q4iZ718IZJUJQ8+68wTgxlwiS7y0FgQoXaTFRFpouIEXT6ECVr4thH4J3MgkkgDhgx4X+/6jIE5HZJUs66r3gRNvkl4iL86/qNIhLqrQ0SkZQXCHicKk4wwyTQWWOtTI1IDzkCiVh9Vy6hjVdzQmCNojqwYm+UnHSvuntgp0N0eN1YfP+JPQTQW7pCSAQtyTkUrvxNmthP2CBf5Hj9Eawoa4YI+QISVNl5E5KhaYQzmPEkLXvRj3EgzE+2InX3wuxu1V3l/Egghd2MXFJG6QTwm+q3GYC5rNlzQkzpgK+yASUhKi9iODH1zxw0wp1eEEHCbK4ND5jrZhpAtWddFagoGbhP7YEDWtDiuzbZLsJ7s3BVLEE1LIurSngTHh4YqE5D7hJRXZRCqn9YkompnPXbAnN9WLN0UIVoHbiF4yG9YgAqIooNIJLPWfv1OucYukDJA0bz4PqoZYybqFIBoSruy+D6qFUX0pwmp/7MDiJFSWxFlz1nHMDlUt0wzq+1G9bBMEfkoGeaYYVTmvFiiTo3A4Oi4N7apljLEPcewBZIS5QOuia3LlW3V+jkQ+W7cDaW7nwaiD4d+C3wds/0O3uQNc/5bMCHrtgwTjYTHuNaDFiCFoLrpr2lH/BYDLjaYsyfjK6w+jBmwSWH8kExjYQJRLdMhbX++5zFTdmuPG5+dqqWp01rc9GYQ7YSASLx5zLzLaSAetoXy4PutTMSLWBar5jqIiHhdwc/qUEGJANVzQr0CD5KxHziMZZrRZLPxvYGBwILVmCnJQwzArgdgfY5pVthaYNai7sUXEYlLVrKRGekzVzbMAFhL5qgOmLEywahr8RiAjBnVBuYuxxCRHxIwsIy9yyTl5hJwDhGnI2OtYY5JbTPhrjCi4skG485YEj2VE6QEcT0cA0vdVioyGNFJYMZiwSTrvLQfD4cNhHXfl2hYsMGkux8QjgXjsFS3U278EQEELu+POi9DeyKqGxCMe+QcG1yHuYjo363wKJgzMkNEuFcvPPiylMbnsLAJBi9rvZSIRany+IwMJqjLGpLIPS6FaErJEvh8Bcdh0OdAgugbC5CAGR+A97VAc/z8aolzlnyxjghWQmFcj129sPym74GuwxVJh8nOEbhfM6TXajjREto3EOZ+ZPyWFk82XhGJ36V21jDnTRQWQyIRbtrsijerCWl9YQY+52LxelZjUWVubF9ltn//DiIio7ZiZssy8SakPnWSqMet6VgJ5vaSQ5nxM3bsCYO50Y5YMrFVsYoZgsMOZMs6WMdkfiKs7bNkRfzdc7tQAa/pMgwYPpEacNvSeNgatUU2coX6ys9fkKhOsv7/7WEo5tWdECtzEyvoAfORIOc8CJEj+3FeMMcgzbIGeH9yFlCiAqWKY0DOiICvScAQTbqJZjgiOsN8PWIScF2zjoIePUm2VxR5J+qgYftq1DVgZRWmdfGKeFjsImz3zuXxvk6uj8/rEeLOqpeNaJMQpECtgeBCiHD7nbGEsJaURgoQqf2IJ4jWHSDkzc9RqJI7d6oNzJUbhV1dLDi6Q5Rzd6vaV5nh4YUoDKCXE2dTPdIlsqoPkk1nNkVUr/3iQJhjXhwxm7Ako2tG2oNVJQ5Da7T97jACy5Z/6ZvAXGo8BrMs2Djvg+TN9FqLdyNyAV274n391aGRcobtWiVngXlnsBIHQyIek7pj7EPc5GrXxDou607IXQQj3tsrENJhJM8jt5TogTVp3dpzGQ+bkCDM2LNmw8OrU5tKMHeD1KJtq+CBmUoyyg7lcDNkhCs1OhF0EzebgSpSqQjXpmi6EOHRjlb4nTPN9qmk/LD1JG6a67ohoa3V/ECYi7uPmW27jkpYnjmRPiO6A6zswWSvWW3bJB++jvm17NyDRFCmdbGBSCs3VhF6WW2+4yrUcGhISF4XyGEztQVuohtCcY04kGezoqEOzJE4UEKiEWU4E608DN+SQOAEOVgPTcAOC2Zdzu6hWsNBRMTXA7NTPVLbZj4ZzLFUTSztSFR9oyLw+43Zgv4Pp+/h99ah13yYC/FG3YHajktgLnofyiMb26MS5/DB2DnVpBju4cnvleupiyOiLoG7cM66uyvMxR/HkkTVqYhqR19BFJqVPfbNQN4c65SJI+vJe5WSY8SEsK5fw64O1vLsQISq1C2kItySnAU4SeGIkh/3xPtajli3586GCeOPDI0gEaGq3n7W4nmTwGjp7diYshYXzXuSjZxdhxFq3GsMXhqRg49Za09YocyKyxoi3HSfRNRXVzrAXNkuaP1rlh/bI+sXxw1o3j4k6nmTfvdy/TDKtmmFn0vdFfDxEwYHJ4gEL+Nc7ByI70OtMS8iUpwIazmtRLixVXPMTm3moLNn+6a4kK4/RJhT/ZwU6YPcBKZOyTb5Q+NwM2AGZEyUahCBb4vnx8y+oSl+hkKke6S+ikTL9A8iLyCXhpU44klJggZpF5DD88gOD5ZRjYkFeS+sATOyrRoBqDMDCZk1iANmKLFkb2aOPIwdZH/pOh6Ff3Jlwfvawx036vFtsYxUn5j+qV1BVxJVU5sBeH22lnqR+2XhgK3ctQdthLnlLhiUNFqAnShMUVO/K5IB3YhBlp/7cOWEEZYBV5zD4PuvggTpfIilwZdEwbVXP3wOXYiGxUOyhzGp/bObEPb39VQGZXY9sfQaS1QimfdPGSJvzwKGyk0Rwby8G7v68ldDDhMLGGYeRQ7LfKJh8yNDI0iE5QIlPP6GtBF1tMRN1D8cs/iOFgjBFCAw2kJ//DI+kjo242uwWtEc4panDkDmkg6Tm6T8Yt8SYbkJBB61nImHI+tsWUd64DetwQcpQ148gJgF+UQ/JVKygLDTj95F6HYK4YRUrIKEvovnEKq9txbfB2tf87+Nz0RDQui7ReDbcoZYK8ymWsCVxqFQz8hOGLiYkVat4vnwWZpxBPUkyhLy1gSV/LaIyGyyoGuQhc/4GS9VLpOWxsTXhWTiXdZgIJCRiPxE38X7oFsAiXpzHVFuuFwBvA/9tyGJ+jYp06k9JboRLYn0yll3LIsbtQnpnTduhhl7QQvSiUQIoxZFEJ2s2HczzEmMMhHw34Z/04CQr5kmRuMRmCwwFcvzJMFp0Rflptv1R2T2/FW8/9GhxII8L5aQXcYopcAj4jGRYwjTUuJhMnIv8qY8N2JgmbBvBMwxk6szwUSQcDYq4tq5YstwRlVb+bPT33f6FBEZ6I3dX6xF3XspEoYZmtCgM6Izw6djadhtIXZn/aWDa+KNDxKBf2RoBImIjFAeOM8fIawcQsy2bl5F0t+4ENyUrRvhIbfSATevxk54QKzvjvrpTJ0yXy6cUx8QTcvjglG32omIrFmBfdfNSzrCXPIzjLIvEtb2+Zt4oEsO3KgzEeOjKQGIYthXVaICJ+4j6W2OF3ZinJyDUCCrk3qUx0M/G1k0LIioQA4g9ruel/EA6kDc7YzzKA8NhmCoW3lFROLe4sZXfSBu3pZN8Dlko/RYDPr2jUZk4wTxOimmgwFN0M1kxc9uBzEg2U1actUaISIiwTfx/kcex+fGph3ykJiuxUBS22YdAPqGeABvVCUH2wORS3T3Bu4v/ZpgkL6QCCbt3YR7BFOPZIEKM8hafwpLKw+3IbKhRhSYciQL+pjrJhtNiR7M0Mb4nTBC3+QGOHeTrOHhBNW1JW2kLVSdOH1qYBfDbkL4LtAIA6v4o+jiGXwRf/fsXUSilhG78aeEn8FQETa2DFXyCWzOYPmcjb1L0DfozvFF+D7aki4OKyy1Me0It5n4N4ZP7Q1zl0lg+atDI0hE8lvl5s1aN9UlDxGu9cBaHLMSkt+dJ1hjZmgCU7b8kIqLtXlTDFRuqQhnO4kUMitTjB/TBuaOXsHInpmSLWpD/CkI8e8V0Um4RoKSxmYY+Gy8qNz4mCOqbhYMDhjEuzwkCuZYi2tVIzyoJ63AtqSI1Wj804mIumwgbZkTDiIXRZ15+pHWvRTCsl5CiIVxb7BOynQyXj1HXs96omz6niAMPQavgDmmHmlXQ5l5M7Ely0aIsCSQboK8RNlyXkt8Dp+nYFbcfy3emyAnFCpyJ+I6bUtjVqQmbzJxLH/SOcQko5nYEoPHmXeG9yhrmGvQCQ855th5KBKDMrWKqZo3ICIycRs+S6eJmZ3tSiy1DWpYDOb6zUHuQJdOSLQeZYmBZdECuDcxXssgH0w2vLcGKn52mYiJ3JTluPZPL0ByYFNn/AxJtxGdkGykQ/AVHpi9RmGpeXhtRMkrtsLAUl2qMKwzHF4j+bDUxlo3mcU3sxYvM4b4NV3A+++2ZBDM3UvE/cptNe4Tv9qd8VuIlaxbg5U4ChFBD+amyey8mVPmlRO4oTGBoBDi48ECGgtLZa2I2Ugz6L5hQ8x2g4Kxdug/Fet4rC3LgPgdMBOiANI9oobzRbCjYgqx5J54EDPRE0TOOj4W+SrMYZNl9nWLIhfDUBcPNKayV9PpEMy59cE682WVxkRtIx14TcI7/C6XHcFa9OVTuHnd2YzRvs0irDFHXsVnLnoLwoipJLC49Ag3wwoq8mJjl0B4TfXyuG5m2WD9M4V006h1DUREGk9DNGXJUKzZVjTQgbmVhAzJ5Nb3q6TLGTclM0GmmD8D6wpgn9U4Px6YhbthSaJnV0wi6pEe+x6TEUZWSz9PmdkTXvIuFbdi/wu4zwUSXkspIq2ccAHRCYdRyImoaYIlNIdKWEa6RfRaXpKyhDpAYk6frIRw7jGiCX2Iv5JazEpEJOAu7kMfCamcilcRTQjJhaW7I0sdFT87k1LmjRuYLLL2ywYdkLg7a8komAuPwWDjaBCeJUxGmylbSiopLV3EEsyPDI2UM9TdGKwTg5kcMXngcia4GXSuhPXOk3eQDNO1D7YqeW5GyOnxrsEwV6gtWqQ+V+ndL+iINdG8LVEngpUkTp7GYIO5IjKFydOReL2GpZB5HP8aF8MYIuqyMVi5uTiRjZWR/oYQgStGXJ0dgIuLuaTWbIH8j9BTWLO8sgLRiRKkV7zvYiTMnnVRMp4PRCB7OpR0Tmwkfi27SItnCBEz20YQqwJ5rGGOEdpKmuLmdYV0z4TPVtqoZ8mCweIHEpBkykCY2GQXuPcKyWtd7SrBXN9+2BXA9BmciYnY/mP4nBiopOtzE55Ak8p4HwbWxGyyHFHsXDcGs72HLxCd+RyDz6GnN5YWNhKFVYdu+Ddal1UGzExC3iQP8jXURmsivD3Sdyz+TZ+buDe5zcbgqJ4bEtL1ayGxkglrGVTAcp5TFyUCFuRCSJ/Dsb1Z1wDX9IVoDFzG1UPUZd1ORL+j3ZGHNbXRZJhj2T49+HsqSxDMMKsa4Vywluchzti6zFxBX75CNOH6YgzADK1xfxVCVJXXmi9naCSIODpaqYvAat3XHhMYcSrWJ11H4GLITjIPplgZVxQP1sKlkdDGtCPu70BiUkyist1Ol9T/R/ginNeVkENTSLZrRnQtXpLv7tRpzIoNCGO/cmHchIb5IkN/s+qAHEY+w4g6JjDHWMY1h+FmMGUooj+hWFUSS3NEIpjXSWFSbmlGarahIcgLuP1UuQmFkLr2zGaYnU84gKWRGAKZr+6MZQ/bhRgcmBEdB8++WLpjnSgBk7E8UEXV5ra2J3YOXYpLhrlKI1G8ZhM5WA1yIiLEni8Dy8Ywl5OgacY9kNm/dhKWadTli8hwzLpqlcF102UzthDvnoKImE1nrLFv3YCHQcsBeAA1K4OH3IoAfH+nCV/HVWXBzgyu+k7FexO4FJGDfh74WS2IYuV1ov/RawxqIhjlwkAlszmWPWI3o08MK2cMGblG8fMlb+IS+R6DVJ+x6JPRcQmupXZk7Y/pjs8/U8qMXI4BjWtvTBgYeVGyKr+nivZoXBbrh5+VlT0YJyJvI1w3TNmyDTkPrRw7wFwwEaoaMuXXSJRs/JZyBut+iIvHh0ZtSS3C1SmvEOLXSnLjZ/ohpJORlCAYM5ZpO6gVJVkJZS2pzTd1RqidKWyeWtsf5uYF4qb0jNhyryeHV83xaHQzi6hdGudWLgamsOmxCyP7M/PbwFw4UTZk7aHVjLB0deI2RsUzmmDGuiUMv3dmD96bqFiuUCkZ9ifw6On7iCYwT4w4D9xEzYbtgbnVgxCJOPcI0Y4Ygti5tEAk6pEqmBURCXmkvGcLdmGpZXoX5EQMGL4a5rauxAB6xm7suz+kShZEREaQIJWZXBUywiCqb1NEycYvUH7vdzc5wmuYwRUrAzZ1xQOIdaIcJuWBNwQpYG2k5sQ5eOd1hLRbmysPvryE3G0xCIm7/vMxmLEZgLyZCB8k4JXqi2z/z28IxE0EznSLIPrLpKrV2gkiIsc3KmH5plNwX1ozHnkCtIS4A0UA40OWwBzr4uhDbAp8I7Dkq5bpFhEZewDPkkiVKyxVmGRESFJC8PPCYLbXKuycujwX0XXDVthGemkLBipNSELC+BR/hIvnCpUxlR3xa7Al0sVqBEOEy2OzgKEycQ9kwUvwPYSIhpE6K+NELB6tzKgbFcdoP4lsaMw9bvDOMJgrb4ob68u3CI8ePo6bMiOHDuuGDzU7bNupRKkYc56JVLGeda8NATCnVokU4TbS5YvgBuy6HhfSitGYKbPWOrVToojI6UXKCP1SHAYuullxQ5+2Cw/HWR2R7f3gOR7wTArbYgj2nTewqQRzKYREe5PUWef3Vd5rZ+JO+pQos4YtRvLa42T8DAaEbFnPGTelJ3cRETQwJfX0hdjZsyMMOTabTivnEkkA9Y6QijvWR4i7IVlfDIlgsO8ld+S6sO6J4gaIzhi1QpZ914HKDFgtxy4iopMLSzcGRBwr9A4GvawM3LU8arMwhdXq9ijyVLkVol8W5ogAzGmOKF5XD2UC4r8BM+LMRvh7qc8xmYnfMwLmmF+HDpGutzTC76RxFyTCPg3Gz8/KOfnrKFE3phxa3FgH5k4TwzhPIkD15gM+X5n+wiSY2X4H+yBhknEiYo9jqVE3B353PzL+NSRia3cUPSrUGiEdRoR8moTlBzUkLyJyMRYPCJYpzDqOD2FVY0RA1NLS+87iprdrILbRscCCbcoM0mSS0UV0iP8HsUJ/9AAXoYEhBlvDWigj77k78QAKnoKZQmaC6pQdjhvElSUIGRbvjeZFF9wQvnQksHR3ooDZiGhHeBJrabVnx3YiLRz3GuuOC30xE4mPxe/37T387pKCcKMKJqp4o7eFwRxrX2xrh2vnXqxyg2hXAzPHgKuI4Lk7VIK5pFcYuN5KROQkN2khHroe71d7QtTduAvVOZmjqGM15efwuY6ZozojFBFxbo4ITotpWC5lTpThB/HQv0YM2IatQZ2UroQTZZgHg9Lxc5V1d9OKSL4OGIMHywuSVDwlaqrM2ZNB8qG7p8Mc06LwuIxr6cgp3K+e3cW5p77KrJgRMjsQZ9odw1CSuSzRTSnQDD/X6vmOMDeRtB8nPSbt8knIk5IsuF9LorJM9fDkEnjJqH2I4DFJAfYMvyMk1dAdiOKwQMDvJn6GthWwrM5kv3/VCvy3tHgyRUh2wLHsv2Fj7DF3boYLjhH6upJWLdYBwfQkalnixhehIm8eHo8Zscdl3PTL6GN2wiD+9PIOSjtgG+msySgQw4zFWLB17J7ycFl/IgpeU5iIdFU1wUCrakGc6zQb0YlFhKg0i2hRjGyHm7Ia4hYRCV+Dtd2bT3Fh3lSV0RZ44MZSuZoJzLm2whbHK/HJMMdsyi8+JCz2d4SAVxkzRXZQMdncfhuVnyO9B9COq7jZMIErtZiViIhdedyUWMukmwqZFBEJjyBaFITvoBZl+ssEyczDeiPBd1htE5h7mIDZ/kgflKneNwgTgWqT8Rk+69wU5pijJusKcTutLKsxNGF5B/ysXYlK5moiA8/0JNoQrYs1BIK3GYUBfv9+yFfZ4IXdb1Vr4b55NkD5nqN3IokwOyHa77mG+9fhCETTWAmF2XknhOK+qVdnLMyVbtkc5o6R9aQWjepXA4X2fJjmCgkYKHJAdG6e+iMR1Hz4HphLuoY+OfkrIyL8x5Yz1FbgLGBgUtge3bCuX7g7ErBCFqIsMYPbO5GSScGCeBh69MCFNHQ39mifPxel/JvpLCHULKwDc6aEMMjKHncTiO8IYYAzdje7HrOgnjJeiRTUM/6+/r2IyAbCCWGaEIHEUbEVEaUpqotQbVHS4snayMYuxUD1+gqsH19U1bEvxLA2NVy8RgT98TiOn+v2ZewwqFALA6GXJHusWQGDiKG1TGBuzglEzla2U/IdmJ7CToKS1Z2ETPRH67D7pdVqNLTqUYvUyUtgia85yTKZ8FUWgmztUh0kDUyxNDR4JwYCobvQiVYK4J4TurwzzDE1TTdyoDM0US1nLSJi3RE1BloPc1T8zMi8G4gybeuSBHEjgeBBgmqeJ0GPUSf0xDAuh+9lVU9MPryu4N9lwcuKjcp9+Ok2bGdlaEJmA7xfmyYicXcZESAzKoD7vPcWPKj9lyBR1aIYorWMlJlFZbb28SPuG1dcsWzH9mWPi1gGHDNkAcwx3Ql5SQwkGbHSC1uyJRX3oV8NIjTSnaEeufLigclGqWF4o5g6JRM+WXISF83jB1g7HmmH6EH3zZiNXgzGGrhNa2Ukx7okDIl1995bCF2fu45Zd7s6GMku3ITR/tuXGFgwIaF5BFplo6Vq4z96H9/v2fvJMHf9NvEwIRn2ZRdcSKyd8YYObsoZyIKb2ASJT6GLEIlh+gwVVXXcOw+T4TW3ruKCvuyGi1KNuImIFGiMtfiwR3i/ZpFDg8lZVxu9B+ZOzMLv86jKUbIL4QQwJ9bXV5FzcvA6Zl19LfHZLJob1/USovUwsy2u4SWnomCumRkGr23LKtEOdRAoIhJPSNrMd2HZeKzrk247MTbAkqdpAcJ1IAewWv9BRCTpHPbdqxUV8xCIu0clRHoYEdShHOp/7CPtsjkIH4plu0fGW8Mc06HxXIX7tV5p5AkdUGlAsA4Ops1wbC62Llp1coY591UjYE5t3CbCDbiqmWDAMO0QfncRbm1gTs2T0LXA0nsVgmBR63LSOVHZAcu7fsQGYRzpHPNcg2UPNcFVROQ2Qf9/dfxr5Yw5RAqXtXgy1MH3FgYHrGRQldT/m7oGwhyzJWdIyRI75QJhXAemCaE27hLhktTDSWfHo2Ri1fwMD6UGpfDBbEkMhxzWYkap7r23Ko3ZzmHSpqZWSRQRmTEPFwPTf9jYFT+rpRMuOAvCqPbfj1Cd72zkXbAyitqCm2W252LwoNoYjMqWY5tiMKOW1RYRiXmJHB4WMOwmnIX8RBdhHnHUVJMSD1zDQHBxa1xzrMWTdU4wsq0P2dBYPd2cSNyzIFKfHNQrOiiD4+dEaMyHyMAPIjoRVsS8q2YVPKiDCXLG4OG7fqhYyWy/+xKn1M6qPWFO90rwmvqE58Pa0VlJpgtJSMbMwYOFBRFde2K2P5eYV12LQVi++aQ9MGdkpvyOG9XE99aO7DkWpkiELNABu4ky58DnhqldhpMW5/DHuPcvd8EulthDeK+hVTMzJkHMCnxFW1yH+nVGwpxVb0TJWLCRcBLbPvWaILKTvywmms9uIofr7THSgvsDQyNIhFrmmnVddPHARVm6ognM9dyEKMELYss6rj1m3awVsAJ5WOuYYbAxZTa2EiU1UWaPlgNRn9yiCdadmMU3I0fqkLa0dURsSZ/wE5gVeN1JGJRlIJCxmovCsv8udXHhl9LD9xHmgcJdzK+jdJPxMGfZEyVo1b4eIiLbeqC5DDOvKl/FBObUQUP1wdglUbIiZrG3L+Bi8y6I3AFW648h/hcnZqP0b96cyTA3qi5KEKv1SkSQ5Di/Fa4HZg6WKy/ew8cPsfyYmoKHN7veXh8MUvv3RvTvzjUMyiZMQbhdV2W3/SgJP7tvEB76Q0gZKGQG1vWL18fsjPnQhO/GWnTCKwyY9En3RCliwKYuLbBOjyRy/WsJyDnZTRxbJxGF2fjdyEW48wQTklYuCPvXK64Dc7mJ7P2z7ViqOK5aE6zDoOtiDCr3TkAyd35jhPOfE3n/TkQKnGmnMNJ/h4GYuNpvQgIuiG0RNGUwcetlviZMuGtiQ0xSgjdh0KdXF3VN0mv7PfMoBoe/On6LYiXzzmDj+hmEuZg4VMx1IulJgoidpFaWjRzUS4hbnBCi4nMVVM8idqY5sWEVHuas66SCEd7kMe0RCr7zDOuuzAH1yHTsKWYE1PnHlGUZ79642OyIYyczG7Mh5MAOlRARmedPrKCJA+oTotA2ci8ynue3RDZ+T4JijPdT/m7SLgxImDnW+bUoysK6U7qT8khh0uK5i7RpWhK5YZY95yXCYmouRruOyDlgEtf7j+BaYl0Sy9oiTF3UEflKufMjijGN9N2v2Yjo5CUi6durl7JTgjHg6xDFSqbrwDosVrtjMDvHG5+vHOTAJB2YVCnRuigmKXb9lign3uFnX75qNMwNm48HfG3S1cS4NKwVMvgaPof+k7DsU4AER6atSQZMyhmfVKibz1jc+969wX2J7VURi7Gb6ibhNVnaY0fUB2K3XkYP11xGc9KSvxA5Rh36KsstTPTK2gHLL4yv8NQPA4FwQlLOXAzRBCYZbt0PtUPyl8az5Fk4JvPzW86EuR8Z/5p3Rl4C0z4mJiTptQx/TWBUJiyVXj8NJmhlqqqfMRnhiqQ/O4a0pE6wJixmAqMX10GozpGotgU5I6P4HTGSikjEBddEpZS59zoe5oy4OpGQ7TyJ3G56NTwuROPnj32Fz07bcghBO5E6phNpLQxS8T3m7cFD1JfA9FeJiJbah0NExGU5aick7UZDm0jyrPfbigdQ+Hnk3egXwc3qyX0lAdG0jAm8pgUxFqpFAldTHUQn7Elmx6S1WYljPyk/dqqApbDAe7jmaqlKK4wTUNoWN+rsxXDDZCgc44RkMcfD5pQrlsv2ReDnalIMA8Z6YxDVvOWudEB1Ib3+G9ZhAGlghlyXqy649pntd6E8CLcfId95FeJ1wta/TZ8lMDdmMgqwja+vXIeMRBm4DnUYph7CtRm8H59Dlsy52eH9H+KDPLdde7DVOG9+RKKYzXe70Up3VnYemJASndv0tTB3fBt6ZzAEy7ABKTXkxPerZ45JtTqYE+GCYR6dMVD5kfGv6USwgCEHYfYyIRnjQrjx+e9AT4y8RREKZiTPwoXxeukx+cpDAqHwS0jKq2eFN4qpTrIAxN0TN7ng+YiSMJGbrZew3dRpNS7CbROUi5B1jngRq94htdMHta8+j++jPoFHBy3B7NSuOaJEy0hNUbftKpgrWRk7QNSaGC1KIXLCgpkuxAHx5krs/lA7ooqIFMiJzzVzol2wFzfNlBRc+D7D8KC+m6hcTw7TsTthzywsoYzYgpvoDtLiyESJrGdiwGRI1lIxQ9zkRtfFw1Dt2CkiYtxtg+LnIX2Q9FmlMAY9vfqgYFDwLsyw9AicwDL2hba4KceTDpstRE/BsQoGTGdUJSPrYkS6eR+W0GqTddOmDCIx5q1INkkg81598ADeewRLqEv7o9Lt6E0Y9HYiqJP60GQHptqHQkTk6ZHpMEfbGYmLp1UHLF2xAMRvMXIWmNsr01NQy36vIUaOzDDLez4GEf7b8X6xLo7MxOum/eJAmDtM0KQqbckzQQKQX+VEaCSIWHtWWe+cuh55DYy4OK0Jwqh3k/Em9JyNMtIxHvgwMBISswI3JtkDI366BSsfkhuk64IZZtmRRc70JJZuwe/p/ELMgBg5NOYKRtmO/VvAHJObfqJiXrcnCqOVBmDvuE0r7E9nfhLMIMksP2ZFTLwoI1lIw9dhfXJsR7xfrFVz5ynls8kMncLOY1aoJmSKiJwkRmgnAhEROTID7wPL7I2NcEEvaoOfa5gPth8va6/MHprNxgP+lDNqpLAs3nsNZoXp1YlQe3iIiGwmniC9NiAiyFpQdXMpORGmXdfBaxjnoj3x02AEz+uxSA7MShCLvbcxY+9VFYODmUcwAMlLPHYSVOjsvn0YzDGbbkZwZF0izPSrayVchz2WY31+bk9c18xY7e4xnCs1AFvIy6m4SZdPIIQesRWtq2m7bB80RqzawhrmLu5F5IBpR8Sexs6Zc/fxdeVIINxC1brcpDo+D1MbYVBFpbBzY+DCLMN9euMzUaAelkIY2XKAN9IFmANo7Bokpf7I0Agn4sAV5YKrWg1JeWrehAjXdWCdE0VL4OZVcjBChpZ1kCD3Mg4hyOuPMXtoHYwHldoVdOZwVFRjtcP9RD2MqV2WqYg1/AkHsX1HXVYREXn8ALszOhATHiZ+smOvkt19tDLer/gdfWGu4SJEDq7sQvawXQ08lEYSx9KIlVjbZSx+xxYYbO4MxXvYhegYhExSlq4MumOG0bkdbqLM2XMeUUUMJKZMzKGQKWVO2YmLnEHmW0lt1ytciZIlPCKqe2RsWI6bd2GVl4oIF9YqNRq5PqzbgbUvzrevBHMFSYtvjIpIWbA4Ppu1iyL6wTQWvJbhAadbDu+1/2TMzj0PIE9ijBWiKctJ8mHYFZ0yz6l4DHtXYEdAQDDySzqUxzUtsRi45smOmTgrZ4y1R+iaaX0wFc9VZ5Ecy8aghsrvyZxobuTPjYEWs7O/sxs5LGrhLhGRea2x2+Ep4V0wwiTzwJh9HA/biirDQGYr3qIEEs2v+2E5J44g06OJVtF14rkjmfHM0WuG94vJXnuvI8TiXxy/RSeCmW0xe3DzErho7j9AouL9cIR9F0zCTfnGU4TWI7agyRUzDdIjGer8VspDg+labCO+DmNmeMOcZMSv2rEPstOv3kemfKMKWGrRyYULs5UTtnSZl0cEKIMKImOHlNsprM3vJYJBV9og7Fu7GB6sT14ikzk6AZGj2wfwM5wugF0crKMkODIZ5moYKiP+iX3wM7wmJYQAon/QlqgM6pCDMGw1qmkyUmb1snhftxNysC1p3Z25RhmAM4Er5kTawBwzoNqdMYsRPQzIbm5EJv6xuxiknidcn0oFdWAugARMQ1XB5jlXJJFdi8PNcWZTDDTrmaHFNZOHvpuECc6RKRhYMJl6t7WBMBe9BUm5SW+U6N+s+RjMOS3Fa1mVQNRU7eEgIrJmNiI2zTbiAbxiPwYgbDwkrebeBHXJkw8Dumaq57XCaFzTa4diiS76MAqhRZIDvm0pDHqYydeDDV1gTj8HrtfBu/E8OOCPc6XK45pQD/Z8FdTBs6VsW5SuZuWc9hsQrWaCUUymO2QHlpE+fMK97lfHb1GsZAHDSDvM4ryI/wM7MGsb6cCc7w0sLfgGEOdBJzyomXjV3TgMfLqpNBYOjMTW1Qtkw7Q0wUOU1c7nrMbs/MoKVA+sNQEXF0NYWL2TkQ1XhEQpfmbqjM1K4n3osAaJlQcIsY5F8bbE9rs9KVO9vYFdIaJvgnOkRztsLarRqU3DzhOHRcdGiGBtDYqCuTLFMOh98QY3W2aipi4/iHDnSeZjcZ20tO0OU2olhF7EtcQY8Ll1EeLPQzLW0yoER0QklphGMdOzzMTQrEkTJL7p5MDn7ohKMtuTPF8sw2Tql6y1MPABlqRYILBhGpakWDlHtzo6oLJ6d3/VYTC4FfJ35m/HTNSeSP53JMFnNtIlxmrsvT2xtLCwLT6bJYjS77pQRCKOkX04RdXFtdURAwEmImY/AGWq2YEZ6OUEc4uJr8eGzpVgjukpqLsuREQSXuIzdvKEMplNTUS9El1T3EuYcNXOK4icDRmNgSALDmL3Y3DICJhW3bFM0dmClLiIrsmPDI0gEZYqt7ihtTD7bUWkcL1Iv3NvD4SbWpXEyPPSbXx42WDdCcwQZcZhJBepBXfar8K69oFhWDsvQSx4cxK1v0vLkKjH2OijuiIEe/IOIhbhdzFTbhqGnRdqsmE7sjmGRuEiDxqLJDePC7ixTG6AgQsj2zJW9NtsuHmFumNphbli3opH6K+xKvOuaoSH6LFbRCeBtLMWIqhDZXI91omQTIINFjCsvYDBwDCynvpOVJZMIrZjCan3Nqy7t6qEa6mkLn7nlYjyXjIJZpg52MFDSHxj3JnT5Hmto2pVbNxvObwmSyETmDu/GMnHfcnnZ4ZGzKo5Ih4RRlbOESMMjh69QoQtOkSJHBUhjPhn93EteR0kXU138Xl1tcX3cSMB10Nlgmy8Jyz+IURlcngdJFYzFE9tcR8Wg4FbY4ImBHogd4CRCF8Tvg4rD71ph+2n8QGYnTPUtV51PFjVQYTE4/1q5IhJK0uq3Bai/wdDIliXDFOsZAEDI5aePIZ7bg8fRM5+ZGgkiJiukiVmsH+RopjFsXEzPArmEkjd0aYqRlSX9BBhCHmAC2kIEf8464LlkWqjlPX+0YMxK7KahX3crJuCtS+xrIDZgzOjrswk2FC7joqI3CQKbVGJyug+magCFifCUr5XkYfAug6M2y2Guc2uCC1WJvK9x+Iw8/K7jRG/yxhEXaoT61+LScquhTw6+IwwsuWIVgiP58+OmXPvhYEw12AGbtQugbiRqB0rRUSekQxoPoHRQzco20iZxPX6zpVh7kpsMswtPIGbaHbSnWHXHq+3fC12SQW7ofJeeUIi1W2PrPXi+sq1fmkr1nCrtMKsK+UDEpJZBrzXAgPmvAQR6jsMu38qt8YDYscw/KzFiJqu5EF0Uj38F2EZbGs4JgGMbNmOGHU9IG2fLawxU/5EAnym4rmO8FpYctDcSYmcem3GoCdh3wiYqz8OeW4GxhhstOiO9f+aXfAQZZbsTKackS1vxWLy2ca2kuLna5G4fqk6ZePp+D4IwsBKF09IV2Mi8VfKkZO4jiYh6hq2Ccv7vzp+i+x1yxUYAT0hSmllShLp5grY+sRcJmsRNvadJxgwXLyAZYSxRILZ6yRGle1rK0ldi8ihf3IO+ho8SMKDWy87HlR9CeoywRY3iBUn0mc4Y6ZPCHIP8TtpUV55yNU3xe/85ANEega5YAcAK78E3MGFyjab8TMxGlebg4lwP5EVoxAVyUHqkbVVpSVmVBV5PBDmTOvh9d+SMgWzve5aAQPcxyQ4WE9aYTMSc4c4UkZQy4jHJSPsq5sLEbfa4zETL1wUg54VZI0w8uLxM7hubi3ENWE2bA/M+RKNEbXJ1T3Cr7LpPAPmmPrpRMKUL0l8MuYGYhA1g7QuPiZlWov+G2AuZCVyR1aeU35Poywxq2eumw8jMXDfSbp/qhljAP2JZLHF7dBsyX0Bvt82RJulQCOUghZdbJlWIztqa3CRr7RuxiEydX4FBmmuRGOjKGkXnkjWpp4FqnhmNscOiL9IKWhgV2XXkdtMVDDOXw05V0bGSIyvWBzPvk0r98Ac69joTyTOu/RdCHOxgXivWXBUy0wH5n5kaCSIsFygLFUw+2mmTliM3HjXA1hWYK6gt5biYcNMuea748IsVBQzYCajrSblMfJlFWKYVLMmbhBNy+JGbUN4Bw7rMKNghMYyg5G8OdoRF0M2kqE6VFRG0Iz094Swhyf4IedkAbHMtifcCdta+ODvPIH3qywJLLf1QMi86TLs7Ak9gTVltTIga4NlaMoxUlbo2xQ3JaeV+HxZ1MYDyN2hEsydicbnWk0sFBHZNh43kl6qz29MNEfG22Dd3fMirsNmpMPEIAc+6x36Y7tdsCdC0AxGHzgXW/B2z0QdC7VmyYAdYfCaGsTQqCWB6buRttonwdiSWro11sQZ/4VpXbAsnnVs5VBZXzMfisR3GAjqZEX0y5OUKPVy4esYETLuAf5u1864vzDxJsbJY8eHvo1SPZJ5ONgSV9/uJPjuuR73w0f3MMNmcu6BM7HFuWIzfF4ZEqG2/RYR2euhkgsgpVeJx6SV+WmMq4fPUnV71DqxcsD9qlsNDPD6DiZ8El08X44vw4DxV4MIjZQzLp9TQrV1IjATZToRA4gV+AACDzPfAYZ2uLXHjoXI1vg3Dh/HQMUkL4G5VdyJkAcYKVevYQJzi0mvP6uLNSKGO6xM40PKCG/jcI5lsav242fNrXL3uxyD2d42H0Rd4jxQnU5tBCWCnAsREb+riGwcm4CZqO0yPJQZ7N3aDqFq37mogX9RJX3cmzyH50iQevgcbgbMr6RUeQyOlhLJ6PS6c1auZgJzzLxrvyqwsCMOpnrZ8DA74I6Q8fx9SFRj5mgt+2KZrrAuJgIm+RHOX098MooQOe9+XkoeAzOH26MiX4pwOeedhK9k4ISiPBceErGxXtix4rMeg5eH+9GzYNQ+DLbVe8k5QvC9cRkRx89EHttlIu6H5fITOWeSTSe8MoG5yMcY0KRHbEmEq90WrKTccz8QDsOGRdgGPf84Ikz3LyO/xrgCJnzRNzEhYePpGQyEGe9g7xJEGdRk7sC12M5p54rl7YEWuEc8Iz4pLGAI9sHrPYlDHRY2+g9AG4Tdt/Bs/iOQiPQoVj4nam9vSC1e07LXhYl5FVO7LFwBD/70yF4vIE6JLWZjtlO3DkaehXUxcClBRJmYFHah3Pi6bFkQzmemXHMH1FT8zFjc7wm/omNFrAFOPIhBCvuenIkV9pWYZJgrVwhr5wwpUSsbinAjrdkdlPenOzEbur0K9SqOkJJMjSKYnTJ5bEZUY4JpCV6YFTwjFswd3RHZiVVlsscmI1rBTJ6OE3OwJiSYvZOAsOfEbZidOTTE59rnZBTMRYZjEO0+DQ9DtciRaVPcWAPGYKmJyUiPtUJE8BVRxJ1HOCH7D+Jn7dcZkb4VGxERy0F0N9RdMev714TXMF0HZnpWwgD3NDWZUUTEaxHqVTwNxmx36Wn87uoZ47NOpbB7IYwef1zZAVGatHh+JMTlCd2QczN+LnamhW/oA3MV22PQRw9lQjZk2Xkmwjmz6qUMQJhviA9p+fclSfVKD1zTqRFYtu0wFr1+vNfjnp4QgMEsM+qKPY6tpbo5iGX8DwyNIBFqr4yWVTCb7lAO5+pMRuOjAbVwg1izH0mJLGDIQ2DEU6dxgzi1Fsklo3yRjbxAxXg+F4sZC1PYZL4WObPiV23eDxnF5argptyxNjKFpxCti42ESFaWHPxGuZUZoP0chJpPuyDEm0i6CZhNeQnidslamgoQZT+WdRfvjlmBYw98Tpjxk2n7JYqfKzfCKJ6F0QPmY6A50hE3fmb69pQ8JyxgYEZCekSEp38DPAzVktlj92P2678BhcBY+cGirzvMLZ+BqAMzvupcEaHVS1HJMBd5CZ8d5gpZsqWS4DytLWad5r3wcFwwFsWWGJ+ihQPW9d3X4WabPQseaFHP8Hp16uP7m2WD7exlVY6K44nrJuNhnD6PiFimmiYwxwJ34/pIPmbdXyxgYF0xf+XDez1kIkL15cYp9/UBpDRSpwiW32y64QHHDKiY1DgbC1vj342yMoG5VaH4HTOCpLxQItHMm4KVt5gh27DVyCUr3o5wjkjrKhORep+K74V1bKhb3kVE5jXH0tKPDI0EEZGqSMv5HGYdIY3xppiZIzkygWRiu4hSJMue25Gui+UE0rSZiVAtk8JWQ5B7wzGiZFLYa/phxhJC3B4Xj8Ze/AkrMLNBXTQRu1oYWLAHpCtRcbRQ1c9NSmDtbCkhzDHuwLwWuIlOO/T9EoqIyBvSHjZxE5I32WBtpM8JsrV9oRKCTX6Pr2GoRpYcCLWfuI7CSoNb4AIsRPwZVpBsr0tlvIdMCO3oCfw+T85RZvFVOuAG7DAUNyqrIXgAR+9Eslkq2SAXEvOy18Q9MitBxP4i9ePi+XBur8on5Npj3DCZhkNVQ9yoB5O6tq8nBhHHiOzx2auoAGrFPDHIAVSIdMWoM9ujZ/H3bkRjN8Xu0dYw9/I9oiktBqIUNutEWJdOfQpWpmk4H0tmp2/g39gxTLlfs0ycmXmxgOHJFiyh6Nni78obfE4YAZPtYStJKygD6I9sn674mZWPqYmWNeo66FZGHopkRCK053DUJrIZhAmDH1FJDvbAJEJIYPGrQyNBhJrvwMoZTPaaESaZsFKefHhjKpBaKUMiihOHwpeP8IA0JaZZ/reVZZTAo8Qgpx5mHbMDEIK8Ho7cgchVaBHrRWrizKiLdSx0alMJ5uIJejB2v7LPeHAz/OwPCdvf9zRufM9ImYpZreuTe8O4DnvnImG29RjcDJhYTXdC3lNzFtZ1Q5JmVUu8h779UcOEdXYwldQVfnj/exNS5vrz+BwuJxvaOIJiVRmgtOX2W4+tkMWIo+AbcgA9IiZqjGMxoxtyjk4+RJ6Q3/4wmFs7CZGC/ISo/Eblf8I8PHSzIFpTsTkeevIJIfPoh1hCuTgT31svEjCkkBJfxUJYunAngcVGlblWwGTkZmwmGXZHkhgdIlwiScFyxp3jaHKVkwTz42fvgblbxLF2nSMS5vMRNNFdRUqeShCWlR64Hg7Nwjb70HsYWAUuR10DpifRhpDZWReD5yosoVa2QaTTrIiO4ueWhJA8fRMG/GH7UHysUgcsv3ivQo6FzaDVMHfXZwzM5WZtyjAjcjU8fSjOj4zf0uKZXp0IQ8JXqGKiA3NMsdJuKtaFutsjVL1jTxjM1bLEBziCiDf5qFAMZuY1vAsSNx2I2FAS4XAwK3AG8fcYh2UPCxuMZNc6YAbkewMj1ND7yYqf+9VE4k9AJH4fDE1gjoV7SFTMFCDz5sUaMOPJ3LqKm/L8YRihnyV+FyvbKw9l1mpYugwiMaeOYnbGtCmYKdf8VojOMAfMHORe7ySdOFGkZdhxgTKgadYIA6HhRF8kL3HOff0OD9vu67Bmu40EVpee4Oe3MMSgl/3d+nMxKFvfR4niHbiDSJ/bauS1HF9EpNFJpmjdHTkB/htGw1w54k7KZLrDiQ4L012ZY6Ns3WacI4sJuKdlJV0yrMNECiIfiCnYVimMgeWQ8YhOsc4DZppVbtAOmNsyWRmUTd2Fydeh0bh+TxAJ9azExbLLENTwqNoaP2vAUESh+2wPg7noOAyYwgia/vme0sWUdXVcjk6GuU2X8OBe3QGTBb06Y2EuvUZdDHVg7aY3FmAQnTsbfsc/MjSCRHTfghax6RlD6prAHAsOQhYi6565eDLp6rHENGcoMTp5QZQt1WqXRYicNRNzqrYJbyhz5/QIxkyUEUEZ6ZOZTTH7btN8eFCrgwZmBX75MGbTm7tjFs9Y/E2scEOzqoj19IK58WBhKJZxIUSixi5FMzCbpvg9qcsIMxwx6HPeis9Dzfp4rWJEqGr/K4RqC5LgaK4jBniliO8AC+lrkAB8oL3yXrCOhdiKWC7cQDY07/34+fVJIJA1M2427oH4dxv2xr/LSk2MUf/0jRLSNsqLgdZdj94wx0h/zB6bcULOkGB+OFG7ZK6NPSojT4AFERXHKMmFSRcQ6fHfhqUWm6GkS4CoZPbqgSXfjZ5nYO4gEW+SHJiJd+hiDXPB9zGgUzt2ioicUWnTHCNKt1ceYfmhFXE/NuyBXSJdhyIRuk9VLA0WaLME5mhnRyiiugmHUdlSr46yjMA0F8oY4pr2Jjwc71W4vljAwCSuK4zDM/JpIApr6VsjOtd+AyZMhwalr9vja0MjQYSHqlWzESldMKttFjDk1sEDg3Ed1CiBCJeuZsiGcX48qM8Q2FQ9ChFWNGsXvbAI605MMrsdEQ2xJxLUH1pglnmURO1ME6IckZZeoXLjq2mCDz5rrevhgW2fCZHYi37dCOvTO/rhg8r8DtTulCIivYkErVqSXERkGWmtNOuvbCWrUgMDnDaEX9GHqElefIxZ99t3eGCwQ2SsO6rRWddGwqR9JVzkH8hnnawSUqpcCJ9NpqY5tQ/eB9ZWqkN0B06SFudEUgop0XMTzDEeAxtGeZSBWjWiQnqetGTqZ8fAjTl2Mkvyly+wJGffFLkDXYiOQfWOuHlf8kZFTd9xyuzRuiMGEYZEVt1/GQZMDCVh9uDuM3EfCrqbDHPTpmIWX7KPJ8yFl8POufsRGJSqYX8moc3UL8tPOAhzqc8REXWogAJX5Y3xO2EBw9lpWEYyrIMldL0GePCrO1uYxXd+Cwzmek3FMsWG5YjWM4ShBXG6fnYBzxJ9G0wEjmxBwvDeCDw3fnVoJIhotFCZFTIDLjWZT0TEdQRxwJyD7UADOmC/62qi9scGk4e2K4O1sqv38aBSS2Yz9cuwRW1gLp5sSklJuNnGvsDDJiepbTWYh7DvM9JayDQrmKDXlIbKA2gjMW9atB4DN6ZOOZa0pTUri4hN66W4GI6SVr0OJIhqQxbSzQsYvHV8hd97q+bKzHadPdb1u3kikrboJHZddK2Eh4hddXy/m8hzcmwq1t0rtcBMIY4oLy4mHJPqM5T8j/FtSEcAsZqvb4LPvm1p3JRLO6B4zQGSsW6dgfBoaIwJzDEew5B+SCyuN0apY8HaJV/fwUOp63BSziBBKhMMq0Nadx+/wvU6+xgGzFmKosLsO8KUV3dnMKvtHKRbxWYElhrY4VjBEp9r1v3CJLP33iDiVYXwO2EqpnefY7BVVOUT5EhEvwoQrwvmYRK4azbMsYAhvcZakURG+rg3/i6z5VZzh7Kb4/fxnPjL+Aag1wVDGJhN+eX9hGieE9fhUz8MGBgSsWEVeuz86tBIEHFUVd9i5Q3Gk3iZjHDQ2VXYCld/MkaKR5xRqGcL0ZkPicSspX1ZPAymtsDF1XW+8vAeZI+QNNswmOnX0Ym4YR67h1GhuiVRRKRgWdw0GBfjYhQ+wA+J8qRtOeXBH3wT30emzPhoTCMlDh1S1098g6gOU6wc5IMLNT/Rv8hMHArve2KvuN8t5GJUMVCiImvPYnDgRsTBGrkGwtxD0uI3jVhQ67HWVVIDr9kdDdgqmSCKw9wuHz9UZmjMOfbANYSfLTrh4bV9NXZnhG/B7OnaE3y+3nxAPgVractLnD3LFcQAQS3pPHEHPiORiQQluoXPcMgsTD46EyQitgwG882ILHFrIsm/1xeDjcyZiK+NShfBLQRLmUyASjLgs8/g91WrkK/gdQXXQ0HSdVShAB5KNxciyZHQE6RxA/TJMa6t7LBJjMM9uKQN3puEeNw3mQ+J+UhMNGP9EP3ZdhmTI6v2U2GOEXCZPkOrRcpk+W1sFLzGoBx2mDx9hM8m69iwckSiPXMxrdwK0RQmI84UK1uShOFXx2/hRLC6NmvnTEzEiLJmH2SjXvNEu112ALMae/QzXIT1nBA2K0paPNXtofP2YYuby2IsyZStUwnmmNtnc3O8oS13os48E1uKJchGGPHJsCN1RjVPgPmaZCVqh1fvIJzNRL+mExtp56OYxVmXQHSqN0FT5h3H300iim9LiDrnvVvK8sjSsQgZlhuKHh4bx+FnqGioA3Nl+qGbaHVLDCwqExnlTOS+VimMZYk4Egi+Tlbe69tPcQMuXwRLgzN3T4Y51jlTqDY+hy7LCAGRKCVO2YdEust7UWxLLUokgpD2st7YEWDQC1uorYbjfXAPRSTm4gnkOvS1Rr6SHyF0dq+EqFNOHfz8YQQlnOIapviZGWEFjEAo3Kk07pvMkC/5NQZCO/fgZ2Vy1i1WIneCWdfPIms4xBPJgGYGyoP/NHEd3XkVA6bDJIgwtsZnbusGzLrZocw4BsOdMThmAaPtNNzXbVsq0Z4BRDCs4wJEjes2JA6rN3A/CPZGwiwTh2JcjAY9sROHBSCDd2MLuQdxlP2R8Vs4EcxGepIPvnlmBd7UGQ/CpiQrnNMV4buRC1EgiEHwI0kP/BI7rKd7qCJZd+IJ0vgOLga1cZeISIURiMSULINBxHpi+62WAhYRKUNMXe4SZjAjkT5TwXLVy2PEWroQbnKzXPAz1GyBzqY3iIxuKQPMOse4YLfLguL43XUl9WnmbLmfbMJq4ieT3/74ETORj4Sod5ioWIYuRZKXGeHOMGGpTFUxo2akTC/SHvxXRuXSZSJd5QhJlxlwLRyC97D1CKzFrz6IhwjzOnEla2mXOWbxdsR58vQ0ZX1e3WYtkn4PD9YR0ncLCs1ZqUpDIiL+47HUyrguWYi3hcsehK/VHAu3tYHwmhyEuLppzhqYq7MWD+5m5riGU54jh2e4LwZ4jNdSezSSwwsVxYCmBOE2qBELuyGYGMoH/C5Zhp1w3wTm8pEEh/lTuLbEEh/rADEj66RbJxTu2zBXSXKttRiT26RQPIO2L8YuDkaO9CNoEtNDatAf+S9MnXNmU0TXrbtgUPKrQcS/1uLJSheVa2B9Mh+psTONifXsQCctmEy3Pb0tnodVG0k2sshPRWF2fuMpwt7dKuGBwcoD5QzxgZ4xDxf0gmkIfZXIh9Afcw9VEytdCHGz6WLsfqhRFjeqIjq4ic5ahgupQg3MzoMIa3uCH6I9G3cgKbFSdey60SPPjroT5TQR/Rpc2wTmuhES6XKSnbGOBeaToRaHEuGSxueIuRLLxjdfUBLaFhP59W7EJXZRGzzgWTsn41hMWI/XY2WvSQ74N5oRs7kTBE102a08gDf3RSLoJvIdWRJy8BsirczaTw+Tg6VHVQxmjeqOgLnKDhhEXj6FB7W6BfUtKQMVIT4klQZth7mDc9rA3PMUROZ8ruLnCo8gsuek62T5NDyozu9DfgIrN6gDFU839MlgKBTrphg+FA9HKhn9MhnmjixBoarMpCZz7jEmveOdkFiqNhJ7Fopmecw588QdvA9DCPqTFI5BtWTG/ZsFDFEPkmEu+gLuYYw78Ue0eKpHvgK4oJlOBIPRGTehOxG+OfUQD/3XL/HwZtoRBqTsMYdI1Taco+xHb07aRUcTS19Wn771BIOoOYTkVGk4GiTlLoKsaKYncT4Wa9asBfXFG9xw1OMgyeqbL8FFM6IfQnoZh2HJIF8OfNTarcfa7nEfvNcGpfHefCSZN+NnDPdQlto61sd7uJXUTplOhEUIZuLGxfFwPOeKhK4+BE1iviujEt/AnHUJzOLVbpwfiMXiUGt8NsftxwMu8hJmzhmJ3LQFaaNj6Nek1bhBZhyEPetqvoqIyIDmStIv4xdtWIAb/MQDyKbPTyTErz7ENZI/J+4HzMV2uwe2/TlMx9Lo8AH4/DcYpTxIL63GzLnbBgyWT7ii/Hi7hQiZh7kiR+zATUxwvAch+jvZHwP3hLNLYC78AX530w5hIAwS/0RN8j6RJGcjlpD0983Az8rKD8nvcZ/r0AMzcbUSpYiIvMWz6Vm48lBmqpOGLfD6jNfiuxSloGb64bmRm6jf7uqFKEmZMcgblJcYHLFW6F8df5wB181TGD0xYaW9A/DwWn0mCuZ8z2HLINNiOBSAh4a63bQ08f+4TloSZ5F2RuYSWlQXo/gpAbigpzZCOL/nJtxwThElO6YKmT238vO3a4UZNis/sM6JI5EI8dc3xUNPXRoSEXEkhxJr3WSmSa0XYrDBxJtiopTv7/oKJDOW6IG9+P1743dZTA8X9Exi3R44Gzc55nY5lNQna5kiyW2xLx7y2bMrN+rIA3vhNUzi+T0hkbn440HAympGevhM6HfeCHOTB6GQEPPOuRiLcPv07crvJCUF771LDyQ4u5/Cjhg9oog53hpRyHWXcA3vPYL8mlbEvrpXFVwTjLx3ysdZ8fMe4qa47wx+BibKxCBuprvw5gN+d6zsxVRBB4zdBHNDRiPq0pqUqRoPU/6u+yxETfuOwH0p+iB+b8b2iIhkzq0Dc+3b4DMRcAKD/gi3NjCn3xBdbI9vxpKRWrxs6iHcqysTYrTbdPysCafnwxzjtRRvtwDmmHeG/2bkhHRbhklffdJW/kdwItTlBnW3hojITnLYuu5CDfC9bo4wZ5ATYerDRI99Ccn2/FTqaSIi+2/j7yLtS8RQ1aO+vjN2RPiSvv4DVxC+YvbgTOI7Z14MLFaSjoWtpN/fsCeSy6YMRYJg/CvlplGeSPduJEJYx29hZtO8HG4irGW0DlEdbeqKgcBgou0/fiYSH1lg+SAKDyWPicoaO+t/r9kQ+TVniCdAo1aIHB2ZgdBinbFYzts4Huu9bMzdGgZzegWQIFncWEc50RLRD7t+S2AuZwksNbCgJztRJ+1J1hez+GYHlS7pMHmQhFnm/lFKBGzDRdw3dhMPmzmkJMcCt3xE/+L2ftyUj0whao8qqXERkYn1UYK5cidED24mKHlC70i3zu0LiBKJ4F46kZh3MZlupsPSbyMmHzWJ7sKd3XgolWiEB2sLIpCla6xETksQ7Z/4o2j7XaAZljgyGyAKy7QjGP+BtWTrN54Oc1IA/0bHJbg3qQ9gs0KIuLOAIXQ3/k09C+yISgjFtmo20issxUiZrI30V8e/hkTEEfiKeWfkIoco88R4RLgIlnWQDMhsvy1tEapn4joH/cIVP3fugDCSD1H7694egw1P3zCYY94ZTHVz8SlsS2TcCYa6eBMGcSs3pQZEvyb4vV18iDDyXUKYjCf3VZ39i4jEeWB9kqEkBkVx4ZsWwzq2E2mtLF8Ys3jjZspNrnU/VD+drNLNEBF5/BLJZqO3hcEcs7jePBMP9Jcko2atdX6kfsr4NGo3RtYl8nQbtku/eIvZDkOTahLthCBiI962HGbirBTwKBm/z6K6GLy2UT2btkTV1usgIjMrBuJzfo1wqQbVwkwsKh5LSEO9w2BuoR1mbNZD0LytV79mMPdJBSOzEsqCZcjpcpmIXBpWr1c7TP79RxF12roJu3PKFcTnME92fH9qXxMRkXOPcA+PVenkLCdE05NE4GoSKauwcnHdcRikM6MuO3cslwZv8oa54dOxnTP4GhJ6JzVX7jl6hODJSI/M1yR/RUT6mD36tlHWMFe1qA7M7b2OPKG+gzEoYQJUliUQPfmRoREkIlRlJKQ25BIRib6HGxDjMDDkoL8nljiOTMc+40n++LCOH9MG5gzzYMBwOQbfi+9MZYbGBLMakBtQg2zAlYlmfbF+qDs/uAsJVHYhZF6aIAzMMtzcHpnsahlt1lZ57BZ+593r4PWtiXhRZ8J1OHQTF2XpKggtRxOy3bL21jDHsv3QRZgB9h+n3Fz2HMdDfyYJepNJCynr/th3Ez9DCV3MvO4kYVBmkh+fiZ3uGDCu24MZ6tL+SiTKyAwP81qzUKjm0GgksxbPiwFpMxesu8dFY7BhSJAYhhzOIgfErFbY+tZTJQblWA0JjhkJnF9aH7PCknp4H1jXzXUiEJSRZPHWIzFQk6dRMHWKED9Xq4zfWKY7ZCCiOiV18d4wmeoFs/AQZeZwJch3MvMIEdEi6rfse/fciJ0t6oAmsxEG/CVsEXVIOI7oxNVoTFyY1DYTm2IupsyUTId08bQi7ew5MimPy3bzMUFlIlKs/bQM8etxJ50u5h3QMIyVMzoM6wJzrQdiZ2JFI3x2fnVoBIm4q3pYexBW+LBGmO16hqJkqjogEeGdHcw7g7WWugXjprysLWYUL0mGpu72YJ0e8wZje1zVghhYHCFB1Oq9GPQ4tsAF1460gjJOhDrbEeEESbXwzShySOUgzpHMdXEMIZuW6IQtTXeJ/oUviZ6ZnwgLjvZdQiGdJhWwBW10PeWhdJ90zmQgm6PFKCS4rh6LgRvrAIhKRP4PI9a2LIcBmAGRb2Y99Wo3zuF1MGNjiOAMYtPeg/iwOO/EZ4KhAi1K4GdoPxf73W8uQwTIuIs7zKlLS3eITC8TkbIn3JRNPbCrhZmN1e6MjooM4mYGbEVIqXHcljCYUxOBdxLdGCbJPbcT7lUmhEt1NxFRF0b6NDHHe33/kB/MOU7CVtgQIl5lSUoGM1Sunaz84rkKk4DAdaim+JrsuTWLYzKn1waz7vymeA+ZiBbz52Alkw7dlIRZ71VYZn16ZDrM6dciKpGZ8bmhuhajcd1cJmXb7cRh1bABCnDpVsQyeOyaX7MH1wgScTdB+QAfIE6EamlsEV7OYAFDw8bIJ3hAIMgQ0r535hRmnkKCCObPoR6sNVQnG0axuYh09YMkPFj62jLJXNz4c2TB+vT1YAzUTq3Fha8OGEQwaPDfi5vXrNGYFZXNT3xNCBM/S37CEyFqkrlI3T0zaZm8TjpMVnREHsPVpxihqyWte1TDjP3Bc8zYnAfhJn8uGp/NXYRc5T8J+Q+jiCtqhQI6MLfwJOpfXCL8jKexyoB5NAnmCudFTsDAurixqg2TRESiT+F6HT0ZgygWuBYyQiQuhJQfjyzETKmaqTIAf/YSEaHlhEB9eQcGfU1i8HMdJkJozOuCtd9OWIzoTKmKJjB3djoGG2pvi+HeuJZqlsdkgZmvMenmcZ7hMPc5EZO0AgUwSXlUAqH1W4+SYW4taatXy3mLiOxQ6ZocPYOJAZOkZqUheYUH5rQZPWCuZDVEtdw6I9lyPAloUiOIARfhJ6hdNlk753lywEs+DLQkN3ZiWDXBPW0rKd3N7Yn3i5FtWcBA20jlDwgi1EJSzDvj1XM8CJiKZb48uMk1Jb7wTBOCeUcweeylIVEwF3MFmfLqUkjcS0QrrIjSJdMYOHUYSWk2rVF5LyoGD0LG2pYE5D+EPU2GuSd3cRO2r6rcrAbUxmi3swvaLR+bidD1tUt46PlMJ90J5ECbeRQ36lQiI76oNbYbpn7Aw4tlY1WNlfBdhynYxTBmAHZiDKyJzyGzri5OMvEzpE7sRTIFo6ZISjNrYA1zrIyyOlT5TGQi/e+fCBKx4BBC12y9Mk8IZgQWFoObpiNBHVlpoUoLhHlrOnZW/MzIzKX18VnKXgY3zLhIfDZTPljDXHW76TDHjJQuE+E6xqhfQITQkvYqs9HoBEyCnhLPHcYTKG+ISMQa0vbXPBKDiL5W+FwfyIfclIP+6E9idwMRsWb1kU/ktVlZRnvqiyhkEunM83bHtRl7CNcI02ZpaIqH8sMX+B2zrhurvlgKYgZcG9aMVPzMlIQ3XMB92W8FJne9VmHyxYiawT64Dzt54rHd9wwGPcc9kWy5KhQT4V8dGgkisqky70PjrOE13tcQumbmUMnEFXHqeoTuLy1sA3Ns8Q4ijHKbqhgZ3t81AuYyqlp6GGGMZWLZCXJQsjJ2HUxrjHMdV6BZzbnpmNkmEpVBpu7nthV9TIJmKYOBg0SJkZk3HSCvC55PeAiEw2JQADe+4374OhZYZSPeGdWcMIjUJ8I3G1XZ07X2eNgwG22TfFi6mW6PiFhVQyxdLT6F1/M6h9nOzX3YWlba1hnmZhORr9aqwLrOKCSMtWhVCeYeP0Y05cl9PGwYdF9pJIqeMbXLACJyxNqDg3ejeNFC1Rou2wwDDWaZnYfYqu+ajGhajRH4PfWaiOqcrUvhoWRH0EpbSxOYc1uCh6FF4a6Kn5uUwnuaQFCXdmUx0apTHNGJ96Tbo0snXEsTN+Kae3YX982Q1ehN85qQg21n4jrUM1WW1lwD78JrHhCVTO9lSHA0bIXZviTiWSI6+D2Vro/P5tUFSFQ1bIpcjCxGGByV11cmJAXakm6KBFxLQ7ci0jWreyWY23IOfzchAAMBsyFYCmIk2t2kjXjPvjD83T+hxVNdvqjtjNFTDkJeYQqIh8iG/vwRtgyyLEsnOx42V04hzNe7vgnM3YhF6NP7uvImMMMgZ9Iy4zEKyWtMCIoN1hdfcjBCtTVrYg28njluLqXJ5q2G/acuR5JXnKcjzMUQvw7fG1imsCE22j2JJgQ2OYkkESdO3RqYybDMkwWvapJnBbIBM2fHIVOQ9Oq72BHm7Negep5Hb4IwJeHfPUaUEm16IbR4nMDBavY8c7vsSoLl+a0Q1ak4FA9WVutn7pkVCiA6deooHizvOuBG5XMTN7kElZ5Mu5HYQtnVDUstl10Q/WKci9VTiSgTMSpjnTisFbJiIQxcqzbBTpHmZZW/u4u0vDMeyq6heBCygKHyBOQ17BmDCJvngk0w95cRPhOOhJ9xOxgTnPt7ke3/UIWy5CL8qoYzsKneez52azH59b3r8BBlGhbtS+P5wlAM/3UjYI6KV6nRExIwsOx/xTlcv25tsPxiXQzb5RnSlRSJ6BQz7zpNyqAxm7rC3K+O39LiyWSqWSb6mNT2WLDBlC0LF8bM4x0RJbKrgQda6P1kmGP21cOdlRlF/37YOdK8JB4OjJ0+whc34LN+aHHN2k+blceHa8o8zHZOrcIFdzcZvzu1LDcr0wSQttJqFXETndUMYW+DvJjFJ77Cv8GQkzP3MdhinID61TEoGV8PeQFbVCJX9iSoekBUIpkDIoORcxLUqUsV7CgwGYgkrKPTsRVwx1X8u8NJm5taea4p4Rzdvozlou2z0WyKdSx0JRlm8TL4nZc1w3XDSLl6pIWakUHjVZB+3CtE/7oTxcbQ+UiYu/YYn6Uh7ohqhszAdc1aHEuNxDWXEEukpdfgRl15iDIoXUl0Q5iuQyMzzLCfEeG+V+9x77PqhZ1ZR9ai3wNTMQy4ixyWtV6YMJUqj/vrQhXnrEEHVPrMWZEYEjbBYMZ7BQbz8g73NKaw+Z6URhl34Abxtem+FpMDE1VrZbAXBm4MwUi5h6VyxlfISBBXxn/oOw71Spg6JdOnqDMG0cQX27FJ4UeGRoKIarOUi5rVWMsQo56WzFqXCMkwtUu76ngYnI7E+qz/bjyoS9dAWLqjJdYK1eWWJoTD4XER+QpMHKldd9yo3hP9/GgCN78kn/9+EKIH13xxsQaQEsSdZ8r7w9oeg6chnM1q4nbL8fvdORCldb2uYNRuRyBdN8JXaWyOrGW2uTZwxcNFfcjlJofDbcJDYZ0e6w5gPXVVH0QdShXE+j9DHZiPg0VfzJ4lKwYvlo2UG/W8lrgBPyelwRbjdsLcXQ8MPlnHCssoC9QeAXNjZuNBtcAFPSAubR0FcxcfK9fwymMItfdvgMFHw+J4v2pOxu4Eh+YoSrRyM2bYO6Y1hzn/O7hRb5i5Aub2knKLYR7lXmI1AY3QChhiQrKePV+F8PlipdxaRphoGebCEjIjR5r0R3Qqei1m+/12ok7OLh9lsBGzBYmQ4UR+3KbPEphjLqGNp+HhnZ18Lqa70LoJsVWoiIhdOfKd2KpQx5ukRL+SlPe6jEJVV9amGb4Xn5skknw1ccJnJyUSEXeGTpwJxj3sV4MIjZQz1AqVhbtjpMSIlWy0roibAZOMZtn+bGIkVLYWKvSNa4kMZWaatVkl3nTibjK8Zixhxc8iXhczmiD/YROR22WZ/YEIzNhXpeAC2X4VD2rmvFmhvnJjCpyKWRFz4lx7FgMmteiRCG+P1C2A3IF+Fvg9HQ7G+inzGIl7gYFqw2qYKavt4UdYIenvKKkdMilghsTEvcX3US4D9mKbE+2IUXswQ6naEAmYJgVxQ7NQGU51I5mTuoNDROTUUuwnj3uOQWr0C1wPIzZgPX3B0pEwd5IE8xE+6LJp3mszzAUvVsqSj2mKmV3Se9xYS7TEujYjqTKIu/ti3Gy3XsED4hppIfffPhPmZhDp+liVffNpF+xOKEBE9dRdHSIi8gTXSNfx6MXABM5eEsRCrx26bEZvxevpd8V9PXYzkhLVBMnC3fA+2xPhPsmFe0TObJidFy5KyMxTsOtm7AG8DxsWoRlYOHEPvbwLD2pJVa712NPpc+c8vgbdORlfoWLnJTDHDLNqWuJZcjU3JhrBHog6MD2JXx0aCSLU7ZuFiuJCveCMmfjWS8h1WLIPI6WjpNathj1FRDq1qQRz0xoTeInUFHWyYoYa/1q54ArkxK+r9iR8aM66ILTKOkImN8BafOJrJFe5bEYYcfs4NPmJJKWLxkSo6dgR5eGV8BJboSb5YPklM4Hb2tVB6H7WIeTEDO2P2W7xLrh5NbDFejITg/EjLaMeu5BE2rypsva4j2QPPcZthbn4/WNgbiyBwm/dxU6M501xo15/BDNFHR0MhNl3bJofg2jb0sqAZvwCFP0JcXOAOXZQleiM2bRlC0STlvRCaLUYEUNiaqenHyA8Po0Ytc1VoWJPk7DUVNqYHDZEzjvyIK5NeyIidoh4zkQRJdaw83gPm5/C/WpwT8xG6zVUBq9Mw4O5hA6fjRoDvkFYavT0RJ+ECescYY7tLwamGHwP8kGEITUOa/s+VzERUiNM7JmzXYnoz/FlqLBasT1qeDBRqktRyTDXoQwmpPuIUiQLGJi1eBsVmZmVRp4T4bK7z3FfnkT2/uWz8HdPk/2FdWwErh0Mc3auMCVxRDn2V8e/xolgJQ7zEgjfsdJFJPHJeP4AFxLTSZh9DFvamNkWE69SExqnEcJcZpKJT1iBEH+JMlh+MSawJHNFZKWWGUtQ0OfscqzF+t5CFEPNgZhJUJLLjzCbnH8MM6CnZLOdbIeQMetiKGeDUfb1AGRj+97Ag3/mGvyOx/XGg09tS96OdGeMt0Z0gtXwK4zAyH6gPW5KrNvDow8GR7q5MDjqQdqD21VHuLVZCeUGOTUAD7O9S9BYrOvEATDXj/BLOpJOhPPO2O1gNQdV+1jHApMRvhwUBnMbZim7fVjgto4IvH34jInB7mtYQvJahmWVpCDsEgkhuh7ORKgrgrQ9Jl3GA3L7emVQWoo4HbNOrxoE1buxCltNY0i3wx2iuTPFIwzmPAkE33sdEisfkpbRz8Shc7WzsmWcSaNfJNbVWQknpJQh7pFzSPm1R2X8G9W7LoY5RgTNkx2TQ2KKC67DBjpYQmECVMsXYqfLJaKQvO8Ycpie3SR+KqQUEnEQEbELDxE5C47C313SGpHeHxn/mncGI1GaEK8D5nWhht9FuBV0TuLieCEEb0ztemhb52sAAE9eSURBVHjIvSX145ZVlJv3oasYzOTPi9mkeycUDakxHSWIDxKjsmNE9vlGHG4QazYikc60jAnMjW6DD4ilsZInwMoljUwRMmTOmS8SsewRu7EzzF1/hK8rSjJsJ2ItbFUMnxPdLHivq5IMdeRe5SLcfxADSLVJl4jI1F24eD+RnWVAM0S62PO/2AfN5k5MwUyceWBcW43fp9oVlZWGGLHw6RsM0ll3wl4fLI94z8HOkRGbEP1xIq2wTFhrN5FCX7NT2ZL98j4e3MyLoOtwRF08N+Necn4tdns8I+gEyzIzEy0OdgA1noWo0F+q6x1zwmfuOdFOKEQOqo7ueG9GNMHMtnR+DFSYDw8LmJevQD5JxFaE5c1bYwDm567spmKW3I5z8TtKvYMBdK8pGPS6kPIms3hnAchwos7LsvOLofg9ZcqsvNdhC7EkZVoPy3sMTWJGXUyxkrV4Mqdj8+F7YI4JS02ZjWWqyQ1/TTtCI+WMRypJX9ZhkZtIJluY6sDcAOLi6bQHN2Cmdsl8N6xIENHXEiF483z4wI3Zp3zgGCnvGdGOYP3e0Zfx8Brmi4ce44Rs24u/e90dkZNqozBTLpwTNyG1L8LlOdglMP0wQXAmYt3RdjHCqJbzkODoQJQSe+TH+8BQkXPkXjOb40YLMMiJuqNEMdT27iIim4n8+qZeBHXKhAdLS9dAmGOqiP3mIxmQ+YkELUDdDYuxe2BOrQrZlIieeVxEBKd+SXzmouMwY3XsgW3KF0gbdOVy+LzWIwHoW2LeNLi2CcwtcN6k+Nl96UB4TSKRqA97hElK6BoMGJiqaV3i/9JkfiDMsbLqPYLEfSIJTpfmyrIaQ4727UNNm1UkwJ3TGoM0m84I8UccQTzba80emOs1DMXmJAOW1fbfxBIilXnuuEbx8/ABGCzTQTxB8pEgTY0IiIgE70f0J39x5KttHoJdIRameHiPJL42fVRt6qbdkTA5ZcEImIuIw5Kcml8hwn032Kg8BdtjqRIl0Y6YNQeJ1ZMboo7Fj4x/DYlgZYo3JPJmwYZNReRYMMfKwvpYn2XIRlkrJK+xv5tJBa+FBKEEafMWiDqcPI2109OzsZ++KTmA/Mbg5v2KtK42dsJ6L3MPZQHI3AFKaP1sFB4Ozs2QfMq6Myb44XeyhPRAV5scAHNxD/CQi9iATG59UlNl3AZGfFVrezCpbeZX8Z4sQFb/N9LDII25HZYehK1qxsXxuWauoIzk5nFJSXJtXgIP895E9OvyCZxrbW8Nc3NIF8NCksWOtcLg6Ew0Bn3sO24xGrko3i5KYiVre7yVgAFDPuY6Sdj5I+ZjPZmR/IbWMoG5tksQ/ctO/u59f6yxD3FWqqLsOxkFr7k4E5OgBUH4PLRXaU6IiHRZi4cI0ytpOBU7G9aOxD2ny4h1MMecQoN3IYyeV5VEVmyLaEVCIBpmhd7DEirTBLm5CDlnzOL7yAZEBQ6R1tVNBzBJZdyGNraVFD8ProGJUclCuEfcisUgffphDCIrm2CATxELEuBJToLWmiFiM7gj6rX8KhKhkSAi+a1ysTKfjDntMHq2m4oHYchCjIqbOmPkxSzDuxJIjxFultghCYtl8Wr4ajkxzWG1ftYlERKJ9alnpI7JhLDqkUzpfgJmQNef4cO6NSgK5lpYKCPqZ0TQZNMa3GwY52QU0b/Y3B15ApZOGETMJkS9YYsCYa5Vc3zwmRV6S9KCq874ehHdkHvJmCn4XsSsqysxqspBiJCJJDgOJO2BW7pi0HeT9KxvDsPnac16JdrD9B96LwyEucrVTGDOiGRdTOCqCHEATCTP8OGx1jD3mEDGrGVU/VkHEfnx7OQ7V1u+i4j8VRC5LgbG+IzkInB+wlO8DzuJeNPTN5hR5iMW0eq2zBG+2JmzqDUG30xqPfoolhqO70Akgnn4MIL3XFIeYARMtxB8Ji7fwVLYtUvKv5H6MhlewwyoOnRE3hA7qFlLah3CzbkdigmU32JEcFv0xS6LIeOxi0FNhmTunAxhcF+HPIy+Y0jbJwkOWDmDWZzfINycG0SdU98ar/f2LFEF/YHxrwURjFhZsCAeBIxEyazFq5jowByz+F5/Igrm7hPtBGYtfuqhMqM6SIhatc0QCpuzGiH+7vZI6GPtoYxEmEoQgJ2ncEHf3ItiOHs9UTuiuJ7ye78YixnA+M0IrYbORGKdcTskL1nYoAGbV0/M9ladxc+wYisS6aytERWZ2wIz5UOReF/vJSgRsBOX8EBmImVBxGyqMYG4Hz/ErNu2GR4G7FBm0rebzyDCNro+HoZqLQqW/dsRYS2D7uhYmPIAW+GWL8aAkelaMP8TJud+mwS4FsZIrH6jaktkpcEV5LkZSQS5vMnG2olk8Vfik2FuMmlnNTbBz3/5FNbYmbGYk8pIaXM3DKDH7ceM+PR5bKu+PA9RTRciLb18FSZf7PDu2hnXqx8h+THCqPcG1HFQW2bnzIzBTP1xSBj9TGzVL+3Ag7oIsUtgRE2bAdh1JNnwzInfMwLmjt3GveSwqnV5yw7cq4oUQ3SRIVOsPZRJfHfojQqr3ksRwbPqjnwl376IRDFuWnXTX7MH1wgnYqdKwnVHP4wo2UG19Cg++Iec8KBiimozCByUjRzotUibD7OWZnyHEvmUGVrzciiOxWSvx/ZFxOL8ffz87VfhomTW3ayMsPEQwpxhfnNhLjfJRjaqBLKYc6ieHpIeyw5HtObxXhQMqjcvEOaYOqXXUfwM799h2WsRKY+8fEtKPEQ29ogoA79oYx14TQ8LPGzVvikiIjFRmHUFz0NolfEkDIgAVfuKBNnIhNmI3WSila9ixW9wQfJln+0oQJNKNBYchuKhN2QWIlGMWMkGM0dbdRIP/mE3EILX1VOuOR/SOXCPSMjPD8K95DFRIl3liX+TBVFDJmLGOpRwOMxJeajNbDy8c6t0QuaewPdrQ1Rzr0TgM3fhAe4lHYmFQItF2K3lTdRfN8zCVmshKI6fB2axTNm1XnEdxc8s644PwOQmjHSmgdS0iAzyxue6Rgn87pi1uLXjQphjebQP8X85EYLlPPW4MAM5LG8IRyq9KMZRUs6KPT4H5uzJOaRXFxEQVvZ4e+zXOBEaCSLWHlVyAFyTMaLOQuSBQ5yQcFNqGG6YzIvCqABGlAcuYRbvUAsDBktiVaxmu4uIdKuk3OR9b+CCZtblZYgRlJUxBjh5iY0407BgQURSPG6ku67j549/hYftXlXWUr40Hr73InBzmEda67qQlkTbWkiYVHeEiPBAJeYmfp+lm+CCm7UI/TSamuHn2HRcufCDxyMkXW4cHphJ8bhRbyRSxdUHYzfF8klIVB3qgt05ia+wJdXzAt5DpvewUqXHP9QN0a/XicSWmEgGdyyPB9DhIpixM67TAXfMKOe3QmOx4daIFFQjZa9DqmDT/TyuS3uSBMS+wMPm8g08CBgPZfxofCZM8uAa3haGKFH4JkRsmNzyENXBt5g407KgjwVRU0kCNZhwOJjolastBuT7auEhd8YZkVk10VxEZO8KzIqvt1cF1h/w3pBGF2ncbzlOJmPQc9wb+RTuF/A5YSNzYSx5tyXtrMx1t6EqoGPlAmaOdX0xdnFEH0P9C+M2SIRlhMnhe/AzOJJSa/B+fNatWiHq9KvjP1rOYBwGVpJgLp72LZFjwYxpzPIjfPeOvK4lIaZlUwU+R4l08Xoiy/soCsk7TRogJH/6Im5Ka/ohBMW6U67sQlTAxW0EzLU0x8NA7eORPw9+R4WJEFLwTfz83evghl5JXwfmOhPrW9axkiEvBhutWlaCudk2WMftQxxb/VXmcDWIOVwR0goW/QiDtGY1MDhipmwMCj/ljIFFtdF7YI4x+1eQIPpBknI9lSQBWbmCmHW8fodkw6HeYTA3lihFTvTC+zW9I67DS7EYqAwhhxyzEe8yR6l/cno+cj0Y0hN3Hw+RwMWIzliPRoJr9Bbs4jC2R6XII0tQndGL6F9s9MRnXSe/juLnKwsRwQogrdZFcuF9temF2XToDkQJmMhTNxL0MxT2CeFcmRXRgbnORMW1gqp1n7WuLiIkXadG+MzFke43llQ16IuOmvnLIpfq2WlsLc1sjnsuU+JMVa3Nfjsx6BtIODyMc8EEs1jrZvsNePYFb0JJctYeyvQkRBcDi7f+SED9kfFbFCvTy39QZ/oiIhUGoxjMRmLpW1wHr8d6uxkpkyEbbCGpIfh4QkBkAcMHIpn84g3WdvVJN8kEbyQqMlXIKiUxA1LX/0VENl7EzVXtWWJMHCDLGeIBdInAqPFE2z1MkmFu30gs01iMwqCEaTawroh60/G+JjxC9CSyvXIjSSWM/eP7sO8+ZCWq59XujNnDJW+EApsQae1LRLzrArGzZ9oOjguQXJcrr/I7YYJBfbdhUOXeGdVJF7fDzZbJIweQzqEWizFhODQaXzebwPfssP0cpdyYn73C+n/cTewISjqItfnOm/HAnDUS0aQqExGJqlyvEsyZk5JUV1L2ykEUK5evU7Yfs4CBuXh6kNKwZMEAn8l03yWif5FEAZGJiHUgbZQpZO3YDcDDu11/ZZvyckKqX0xIpAXaLIG5zHkRNX6yBQ94y3a4b/QiCU5Lgh7svoY8KWZoBhoQhF9y+gxm+i5zcS+pNYsQQU8h6sA4EbGByJ0YdwDXRPQzDASZFPavDo0gEQX7KlW6GBGSmW2pyyAiItlIDX9Fx0owV7QAHnzMsyMn0RT3HIvwZTKpFVcrrIzuWAfHZKJEuGo/wo0MdWFB1DDS7TCzKWbdR+5haYW5k1Y1wWBAzYFYsGgPvCbMA2VUGXGRcQeYE+c6e2yFvUPcWS3HIRy4eizCray3n8SQoDKpZ4DdNIfG4aHHukmYUuJ6Arcf2ENkyp0x86xRFDdIlimuIDbaakSh9gBsybNoghlWGSLI1YVYXDOBoDgiVDVk5BqYC/ZEn4xexFp650DccG/GK4lfCw6hXsnaLtjVUt12MsyVbInfuRsJosbvxjXHuFTqMqCIyPQueG+aE/Sv+hTl83RhNiJTd+Nw0++5Hg8WpgjKZLqZS+oG4tfDZOUp/8NxA8xlzoH7q7obo1cfPODfkkOaBRssOx+8GztbmI14/FkMcKxcMCDPSwQDexMtIUOV5k7LyUhk/5yMwSFz2GTcBKsO2OJ7NRwDHFbiyF8N19IVVwxADJsiAvL2JLbp/sj4j1qBR9zBqJh5bDSYjyJCN88glGTTHhUgJzdEiIyZFTFr6YqFlIEK65IYMwOhpYjtSOhxPoqbYWEdhBuZLbePHy4a5p0xl/wNlj3YVlFucuxzXYzGQKAScQWsThCLuUSoKioKM/G3r7Dtj5WpehJJ25oDkax1bSPqKailtTevR37FPqLYOLMplp+Y6BMzA2Iupp6kTbNALgyYe1U3gblMRFq90RIlB+LiKcxEzq9AOL/GCHxeWbnoeiQibIxYuo60PVYpQrwtsuBnLeqIQX/5akoUpywRAmIcjpjX+Cyx9ttm5vi7Jn2Q19KvMwZg7FBefiYK5soZYILToLgyiWIQPys/PCaobtbMSCi4+RRZ9yzA79Af7cHzV8bPmoMYHL4nqr4p7zDYTApVZdlGiDr4z+8Ec4wjVrsDHnpHtmLAyD7rbcJXK6WLexhLSB8mICl3marD6vgpTIKZgm9qDJIjrRwQYaMoQXZEYRMOIymVBVv6LRA5rdwUSf8h4/Dc/JHxW4KIROKwePkcfpHWjfDhiiMRNZOzZm15dkQD4EESZk++AcgxuLUUa6/q4OUFMf2qWQl9DVjrprpdVETEaTV2Z1QkffzrO2PmFUla5rrOxyj7zDyE79SdMtuJJkIFEjBEJ+J99dkXBnMprzCIZD3Q/Xviw/uE6AkwhnpZYi2fTOSLa5ops/3eJFhkB5zvdTz0mVBR8TJ4vZQU5DVM6oBEOiak1KsPkquY8uAyVb+/fTnMfuNf4/OqrleLiBTviDXb+7tGwFxNJywh9bVFlGzxFkRiNpFgQ90KKCJSWCXznExKiDmIYJhFf8ySk/ZiMF96LJYuChEPm/VdkfTJOgVKkDLt6fsYgKnbAzcsRY+FrUvQY6FJKQx6NpyPgrk+NUxgzouQxesWxXUTSwIV22mo4dOpLe5Dnm7oiil5lH/jzjZENSf5I+nTkPCwth7E4Nh/IiZQYU+SYa7vwCUwp1sZM/YChDt0ex8ioiF7lN1vH4gMfjBpte5FkHmGCDD1T2aZ3rgbBgd6VTBxKUv2BGbe9Ud0Z6RH9rphY8ww40i0xxALFli0r41wk384Qkmh/nhQn12HeuwMSpzXQSlKxQyobMthJlp7NG4QzODrDlGYDCd2w2pCj4iIWX7c+CzrYC2eMeotjJTZXZ7MeL9YZud5GAPBjBlxQ0/ajVLF689FwRwTYGIaA7uICtyQ2oTtT1QxV3dUllHCY5PhNYww2I4oMe6cgdkDy7rPEpnu0cRjoj1RigvdS9T9iFaCTnbl9x5IXDKZSRlrZ4zYPxXm1F0SIiJzHbEUMGc3BuRT+6AmSocpCP3+lRG3H7XsdzjRcFjoi5+B2WMb90OJ3wwkcHO1w4OF+V+0bozoVK3nuA7nEyfinDmVa8xvFfpQZCDZ9NsURBJDicJs9YJ42IwnTpm0Y+cjBkfxu4fCHOMs3DmAIl+zVQZZDElb0RbPg4zkdXZEQG4WQVwP+mNJymEUqt/GkLZfJtTERos5ymeiO5EfZwqTU0jposNAFFV8RITbWMDQdRRyQjyX4bO+fQHeG0MSRPzq0AgSUW2WMgNmxMoyJHP06IaHKLMHZyJP1U1x865tpANzjKhYg/RUDyAZ6sbLymy0jAGKnIQ/xofSMA8eyrMWocqcpQ3CiJTgSaS7p03Anv1iRIRFzesQwaCEGXDtu4ToRMQNnOvbDrkOjlUQEcpOWnwzEBKDw0ZkI8cR87b7hzCjbDkUNw018jB+JwYMix0qwZy9Ky62LNkQEQuYjES9POQeMpVFr3B81reeRHGhfg0xoJnlpXyudw1H4ipT9htK6smty2Ag3GESQqsPt2G5KPguokQl9PBgZWJI4RG4rv1VpOcSPTfBaxi/xJi1ZF5FsuHgWpgVWs/E9lv7phjM9qqKz3VFR+SEMHno1W7KxMU9MApec+kMHo62thi4MXdWVv8fRlQxA07g3zg2DYmVCUSxsumkPTDnNwvbF9vPVXbYsI6jnERx+Fkotim7rxoBc4MXIuIaMBMR16iXmBj2GoWIlbEF7sOM0DrSR1lCd+uAe98UgrAwt8/VqgRVRESvAR76jETLPDZYU0FhR0+YS41C8u4foVipSe8MdrCkF3VgJY70+mkUroBR5avnyoewPBEH+kAWCHP2DArGLL5zayRluRPGuusIhIJrkuAg4S1+xxZEZe/sPSUCEP0SA6EaRJ2w/uT9MHdmfhuYOxWNm2huUjJoQHQdmLBYU9IyPLsD3q+9RMfDUuUAykhvah8KEZHBdbAkNXIvZt1OBE1gksF3EzEQYrLUzRqhEqfPLiRSZcmh3Jiur8AaM3N73OKIyqF/kQyY6aa0JnyC7uvwb2zrj9BqJ5IVVzDH4EWt7RB9E+vONzci2525nw4mXRIJpOTFyo9hcckwl5WIG9Qvgc+wHzGq6ttvvuJn1o49fi6ur6c+Q2DuPOEXteiOQnMMumdITMgs1ISwmoFIjNdQrKezvb6x4wLFz2OcHOE1DU2RVMyEsCIfI+oS7H0Y5jIbYHCYNz8iAM/Ckbg8fCKKcrESj/rgvxqN740F7gVqIqoTvBsRR7XniIhIxc5LYK5gBQxenpzBPZK1c04Zg8HWH+HiqcnB+A9s6BFtA39/DA6E2IjnLYqZnSkxP/nwUfkQMgMu1v1hTBwV61nhjTpwEnulsxLdfTZYvbtmMTz41WqiIujFERCJ8HvGDLhRLSbZrsUoFBvSLYDf5a2FyBQ+egs3DdbOeGs5Qn8PnmHg07gkfn6drMqFyQIGH2Lm1r0KBq4sYGhENAuOT8Cgz2E1BofrR1vDHLMgZ46tanno94RAm5CA8Gi5Pptgjh3KLivxPkS2xzLFpLbI9Vh5Dr/jHYPwQPtEAkY9lRjSuvN4wG8lok8xWxCFiorHZ4SZaE0nzrGVDHRg7uJjXBPlx+DBf3waksPVQUMIMYvzW4h+DRP8sTSSgxArpQA+r2wkXDgFc85H8bm+6tIc5m49Rh5Wg67zYU4taFaZlCMZ5+KgMx5wTUhSxdQumXgV85gIvot7U2aSuHq7Y/nNe5WyTO0wuAO8pu9nRLTZeE3KVD43cT8MXIt8khUqoTkREe8rRLo6CRPt1b64v/wRBlzqcsbR0UiYq+aE0WN6DbMK6+FBffU+HnyMvLl4NLYHMvEqJrcd91oZjZ4ncrvMWGspMfhi2V56TL9EuPEX08lgbZ+ZSZ2xpSqjrNQdNebHjGoDcwVzY6ScXldMFqiUL4Ss6IbFMbMbtQcf/FCifzG/L2bZA+YrA0sW4Lj1QXW6Ecw7gUhmj22Mz/DU3fh+HRtg4HoykgRqpM5aogfC12YVlX83A9lFD5F1+IwggvOIhoNrS0REWMC0laAOTE8jOgCJZKWHInfodbIyuxvezxpew8oKjJ2ek7SL269DVCdnDkxcGMIYS9wYbeuawFyLEphEqOHmaqQce/A6IhisNFRjONa/1foaIiIPg1CU6j7hl1kN2QxzLKBJj8S1CMpcs0P/KiEMNui5CObyV0SCK3PYTH2O+4uuMaITRiaIgFQrhXsOa0F1U8nvM9T09mNEHK3bYzcJ05hoPRi/870e/jCnaT+NHJlJb/wPjP8oErGaaKCn5zAXEYkhimpsMAMuv8mYKawm/f5qmJN1P5QsQ3rCRyOzt5YlHjbjemJmZ0eu14z0Nj+5i9leu46Y7Znp40Hdjyg7qgfrYjhMjMvcDmKN1YR0APSriZlSCSJdfoyograuiIv8EtnQWJtXnIeShMQY9pMOYh0zMQ6Dw9bWSFxlLXN6FTGYeUnswZ8RNb540gHErMCHqrQNWCszCxh2XMXvrUNFJK8F3ceA9Og4a5hT63CIiFg6YEaZRMTWWMdGhGpdnyXaJ6w9soc7BgdMHGsMUeKctgu5A2puhohIJGldH04EvZjNd3SEMns8Mh+z2C69MPgaMgMJmGywgGEHQSHDYkjn1Bs8lK89Q6iemXL1qYqdEsPHKktrhj3Q9I0d+vFHMdBkrZZsDa8Kxf2wiTkikyuJwvD8lthhxPgJXi5K/svTM7j2mRW4nxd+Lh+i/rthLiYLDGGKIx1sTCeCtYzq/andGWrkgcles2FGmLdORO899DzCN8yzwmkgZl42pO7ebysy5Ufb4ObS01OZjTKRKrdgLEkwNIEJRu0nTnFssMjbbRLCjY2K4/fJTL6SkpQPoWN/7Dro6Ynf0Vk/ZPtH+6Bk6lEiSsW6PVgQ4XcVDy8WMMzohnXBTCSIWHFauWkwyXPWpjpnMJZuipASWo9taHLTygUX6s3HGPQy7kzjaUgY9RyLG3XXqsrWYotBuFFLAh4irD5dPB/eh44r8LmpRZANppOhlzt9JTm3QFw7rSopn+FbRGHRajNRmLTBQ591O5QugDXruzcwgWDW5XrpbDWvUxnbvp06KrNYMwP8ztlgok/MsZSVGu48wyCV2X57bsag/2osPq9dWmFLPjO0UvtTDOqOJMUpJOhlXRwviNFeg6GoEcMsvtlBfYigunp1UO2UqULeUiFR+rWwhTghFAmu7Dn0DcDSuBhiWc2qCe5zrE2ToROYeoo8u4Dr+leHRsoZZSYpSxWJ8RjFhrpgdhJA2sg8ThHrW1KmYFyEPPkQ+kuMQ8i4GCHXOdRF6KuygXJxTSRsZwPiWeDcDBdqRCIu8iCi7DiabBD6RIRmgDd2Gfh4oSiXWRWEpdV17F7jkZSWJT+ScpwH4QKsUwThwV6kw2LvMCS5Me+IRvWxjY75ZHhfQ+Z9JQM8IJapNPoXkXLBgmDMTuaQv7nzCh7KvUl//qBd2BHEOjbUbZoinItQugqiWMfHKg/NNwTpqEPIcZXL4X2dQYS1Ru3BZ92sEH6/RXTwYD18BYPIrYTQqeZ1iIhMVrHbe1RDobFzxM545wm8h+Pa4bNfoQAemDuv4z60fC3hV8VgghOyG82gCulicJikInT29sRy2aCGyP8onheDDYdlyGtgUvsJZ7DrZO82zLDbTEFex2eCTgQuR48R6y7oKOm/Wdk9wDoHEohbr/0wd5h7uB89QZhOSMFuGERTYuVl5El0GIykZKZZMbmBch3qN54Or9EtUwnmzMvgmtvdF1Fo5sTZn1gelCTt/dXt8L0wP43VLtge2qNa+ngcXxsaQSLMVKTEj0V14DVtCTubEauYoFPREriRlCqOh5f/bsyU5RNurtfjUEjoVknMqOarsvF2zTESH18PF361MUjKKV0eP0MW0va38yq+NwtDHZh7/wE/V9X62A7GXExLqmyJa7bAA551ztyMw+zsXgIe5pE3MBC8/RQ7UdhYZ18J5hYQO9yahXVgrlBuXPhnTil/tyOpa5cnNsKsw6JLFfwuGbS6sj1yYl6RjNWoK7abyUPkU7QbiryehyrSpF4uPMw/k/XVjNhNHyYlpCdx+D0xhGGbDx6GrFNk6iEkCLYthyjh/FbKALd0T8w6/8qM72PeSEQJ65vi9ZmXTC/SklzLuQ3MvSQHdeZMeEAuJEHpAAvlYXB5N6Ip762RRFeKmMMxnxSWaDhuxkNkKNErOTinDcwxky870vbsvgI7D2zslbojGzZgINCr/2KY27x2FMyxAH+lB3YEBbmgWODi04h0LZyLqGvXLfgMtyuPzw6gPZkwMYhcju+DdXFUIZo2Ty5gSe7GDeSEMPdQvWqY4CVEYDdZSR18nn51aASJsFyg7O/d3B2JaixzZLoGkzyRJzHSDjOKQ9cR9l5LDqA40qrDTLkuuGLvuTqAZu1hBQkkbTkLF5s/qc92XIPMY9ad0oXYvO4Nx2yPaWes3I41W3Vr6RnSWrWpB97DLoSUFnUHs7iCRnhQGRD49v495B34jETIPIAccrOWYaaYgYhmmZVRbt5MkrpofkSTqpMsPjc5RIsR2e83hJR1mbg9mpFAeGxD5F207rME5mbN6a34uV05hNBZ22OsJ3YxFGqNhDbfxY4wl15p6RyZcM4wF651hgC8UiEq3vsRcUtNwcDNpikiTDYkYGKyx9YdUWzLfS1C3Huv4nNYiphy9bXA7LH2FCVBjglXbViHz9zDHciJuEIcZpnXSRenPTAX7o73nzm7PicS11VJcviAcBZM8itRYqZXkZGgE54b8fPnL45Jmtdw3CMukZbc6gVxP2w3H/eNtUMxKDtFZP/VQlKs5GHYimguJOLZx8oejIfBRKn2kPJrahyW/JkXB+NJ/KpOhEaQiO4qsxKWne0KweyUmW3pkfKApRFutiXyYTmj0mhEAAyNMBof2xVFrlJIrVwtyuRHOAwFcuHBlRSPDyDru2cBQ14yN3IhPvhMAZN1wPTviOiE2h79zhPc4NcQoukEInH85BWWX4rmxetdI6Q0BFtFGjth61fsRvSA6E/KCGejsH7eYZTSn+FNL2Qn5+uEiMBuIl7z5gMGBwxaZO2czUiZyp9kWdvz43PNiJoGKuSBlYZur8P+99rECj18C2bAWTJht8fAWQgF7yOOncxEzaQEBjn9mmDAdOyW8h6+voOlIWNLPESMyL5x5BYGqY1bIm+IeTs0LYkQtDkpl1oNx0DtbCSuObUWA/PSYd4vRvVGw5w/KUkUyolrjlmhb7iIJTmPvXjI1yHW7fo38G8MqYEBU+h95ffOumkqkU6nBiXw0F92BDuHGg/bBHPqtlIR7jFhRZRuO8/CpDL1HgavHUYo91wmXc26Sc7PwYBUzwIRHEbU1G+3HOZivXG9slII4078jqGRIELtxskUK1f2xsz2TiKSd+zK4mYzgPi2M7VLRras0Qz72LtURliaBSAzeys372ux+KAyoybWsWFHNPAH18IH2mIqPtDB89vB3CgifMT4H2t2IhJRXXUAZyWZY+2imLHdeIr3KzepT1Yk5RcvooDJiIXnFyIceOgmZqwsKCmYGwOwv3IrA1BG3lo7CSN2u8l4EIatxkPZl6h4Rt/F9zuZsP1vROP9Ok+y8zw6eECWVdV7ixOez8u3GMzfv4BryX4NbgOsJfVlEq6vd0Sf4uryjul6XYMZGPSq7dxLNsJSjm0tPLjUgbGISPvSuOZcgzBw2zANIW6GJrJ2zvOrsMbM/oZ5K6VT4vHNeLCozeJERIY744Ex+wh2SZzyxwCPdV0wjsG5OygOx8zGWEvjgyREIgasVSKWi3rhwVqgEQZCrDvDjpSB8YkQKUtE9RhPgnWFMLRj1RS8Pw3MlSUOpi48iyidlh2JZwsb+lbofvs0GH1zmNjYf3JoJIgwVKlCMv8LJj/NWgGZK2ZZKwxAWNbNsnMmtqRujxPhraVHVW1urLWm+2YkEUZGIGKhltAWEXlP0I8eNvgQ6hJ04sBhZPcaFcMsS4cQhN6o6vOLOiEUvOs6QnD+F3GuS13c0G8/xcOmrhlmGVbEDIgREIevwyjbiVgwn7iNiytxh5IMxmSfPbchX8esPG6iuQly5roRSzwT+2C7VYlGuCmx9r3xpI30FSmPqHURRjRD8mWVDkh6a90P4dESpNRUjAQubMQSJ9YE0s7JUJzMWfFeq/kOmwhyVHsoyvkal8aDwK4e3kNme249DiHeT6+SYW70ZDy+WHvwBVK6UntMxJH23sCdaMmcMxsG6YNqIgk8miQzjCdhVHcEzK12Rxll+8VI0k64ifum5MA9XG393YwQC+U9Bh9qBENEJDtJcKLuEkXcXPhZ101ASfry+sR1mEiy1zNDjlzoPZWJ2nLSym+MZ9BrIr8dexpN7xiywfSF2kxHPg2Ts67cFoPjhyRx+dXxHxWbykL8FLwGYM2atX0ubkNY9kQBkjl2prdTRF1GuLQMCWOZiYzshRhcDJuJKuJ6B4Q9W5PWuvtEn2GQPf4uQwXuJSJRtZfKWptJterWQ4EUv/VIfNpHHDabl8Tyk/0crHdeWUoOtE64uIQYNTHb96omuEGov5P25TCzSSHCQj08kGzFiLC+hGUdS4JNJoYU8gizIs8z+JwsaoNEzTkqDwTWCjmrI/7e4FVISutpi3D+gtXYJeI7G1GirsTZ9HU8cgfaOSASc5pA63O6V1L8vIL09a8izz4roaTcxACv60Q03+tHNFH6EHh4rC0e1GphJRGR857Y9qzmTq0LxRp22EMk4DFEgLWHugbhQbjcBQWIDKpgUHZjAR42M49gucU3CPfX6KPoCaQut7DuDMbhGLgan81Zjog4q3kzIiJjRq+CudLNMTGMvIHP3JHZ6P8R8wqDnAM3lcEL8yG5vhivxXgSrCUz8lEyzLHgKHgTJtoMsTDosgnmPqfiefB2Hxom/sj413Qi1D4UIjz7ZxoO1y7hRpLcBBf0OQIFDyAmKWeJXeuUtbjh+M5U3mjWluXRA+vVyYSUpO4SEBHpRLgjHj3xektOR8Ec605gxLdRdTDz2q7qANEjZQBWh78ch/Aocx31D8EN0rIu9oWHxWBUzDxMXLtVgjlGzLoQgwiI63plO1xGov/AhKB6EYSlQgEdmGP8H2NSny/SZzvMLSMy4s+e4TrJRmSO3VRB9LgDiEzZO+2DuZIVEelYsGgPzLlMxQBP3S4rIqJPPFZKkXs9h+gTBJfGYHO3ijBchGiJPCdlGmY/fz8IOwCYeBGTIF5LyOH2y7G10qF/G5hbdwEPKvU9HF0XkRPjhSthrh/hHDDhLvYcHt+IQX/u7Ljljz2ASZoLu18EYXlv2Rjm1HoadcYg0pPessJEd4L0kg6IMamI7Nw8Qbr1PuD3VNwAkfP641DOXy2trhafEhExtMYkUM2lEBHxXrED5oZMxNdNbYRrSZ9wHfStsUzFFCtZR+Svjt+iWPmIWCEXJX4SbGQmG6b6MBcR6euBmcIAQtTSyYaQKZOMZmN2gLL22LIK8jVYh8XN8CiYu7rSAeYYCMTqjmycjUmGuaVbcMFN7oNCL0dVrqhMCOmUczOYs3TCtqT2RESrEWndY/LgrN+/WnmEPjcRFGdnLwxyHjzHICpwbhvFzzHEbKwjEXhixMpLhHMyaiLCvh4TcWNdOxIzccaeXzAezZDmEwLm6cvK0tJ7ErjatMJadPBJzJ4KlkXe0GqiRHo/CD+r5NSBqYAxKMLzghz8070QHrezVh4kHYnjLtNcUcuAi3AFU+ZPwIh/Zx7iHnZwrDXMMbfLxvbTYe74DiVUbdwNybx3PBElYSqZFXutg7mS1RBNciClmw2ncS0xhI3dL7MiOjA3tDHuuaaqcjYLGO7vQGOxkv28YK6GJZZ3GaonebA0Kq8x6Uk4jV4fZkMQxTrnhrweJmmtHpXbY5ef2nNDRKRlX+S5TWqAz7B+C1QxzV8a7/XleYgmdSFo6ilP/KwyBM+IHxn/movnY2LnzBw7jYmgzRWiPBZzBWvbzB77wCWs42ckJQjWRnlExRSfYI03ecIBLJd498YDrukSzGJyENe2lpVw02xkigEYkwIPeZgMcw4VEL5Xu2xeJXbmjK9Rn+jkx5NNNJloIrBAhZFSyw/CjWTucGuYa0HY821JKejhPeWhMbgL3ptO5XGzZZCxbo3hMGdAMrF3b/DePH+E3S7bXTGwdJiO8DCzg3aspnxeGRHUwR5Lg4y46UN0B649wQ3YlATfRnrI2GddMgnv8DkZMBM7ce5sVraufviEz2FzgnQyg68ChBNgPgARIWZ6F7EcN3nW29+pMWaKPSrhmlOjmNEEwZtHyOesS8TYFh072YEpRE8jYj+2s7JOkS4VMWEqSdbEYoJOLV+lJIcfd8MMm8lUr2yH5TfGk+hK+Bq+41DVNZU8Ow9JmeJUFCYzGxbhPmTloDyoL4biZ08hz3nMJiRkM7VL4yaYuEQHYWcek7h+dhM5EQkBiE5cJ4lbdVNi3vUDQyNIRKwqWmbdGReckQHPSI+pJMqsYISBRVwtJBcxiWtmQLU1KArmmO7CcCtlPXLGYRTMWd4eCX4rQvDhekDMsULmIMKyNATfWy5C6DPQ0YG55PeYPbANwsJE+X0yLgUrSWyag/Bd7op4AIUtagNzo/biQ263HOHGpUTiee0x/D7fpOAGwUikfireRTeCYJ0gMK2+LpYkQveifW+JgrixMo2Jbq1xgyxJzJU+P8Ha9nhr9Flg0trq4dIC9VWiCSmv8hCEVleOR1KaLmlnZmWUxsSz4OZTRIm2E45FpZFK6DsXUWxkbP9wohMwZyUG+CmPo2AuYxHMpvuRjrD9ROuFEYGZyZdad+UpEdVjyImxPZY4LNth4DrcGrkTNYnZlFFnVIXMkgu/Y5ZEsG4Ex0oYbOwqqfw+N1zCfX6XD65DlrGzjg1Pguq9JeJ7FY3wcMz8GBPIXquwTVdeYfByJli5/+90QtSwL7EZoIMYcL1MTp8fVMRiRDvs3DHY1LNdgr+cguvwV70zfgsSoQ4qRHhgYV4CH/LnxDTo4mEk3JS2xI0kM4HlGJ9i42TkYlQ1xO6BsfuVm5Ax6eGf3gQzkbtx+DC0mI3EUha1MlOuRYSLwXw8WMtsI+KKOUVFVG1cCu/DVkLwW074JUzt0KEiojr5iKLis5f4+S8+wsVbvqAOzDHr34pDkXCkluouQDpdnL0xwBnfFg/g5qSNct9NRLqGzMGMNb2kxMrVTGCOOUqePaY85PSK4HtjJmLFyyCJcOfA9GXxRk2xLY/VcRnx7XgoIjFBpNuhppMyi21AkoVRdfHAbLUAs1PW6RSTjPvLoBr4N2oPQsJk5XqVYM6VOPYGEc7VrHFKcaExsxHOZ5bZu4nA1VXSkmlJDnN2wLNSUAmiYviaqHO2GOkBc/IKS3xntyo7kZJIacRmADoH65ZEmP7VczxLqJx16EmYE8KTOO6NMuUN+mOg9tQP22377lCuOVYGmkJstYf6YNmusgmeN1MJqvU+Fdf+6Xt4/61L4D7PVHfNmyMS9atiUxoJIpLfKjeNUALVTfLB8gPjTlhUxwXNvChqj8aodWxflP4so48Hf7XCmCk1IU6Z6iDnxi1EE5iI0I49YTDHTLnOzEP46tg93DQS3+CC9iU8AVsLhFGZj8FaVVfIgQjMxBlac/MUBjPMMvx6DEJmSa9w8750DrPu8lVMYK5jTQxKFpGDn2Wow9Yos8J1gxE5uUsygHyk1GSUC9EJHfK6GaSPP5monfYgJTS1/oMIRwDUapQ5cuN7e51I2rky4MbnPQsZ5aO3hMGc5wCsnW4KwyCqCWnnLa2PaGIbNyzxbemn/Busc4ghPWsJwZmVpK7GIOzfojcqdq52Q35CYzNsoWbIof85DJg8VV08hQhqNpG0i3rOXQ1zDuP7w1z/6kjAZB4er0mpkSEME/wQYfLZitB65ryYgKTeUe4TutUQOUi6EQZzjNfAArfL/hgwLndBJU4HogfEDL2yEmG1CuOw1AYlg5d4zsWfRM5Fu/Wo4WGgg2VAxs1hKqFOh3B/eUI6wvauwtLdkCnofzK/JZaVf2h81tBISUn5vGPHjs8pKSl/3PX+5Pem6ev9ye9N09fTvrc/43p/8nvT9PX+5Pem6ev9ye9N09fTvrefHwQU/rmRmpoqu3btktRUhK7+09f7k9+bpq/3J783TV9P+97+jOv9ye9N09f7k9+bpq/3J783TV9P+95+fmgsiNAO7dAO7dAO7dCO/62hDSK0Qzu0Qzu0Qzu046eGNojQDu3QDu3QDu3Qjp8aGgsiMmfOLO3bt5fMmZHp+5++3p/83jR9vT/5vWn6etr39mdc709+b5q+3p/83jR9vT/5vWn6etr39vNDIy2e2qEd2qEd2qEd2vG/N7TlDO3QDu3QDu3QDu34qaENIrRDO7RDO7RDO7Tjp4Y2iNAO7dAO7dAO7dCOnxraIEI7tEM7tEM7tEM7fmpogwjt0A7t0A7t0A7t+KnxxwYRr169ks2bN8vDh2hmox3a8b84Pn/+LG/evJFPn9DZTzu0Qzu04z8x0FoynSMxMVGioqIkMTFRUlJSJEuWLJIvXz4xMTGRfPnQJfNHx9u3b+XgwYNStmxZMTJCN7avjTdv3kimTJkkS5b/b/n86tUriYqKko8fP0rRokVFR0fnl9+fJsenT5/k/fv3kj07Oruld3z48CHtPmTK9NO39avXjomJEX19/V96j3/6+Nn7cOXKFTlz5gxdD0WLFpXatWtLhQoVfvn9PXv2TIYMGSJjx46VatWqfff1d+/elZMnT0rWrFmlYcOGoq+vL69evZJ9+/ZJRESEfPz4UUxNTaV58+ZSqBBaiWsHH58/f5a3b99KtmzZJAPzpNeOf238CfciLi5OYmJiJHfu3FK8eHH6PqKjoyU0NFTat29Pr5GYmChv3ryRIkWKKH7ny1p9/fq15MmTRypUqCB2dnaiq4tOuf+p8cM6EREREeLp6Sm3b6Md6ZdRsmRJ6dKli5QqhRbeX8aYMWO++Xc+fvwosbGxkj9/fsmePbv89ddfMn8+2qx+GSkpKeLm5iYXLlyQDBkyiI2NjXTv3l0OHTokW7dulffv/7aizpAhg9SvX1/69Onzrz500dHR8vz5cylfvnzaXHh4uOzevVsiIyPlw4cPkiVLFilXrpw4ODiIsTFa+/5zfPz4UQIDA+XMmTNy//59efXqVdq/5cqVS0xMTKRWrVpibW39y0FFfHz8Dx1eIiKhoaESFBQkWbJkkRYtWoiZmZnExcWJl5eXREREyKdPn8TU1FTatGnzzedE00OT9+Hdu3eyePFiCQsLk2zZsomJiYno6OhI5syZJTU1VZKTkyUqKkrevXsnlSpVkpEjR0q2bGjP/GWcO3fuq/8mIvLixQtZt26dtG7dWooXLy4iIjVq1KCvvX37tkybNk0+ffokf/31l+TOnVtmzpwprq6uEhcXJ4ULF05bY1mzZpWZM2dK0aJFv/n3v4w/edP8NwK6n1kPvyOg08R9EPk99+LfCqx/9F5o8j58+vRJVq9eLUFB/9+a3MDAQHr16iWVKlVSvPbkyZOyfPly2bFjB73WvHnzJFu2bDJixAgREbl+/brMmTNHPn/+LKVKlZI8efJIUlKS3L59O20tFyxY8LufV+TvQOv27dty//59SUpKSrsXurq6YmJiIubm5vLXX3+l61ps/FAQceXKFZk7d64UKFBAGjRoIGZmZqKjoyNZsmSRlJQUSU5Oltu3b0tQUJDEx8fLhAkTvvqgdOrUSbJlyybFihWj/56SkiKRkZFSpEgRyZMnj4iITJs27avvbdeuXeLt7S1WVlaio6MjR44cERsbG9m9e7fUq1dPqlWrJh8/fpRTp07JhQsXxMHBQdq0aZOuz33t2jV59OiR5MmTRypVqiQ5cuSA19y+fVuOHj0qgwYNoteYOXOm5M+fP+3fz5w5I0uWLJHcuXNL1apVJW/evJKYmCgXLlyQjx8/yowZM7763bx48UJmz54tUVFRUqhQIXofIiMj5fHjx1K0aFGZMmVK2nfIxoEDB775+V+9eiW+vr5ibW2dhgq1bNnyq6+/dOmSuLi4SLZs2SRbtmzy5s0bmTp1qixYsEA+fPgg5ubm8vHjR7l165akpKSIk5OTlClT5pvvQRP3QESz92Hjxo1y9OhR6d27t1hZWdFg7cOHDxIcHCwbNmyQhg0bSs+ePb/63jp16vTN74CNr21Kc+fOldjYWHFycpI8efLIypUr09A4JyentA3o3r17MmvWLClVqpSMGzfum3/rT940NRnQaTKYE9F8QKfJ+yCi2XvxvxRYHz58WNavXy/W1tZiYWEhSUlJcvDgQYmJiRF7e3uxs7NLe+337kPfvn2ldevWafvq2LFjJTU1VaZMmSL58+dPe92jR4/E2dlZSpQo8d1EXEQkJCREPD09JSEh4auvyZcvn3Tr1k1q16793eux8UMp6o4dO8TMzEymTp1KJTOLFCki5cqVE1tbW5kxY4bs2LHjm0GEr6+vZMiQQRwdHaFk8fTpUxk6dKg4ODikK8I8ffq0WFtby8CBA0VExNTUVNzc3KR+/foyYMCAtNfVqlVL5s6dK0FBQd8NIlJTU2Xu3Lly/fr1tLkcOXJIly5dpFGjRorXxsXFSVBQ0FcPsAcPHkj16tXTft62bZuYmZmJk5OTYhG9ePFCpk6dKtu2bZMpU6bQa3l4eEh8fLxMmTJFkVGrx9WrV2Xx4sXi4eEhQ4YM+errtmzZ8tV/++cIDAxM+/9vBRH79u0TExMTmT59umTPnl3WrVsnrq6uoqOjI9OmTZNcuXKJiEhCQoJMmTJFfHx8vhpEaPIeiGj2Ppw5c0ZsbW2lQYMGX/17mTJlkgYNGsjTp0/l2LFj3wwicufOLampqdK6dWuKziQlJcnSpUulU6dO30Vv7t27J61atRJ9fX0REWnXrp2MGzdO+vTpozgAihUrJs2aNRN/f/9vXk9E5OjRoxIUFASb5ty5c2HT/N64e/eutG7dOu3nTZs2SYECBb66aXp6en5z0/Ty8pJr165J//790xXQeXl5ffVeLFq0KF2fYe/evWn//61D2sfHR/Lnz68I6ObOnSsfP36URYsWQUC3Y8eObwZ0mrwPIpq9F5q8DyKavReavg/Hjh0TCwuLtDNHRMTa2lrWr18v27dvl8TEROndu3e63v+bN2/S9sWUlBSJjo6WQYMGKb5/kb/PWBsbG9mzZ893r3n69GlZunSplCpVSrp06SJmZmaiq6ubFtAlJSXJnTt35MiRI+Lm5iafP3+WOnXqpOv9/nP8UBDx4MED6dmz53c1tzNlyiT16tWTTZs2ffU1bdu2FWtra/Hw8JBx48ZJw4YNxd7ePu2L/FF45dmzZ4qDzdzcXEREqlSpAq+tWrWqbN68+bvX3L9/v9y4cUM6dOggFhYWkpycLHv37hV3d3e5d+/eD5VE3r9/L1mzZk37/6dPn4q9vT1E4Xny5JFGjRp9c1O6dOmS2NrafjOAEBEpX768tGrVSvbv3//N1xkaGkpCQoK0adNGLC0t4btPSEiQadOmSb9+/dIFQT58+FDatWuXxi1o3ry5HDlyRLp06ZJ2f0VE9PT0pEmTJt9cEJq8ByKavQ9v374VPT29dP1dPT09effu3Tdfs3TpUtm+fbt4e3tLjRo1pGvXropNJD4+XkREjI2Nv4vcvH//XnLmzJn285f/Z3wgXV1d+fDhw3c/w5+8aWoyoNNkMCei+YBOk/dBRLP34n8psH7y5Ik0btwYPlv//v2lUKFCsnXrVnnx4oUMHTr0m9cREdHX15cHDx6kXSNTpkzfPAPTU0DYs2ePVKlSRcaPHw//liVLFjEwMBADAwOxtLSUefPmia+v708FET9ECsiZM6c8efIkXa998uSJYhNjI1++fDJixAhxcnKSiIgIGTp0qPj5+cnHjx9/5G2JyN88gH/yAl6+fCkiopj757/98zD72viCbrRv316MjY2lQoUK4uTkJJ06dZJjx47JggULJDU1NV3vz9DQMI1HkiVLFsmWLZu8ffuWvvbt27ff5DF8+PDhmxDgP0f27Nm/e0AsWLBAOnbsKPv375elS5fK8+fPpUCBAmn/fTko8+bNmzb3rfHp0ycFsfVL0MkIi98jMWryHoho9j6YmJjI0aNHvxscvHv3To4ePSqmpqbffF2OHDmkV69e4uLiIi9evJCRI0fK9u3b0/g8PzIKFiwot27dSvv5y/9fvXoVXhseHp62sX5rPHnyRCpWrKiY+7JpdunSRQ4fPiyLFy9OV0Ci6U1TkwHd0qVLpV69euLt7S2HDx8WfX19KVOmTNp/JUuWFJH/H8z92wGdJu+DiGbvxe8IrDV1LzR9H761d9ja2srAgQMlNDRU5s6d+9XXfRl169aVY8eOyb179yRDhgxiZWUlu3fvlsTERMXrYmNjxd/fP+1zf2vExsYqUNdvDQsLC3n8+HG6XqsePxRE1K1bV/z8/OTAgQNfvfnv3r2TAwcOyMGDB6Vu3brpum6ZMmXExcVFOnXqJLt375ZRo0bJxYsXf+Stibm5uRw5ckRiYmLk1atXsnPnTsmSJYucO3dOkpKS0l735MkTCQgI+O6GLvJ3SYXdrLZt28rw4cMlPDxcZs2aJW/evPnutRo1aiTBwcFy4cIF+euvv6RZs2bi7e0td+/eVbzu6tWr4ufnJ+XKlfvmZ/X394cHTD0SExPl4MGD343QM2bMKC1btpQlS5aIoaGhTJkyRZYtW/bd639tGBoayqVLl9J+/nIv2T0NDQ39Zq1bk/dARLP3oWvXrvLo0SMZMWKEbNu2Tc6ePSu3bt2Su3fvyq1bt+Ts2bOydetWGTFihMTExEiXLl3S9R6NjY1l6tSpMmjQIDl58qQMHz5cgoKC0pV9qD/nkiVLZMOGDeLu7i6mpqby5s0b2bhxo1y9elXCw8Nl5cqVcv78+XRlIH/ypqnJgE6TwZyI5gM6Td4HEc3ei/+lwNrY2FiuXLny1X+3traWUaNGSURExHdLxra2tlKiRAlxcnISNzc30dfXl5cvX8rQoUPF2dlZli5dKtOnT5fRo0fLu3fv0rWX6Orqwr72tREZGfnTHR8/VM6wt7eXZ8+eyZYtW2Tr1q1iaGgIpJnY2Fj59OmT1KxZU+zt7dN97QwZMkizZs3E0tJSvLy8vlkK+dp7mzhxoowaNSptrlOnTlKgQAEZNmyYmJqayqdPn+T+/fvy6dMn6dChw3evmStXLnn+/Dn9t9q1a0uuXLlkwYIFMm3atO8GTI0bN5Y7d+7I/PnzxczMTIoXLy4fPnyQSZMmib6+vujo6EhiYqI8e/ZMdHR0pFu3bl+9lqOjo0ydOlWGDx8uVatWlWLFikGt6969e3Lx4kXJmjWrdO/e/bufVeRvpGHQoEHSpEkT2bBhgwwfPlxat24ttWrVStfvfxktWrQQNzc3mTx5suTJk0fCwsKkXLlykjVrVnF1dZVq1arJp0+fJCQkRK5fvy69evX66rU0eQ9ENHsfzM3NZdasWeLl5SX79++n+g0ZMmSQChUqiL29fboC13+OWrVqSdWqVWXPnj2ybt26H2qdbty4sTx58kSOHDkiKSkpYmZmJsOGDZNs2bKJs7OzBAQEpL22QoUK0qpVq+9e88um+bXXWltbS86cOcXNze2b3Vsif2+a169fFycnJ7GwsBBjY2MJDQ2VoUOHSqlSpdIIrhEREZIlS5bvbppdu3YVZ2dnGTFihFhZWUmxYsVgb/rCzH/16pU4OTml6/NOnTpVzpw5I56enhIYGCgODg5SunTp7/7uP0ejRo1k/fr1kpqaKnny5JGgoCBFQPdlPZw+fVrOnz//XYKtJu+DiGbvxe+4D18+86/eC03fh6pVq8rGjRvl0aNHis6Wf47q1avLpEmTxNXV9ZvXypQpk0yaNEkOHDgg/v7+EhISkvZv165dE5G/k70qVaqIg4PDV//eP0fjxo1l27ZtkilTJmnSpIkULlwYXhMTEyOHDh2SY8eOiYODw3evycZPWYFHRkbK2bNnJSoqiraM1KxZU8zMzH7qDX0ZT548kcTERDEyMpLcuXOn63cSEhIkKChI3r17J2XKlEljKp8+fVoOHz4sz58/l0KFComtrW26Hj5XV1d5+fKlODs7f/U1d+7ckXnz5qWJAH2rhi7yN1vWz89PIiMj4d90dHSkVq1aYmdnJ3nz5v3mdRITE2X37t1y7tw5efHiBfx7njx5pEaNGmJnZ5dueFE9Tpw4IV5eXvLx40d59erVD7W0+fv7S0BAgLx9+1bKlCkjvXr1kixZssiiRYskPDxcRP7mvdSvX1/69u37VV7D77gHIpq7D1/G27dvJTo6GtaDkZER7ST50fH06VPZuXOnJCQkiL29fRrn53vj06dPaW2r/5y7ceNG2nr4WveJegQEBMjGjRtl4cKF39zEbty4Ia6urvL27dtv3ouPHz+mbZr/RAu/jIwZM0rlypXTvWlGRUWJl5eXXLlyReMBXUpKiuzZs0f2798v+fLlkydPnqR7PXz+/Fm2bNlCA7qZM2fKo0eP0l5boUIFGTdu3Dd5Z5q+DyKavRe/8z6I/Py90PR9SElJkbi4ONHR0fnuGfXs2TN5+vTpd0tfX97no0eP5PHjx/Lu3bu01lhjY+N0l7G/XMfLy0sOHDggHz9+lGzZsknevHkVAd379+8lY8aM0rx5c+natWu6r/3P8VNBxP/KCAwMlFWrVomzs/M3IbxHjx7J7NmzJTExMV0HmMjfh05cXFzaQ6Krq/vTcFJiYqIkJyenHV46OjoaEfz68j737dsnCQkJ0rx5czExMfnlaz59+lSSk5OlYMGC32w9Ffm990BEs/dBPV69eiU+Pj7SoEGDHxJM+zeu9zPX+tM3zS/jdwZ08fHxsmPHjh8O5kQ0F9D9rvsgotl78b8QWP9fGImJiXL+/Pm0pD81NVUyZ86clvRXr179l84LbRDxjfH582d5//59GtnoW+Pdu3fy8uXL75IO0zPevn0rr1+/Bnb0/+L4t+/B48eP04R3vnRx/Oz4GVGif+t6mn5vX+7Tzxz6v/NaT548kdu3b8vr168lb968UqZMmZ9WrP3ntfLkySNly5b9JfXbn71eUlKSRhULNX09Ec0rB2vyer9D1fj9+/fy8OHDNGGtbNmySaFChWgJ4d+81r8xtEGEhoYmD/7du3fLjh07vplRP3r0SPbs2ZOmWFe7dm2pV68esKrTIzbzf+F6Xxs/c+gfO3ZMDhw4IG/evJHy5ctLr169JDU1VVxdXdPKG1myZBEHBwdp3rz5V6+jadVVTV5P0+9N5O8yZsGCBRWdTV+g62vXrqVldxUrVpTOnTuLoaHhv3Itkb8h/oSEhLR6fWpqqqxatUpOnz6teF3GjBnF1tb2m3wtTV7rd1yvU6dOYmRkJJaWlmJpafnLe44mr6dp5eCvXS8gIEC2bdv2Q9fT5LW+jMePH4uXl5dcvHiRdnPo6elJixYtxMbG5l+91tfG77BH0KzJwv/w8Pf3/+7Br6nx+PFjmTRpknz8+FGMjIzk4cOHsmrVKjl+/LiMGjXqh6PoP/16mjr0Rf7uEFm7dq0ULVpUihUrJqdPn5bU1FT59OmT5MiRQ/r27SspKSkSFBQkmzdvloIFC1KtEZG/9TC+p7oq8jebPj28Hk1eT9PvTURk8uTJMnToULG0tBSRv/vuv6jIWlhYiJ6ensTFxcnFixflxo0bMnfuXDEwMEj3taZOnSp//fXXD19LROTIkSNStWrVtJ83b94sp0+flkaNGomlpWUaOfDYsWPi6+srefPmFRsbm99+rd9xPRFJk5Dfvn27mJubS926daVmzZrpal3/ndfbt2+fXLhwQaEcnDVrVqocfOzYMdHX1/+m6J8mr6fp9xYVFSUzZsyQT58+Sfny5SVr1qwSGRkpycnJYmtrK58+fZIrV66Ih4eHXL16VcaOHSsZM2b87df65/g37BG0QcS/NP4pUfu9cf/+/W/++/bt29PIQF/aI78owE2ePFkmT5783czt/8r1NHnoi/y9kZQuXVqmTZsmf/31lxw4cEA8PT2lcuXKMnny5LTXNW3aVMaMGSP+/v5fvZ6mVVc1eT1Nvzc2tmzZIlmzZpVZs2Yp2nSjoqLEyclJdu3aJYMHD073tbJly/bT13r69Gna733+/FmCg4PFxsZGHB0d015jaGgo5cqVk48fP0pAQMBXD2pNXut3XE9EpF+/flKgQAE5deqUnDlzRtzd3WXjxo1SsWJFqVu3rlStWlUB139vaOp6mlYO1uT1NP3etm7dKrly5RJnZ+e0xOjDhw+yfPlyCQ8Plzlz5oiDg4OEhITIsmXLxM/PT2xtbX/7tb4MtT1C5cqVqT2Cu7u7HD58+Lv2CF8b2iDiG0OTB//KlSt/9e2kjTt37kizZs0Um62VlZUUL15c5s2bJ05OTjJx4sR0d8j8ydfT5KEv8neZpX379mlllerVq8uWLVugjTVjxoxpuihfG5pWXdXk9TT93tTj06dPcuvWLbG3twedDxMTE2nYsKGcPXv2X7tW5syZ07QJUlJS5P37918lE5YrV+6bOjSavNbvuJ7I3/evVKlSUqpUKenZs6eEhYWl+QJdvHhRsmXLJjVq1BBLS0spX778d++3pq6naeVgTV5P0+/t9u3b0r59ewWymilTJmnbtq2MHTtWHj58KEZGRlK7dm25cuWKBAYGfvXg1+S1vgxN2yN8bWiDiG8MTR78OXPmFBMTk3S10Rw/flyOHDny1X9/+fIlLQkULlxYnJ2dZc6cOTJz5kyFZsa3xp98PU0e+iJ/b+L/5E58YYkzdrKOjs53xXq+qK7euHFDNm7cKEOHDpX27dtLs2bNvvvZfvf1NP3e/jlSUlLk06dPX233MzIyksOHD/9r1zI3N5eQkBBp3ry5ZM2aVQoVKiQ3btwQCwsLeO2NGze+SSTU5LV+x/XUI2PGjFK1alWpWrWqvHv3TkJDQ+XUqVNy8uRJCQoKEh0dHVmzZs2/cj1NKwdr8nq/Q9WYcRO+zP1TAK9kyZJy6tSpf+1aIpq3R/ja0AYR3xiaPPjNzMwkJiYmXa1DYWFh3/x3fX19iY6Opv+mo6Mj06dPFxcXF3F1dQVXv/9r19P0of9FTOrLyJIlizRq1IheLzExMd18gS+qq4cPH06T6P0eJP1vXU+T17p7925a73y2bNnSNmL1eP78+XclzTV5rQ4dOoiTk5MsWrRI7O3tpXfv3uLq6iofP36UOnXqpPEOjh8/LmfOnPmm2Jwmr/U7rvetkS1bNrGyshIrKyt58eKFhISEpOvA0dT1vigHV6tWTfLmzatQDq5cuXJagPRFOfiL8+a/cT1Nv7eSJUvKkSNH0sS9RP4uV+3bt08yZcqkKCG+evXqm8+wJq/1ZWjaHuFrQxtEfGNo8uA3MzOT8PBwef78+XcFjHLkyPFNhnSZMmXkzJkz0q1bN0quyZEjh0yZMkUWL16cLmj0T76epg99U1NTuXPnTtrPWbNmlb59+9LX3rx5U4yNjb95vX+OX1Vd/Z3X09S1Dh48KAcPHkz7+dKlS2JtbQ2vu3379jflzDV9rWLFism4ceNkxYoVMnLkyLRg8/Dhw4Bi1K9fX9q2bfuvXOt3XC+9I0+ePNKsWTONIE/pvZ6mlYM1eT1NvzcHBweZOnWqDBs2TMqXLy9ZsmSRO3fuSGxsrNjZ2Sm0MMLDw78prKXJa30ZX+wRLCwsvqkDkV57hK8NbYvnN8bOnTvFx8dH1q5d+92DPyAgQPbv3y8rVqyg//5Fw0BXV/eXW2vu3r0re/fulZYtW35TgOnTp0/i4eEhDx48SGPR/1+73qJFi+T9+/cyceLEr17ny3B2dpYMGTIouBLq8ejRI4mPj5fKlSt/81ovXryQtWvXSu3ataV27drf/dts/Izq6r91vZ+51o0bN2AuU6ZMcI9fvHghS5YsEQsLi68eOJq81j/H27dv5eTJk3Lt2jUQTDI1NZXatWunWzBNk9fS5PVWrlwpjRs3lhIlSqT7b/+b19O0crAmr6fp93bv3j3ZsWOH3Lp1Sz58+CCGhobSpEkTcPe8efOm5MuX75sdRpq8lsjfktZTp06VlJSUdNkjTJ8+PV3KsOqhDSK+MTR58GvHz41/89DXDu3QDu34bxr/hj2CNojQDu3QDu3QDu34Lx+/yx5BG0Roh3Zoh3Zoh3b8D49fUVz+Oe1M7dAO7dAO7dAO7fivGP7+/ukWhlMPbRChHdqhHdqhHdqhHT81tGxB7dAO7dAO7dCO/7KhScXlbw1tEKEd2qEd2qEd2vFfNjSpuPytoQ0itEM7tEM7tEM7/suGJhWXvzW0QYR2aId2aId2aMd/2dCk4vK3hpZYqR3aoR3aoR3a8V82zMzM5NmzZ/L8+fPvvvZ7VgvfGlqdCO3QDu3QDu3Qjv+y8W8pLmuDCO3QDu3QDu3QDu34qaEtZ2iHdmiHdmiHdmjHTw1tEKEd2qEd2qEd2qEdPzW0QYR2aId2aId2aId2/NTQBhHaoR3aoR3aoR3a8VNDG0Roh3Zoh3Zoh3Zox08NbRChHdqhHdqhHdqhHT81tEGEdmiHdmiHdmiHdvzU+H8SEiFKcrnFggAAAABJRU5ErkJggg==",
-                        "text/plain": [
-                            "<Figure size 640x480 with 1 Axes>"
-                        ]
-                    },
-                    "metadata": {},
-                    "output_type": "display_data"
-                }
-            ],
-            "source": [
-                "import seaborn as sns\n",
-                "import numpy as np\n",
-                "data = np.argsort(-local_results['LinearRegression']['local_importances'].values)\n",
-                "sns.heatmap(data, cmap='Blues', cbar=False, yticklabels=False)"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 25,
-            "metadata": {},
-            "outputs": [
-                {
-                    "data": {
-                        "image/png": "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",
-                        "text/plain": [
-                            "<Figure size 2500x500 with 4 Axes>"
-                        ]
-                    },
-                    "metadata": {},
-                    "output_type": "display_data"
-                }
-            ],
-            "source": [
-                "import seaborn as sns\n",
-                "import matplotlib.pyplot as plt\n",
-                "from utils import plot_feature_ranking\n",
-                "\n",
-                "plt.figure(figsize=(25, 5))\n",
-                "for i,(model_name,result) in enumerate(local_results.items()):\n",
-                "    plt.subplot(1,4,i+1)\n",
-                "    frs = local_model_metrics[model_name].loc['Feature Rank Stability','Value']\n",
-                "    title = f\"{model_name} [frs={frs:.2f}]\"\n",
-                "    plot_feature_ranking(result['local_importances'], title)\n",
-                "plt.savefig('local_feature_ranking.png',bbox_inches='tight')"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "metadata": {},
-            "source": [
-                "# Surrogate Analysis"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 26,
-            "metadata": {},
-            "outputs": [
-                {
-                    "data": {
-                        "text/html": [
-                            "<div>\n",
-                            "<style scoped>\n",
-                            "    .dataframe tbody tr th:only-of-type {\n",
-                            "        vertical-align: middle;\n",
-                            "    }\n",
-                            "\n",
-                            "    .dataframe tbody tr th {\n",
-                            "        vertical-align: top;\n",
-                            "    }\n",
-                            "\n",
-                            "    .dataframe thead th {\n",
-                            "        text-align: right;\n",
-                            "    }\n",
-                            "</style>\n",
-                            "<table border=\"1\" class=\"dataframe\">\n",
-                            "  <thead>\n",
-                            "    <tr style=\"text-align: right;\">\n",
-                            "      <th></th>\n",
-                            "      <th>RandomForestRegressor</th>\n",
-                            "      <th>BayesianRidge</th>\n",
-                            "      <th>LinearRegression</th>\n",
-                            "      <th>MLPRegressor</th>\n",
-                            "      <th>Reference</th>\n",
-                            "    </tr>\n",
-                            "  </thead>\n",
-                            "  <tbody>\n",
-                            "    <tr>\n",
-                            "      <th>MSE Degradation</th>\n",
-                            "      <td>1.179896</td>\n",
-                            "      <td>0.110359</td>\n",
-                            "      <td>0.138437</td>\n",
-                            "      <td>1.764981</td>\n",
-                            "      <td>0.0</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>Surrogate Fidelity</th>\n",
-                            "      <td>0.136185</td>\n",
-                            "      <td>0.143809</td>\n",
-                            "      <td>0.166739</td>\n",
-                            "      <td>0.190388</td>\n",
-                            "      <td>0.0</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>Features Stability</th>\n",
-                            "      <td>1.000000</td>\n",
-                            "      <td>0.998020</td>\n",
-                            "      <td>0.996040</td>\n",
-                            "      <td>0.990099</td>\n",
-                            "      <td>1.0</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>Feature Importances Stability</th>\n",
-                            "      <td>0.211694</td>\n",
-                            "      <td>0.995574</td>\n",
-                            "      <td>0.985371</td>\n",
-                            "      <td>0.664522</td>\n",
-                            "      <td>1.0</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>Spread Divergence</th>\n",
-                            "      <td>0.242259</td>\n",
-                            "      <td>0.159442</td>\n",
-                            "      <td>0.185677</td>\n",
-                            "      <td>0.324894</td>\n",
-                            "      <td>0.0</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>Number of Features</th>\n",
-                            "      <td>101.000000</td>\n",
-                            "      <td>101.000000</td>\n",
-                            "      <td>101.000000</td>\n",
-                            "      <td>100.000000</td>\n",
-                            "      <td>1.0</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>Number of Rules</th>\n",
-                            "      <td>1001.000000</td>\n",
-                            "      <td>1007.000000</td>\n",
-                            "      <td>1010.000000</td>\n",
-                            "      <td>1013.000000</td>\n",
-                            "      <td>1.0</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>Tree Depth Variance</th>\n",
-                            "      <td>10.379319</td>\n",
-                            "      <td>5.900853</td>\n",
-                            "      <td>12.685172</td>\n",
-                            "      <td>18.820838</td>\n",
-                            "      <td>0.0</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>Weighted Average Explainability Score</th>\n",
-                            "      <td>11.822886</td>\n",
-                            "      <td>10.997021</td>\n",
-                            "      <td>11.885149</td>\n",
-                            "      <td>13.677196</td>\n",
-                            "      <td>0.0</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>Weighted Average Depth</th>\n",
-                            "      <td>12.880597</td>\n",
-                            "      <td>11.766634</td>\n",
-                            "      <td>12.627723</td>\n",
-                            "      <td>14.292201</td>\n",
-                            "      <td>0.0</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>MSE</th>\n",
-                            "      <td>0.002590</td>\n",
-                            "      <td>0.016753</td>\n",
-                            "      <td>0.016081</td>\n",
-                            "      <td>0.000621</td>\n",
-                            "      <td>0.0</td>\n",
-                            "    </tr>\n",
-                            "  </tbody>\n",
-                            "</table>\n",
-                            "</div>"
-                        ],
-                        "text/plain": [
-                            "                                       RandomForestRegressor  BayesianRidge  \\\n",
-                            "MSE Degradation                                     1.179896       0.110359   \n",
-                            "Surrogate Fidelity                                  0.136185       0.143809   \n",
-                            "Features Stability                                  1.000000       0.998020   \n",
-                            "Feature Importances Stability                       0.211694       0.995574   \n",
-                            "Spread Divergence                                   0.242259       0.159442   \n",
-                            "Number of Features                                101.000000     101.000000   \n",
-                            "Number of Rules                                  1001.000000    1007.000000   \n",
-                            "Tree Depth Variance                                10.379319       5.900853   \n",
-                            "Weighted Average Explainability Score              11.822886      10.997021   \n",
-                            "Weighted Average Depth                             12.880597      11.766634   \n",
-                            "MSE                                                 0.002590       0.016753   \n",
-                            "\n",
-                            "                                       LinearRegression  MLPRegressor  \\\n",
-                            "MSE Degradation                                0.138437      1.764981   \n",
-                            "Surrogate Fidelity                             0.166739      0.190388   \n",
-                            "Features Stability                             0.996040      0.990099   \n",
-                            "Feature Importances Stability                  0.985371      0.664522   \n",
-                            "Spread Divergence                              0.185677      0.324894   \n",
-                            "Number of Features                           101.000000    100.000000   \n",
-                            "Number of Rules                             1010.000000   1013.000000   \n",
-                            "Tree Depth Variance                           12.685172     18.820838   \n",
-                            "Weighted Average Explainability Score         11.885149     13.677196   \n",
-                            "Weighted Average Depth                        12.627723     14.292201   \n",
-                            "MSE                                            0.016081      0.000621   \n",
-                            "\n",
-                            "                                       Reference  \n",
-                            "MSE Degradation                              0.0  \n",
-                            "Surrogate Fidelity                           0.0  \n",
-                            "Features Stability                           1.0  \n",
-                            "Feature Importances Stability                1.0  \n",
-                            "Spread Divergence                            0.0  \n",
-                            "Number of Features                           1.0  \n",
-                            "Number of Rules                              1.0  \n",
-                            "Tree Depth Variance                          0.0  \n",
-                            "Weighted Average Explainability Score        0.0  \n",
-                            "Weighted Average Depth                       0.0  \n",
-                            "MSE                                          0.0  "
-                        ]
-                    },
-                    "execution_count": 26,
-                    "metadata": {},
-                    "output_type": "execute_result"
-                }
-            ],
-            "source": [
-                "from holisticai.utils import concatenate_metrics\n",
-                "from holisticai.explainability.metrics import surrogate as surrogate_metrics\n",
-                "\n",
-                "surrogate_results = {}\n",
-                "surrogates = {}\n",
-                "for model_name,model in models.items():\n",
-                "    \n",
-                "    y_pred = model.predict(Xt_train)\n",
-                "    acc = mean_squared_error(train['y'], y_pred)\n",
-                "\n",
-                "    metrics, surrogate = surrogate_metrics.regression_surrogate_explainability_metrics(Xt_train, train['y'], y_pred, surrogate_type=\"tree\", metric_type=\"all\", return_surrogate_model=True)\n",
-                "\n",
-                "    metrics.at['MSE', 'Value'] = acc\n",
-                "    metrics.at['MSE', 'Reference'] = 0\n",
-                "\n",
-                "    surrogate_results[model_name] = metrics\n",
-                "    surrogates[model_name] = surrogate\n",
-                "\n",
-                "concatenate_metrics(surrogate_results)    "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 27,
-            "metadata": {},
-            "outputs": [
-                {
-                    "name": "stdout",
-                    "output_type": "stream",
-                    "text": [
-                        "\\begin{tabular}{lrrrrr}\n",
-                        "\\toprule\n",
-                        " & RandomForestRegressor & BayesianRidge & LinearRegression & MLPRegressor & Reference \\\\\n",
-                        "\\midrule\n",
-                        "Surrogate Fidelity & 0.1362 & 0.1438 & 0.1667 & 0.1904 & 0.0000 \\\\\n",
-                        "MSE Degradation & 1.1799 & 0.1104 & 0.1384 & 1.7650 & 0.0000 \\\\\n",
-                        "Features Stability & 1.0000 & 0.9980 & 0.9960 & 0.9901 & 1.0000 \\\\\n",
-                        "Feature Importances Stability & 0.2117 & 0.9956 & 0.9854 & 0.6645 & 1.0000 \\\\\n",
-                        "Spread Divergence & 0.2423 & 0.1594 & 0.1857 & 0.3249 & 0.0000 \\\\\n",
-                        "MSE & 0.0026 & 0.0168 & 0.0161 & 0.0006 & 0.0000 \\\\\n",
-                        "\\bottomrule\n",
-                        "\\end{tabular}\n",
-                        "\n"
-                    ]
-                }
-            ],
-            "source": [
-                "model_names = ['RandomForestRegressor', 'BayesianRidge', 'LinearRegression', 'MLPRegressor']\n",
-                "metric_names = [\"Surrogate Fidelity\", \"MSE Degradation\", \"Features Stability\",\"Feature Importances Stability\",\"Spread Divergence\", \"MSE\"]\n",
-                "print(concatenate_metrics(surrogate_results).loc[metric_names].to_latex(float_format=\"%.4f\"))"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 29,
-            "metadata": {},
-            "outputs": [
-                {
-                    "name": "stdout",
-                    "output_type": "stream",
-                    "text": [
-                        "\\begin{tabular}{lrrrrrr}\n",
-                        "\\toprule\n",
-                        " & Surrogate Fidelity & MSE Degradation & Features Stability & Feature Importances Stability & Spread Divergence & MSE \\\\\n",
-                        "\\midrule\n",
-                        "RandomForestRegressor & 0.136 & 1.180 & 1.000 & 0.212 & 0.242 & 0.003 \\\\\n",
-                        "BayesianRidge & 0.144 & 0.110 & 0.998 & 0.996 & 0.159 & 0.017 \\\\\n",
-                        "LinearRegression & 0.167 & 0.138 & 0.996 & 0.985 & 0.186 & 0.016 \\\\\n",
-                        "MLPRegressor & 0.190 & 1.765 & 0.990 & 0.665 & 0.325 & 0.001 \\\\\n",
-                        "\\bottomrule\n",
-                        "\\end{tabular}\n",
-                        "\n"
-                    ]
-                }
-            ],
-            "source": [
-                "model_names = ['RandomForestRegressor', 'BayesianRidge', 'LinearRegression', 'MLPRegressor']\n",
-                "metric_names = [\"Surrogate Fidelity\", \"MSE Degradation\", \"Features Stability\",\"Feature Importances Stability\",\"Spread Divergence\", \"MSE\"]\n",
-                "print(concatenate_metrics(surrogate_results).T.loc[model_names, metric_names].to_latex(float_format=\"%.3f\"))"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 30,
-            "metadata": {},
-            "outputs": [
-                {
-                    "data": {
-                        "image/png": "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",
-                        "text/plain": [
-                            "<Figure size 2000x1000 with 4 Axes>"
-                        ]
-                    },
-                    "metadata": {},
-                    "output_type": "display_data"
-                }
-            ],
-            "source": [
-                "from sklearn.tree import plot_tree\n",
-                "_,axes = plt.subplots(1,4, figsize=(20,10))\n",
-                "\n",
-                "\n",
-                "for i,(model_name,surrogate) in enumerate(surrogates.items()):\n",
-                "    plt.subplot(1,len(surrogates),i+1)\n",
-                "    plot_tree(surrogate._surrogate, filled=True, ax=axes[i])\n",
-                "    axes[i].set_title(model_name)\n",
-                "plt.savefig(\"surrogate_tree.png\")"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 31,
-            "metadata": {},
-            "outputs": [
-                {
-                    "data": {
-                        "text/html": [
-                            "<div>\n",
-                            "<style scoped>\n",
-                            "    .dataframe tbody tr th:only-of-type {\n",
-                            "        vertical-align: middle;\n",
-                            "    }\n",
-                            "\n",
-                            "    .dataframe tbody tr th {\n",
-                            "        vertical-align: top;\n",
-                            "    }\n",
-                            "\n",
-                            "    .dataframe thead th {\n",
-                            "        text-align: right;\n",
-                            "    }\n",
-                            "</style>\n",
-                            "<table border=\"1\" class=\"dataframe\">\n",
-                            "  <thead>\n",
-                            "    <tr style=\"text-align: right;\">\n",
-                            "      <th></th>\n",
-                            "      <th>RandomForestRegressor</th>\n",
-                            "      <th>BayesianRidge</th>\n",
-                            "      <th>LinearRegression</th>\n",
-                            "      <th>MLPRegressor</th>\n",
-                            "      <th>Reference</th>\n",
-                            "    </tr>\n",
-                            "  </thead>\n",
-                            "  <tbody>\n",
-                            "    <tr>\n",
-                            "      <th>MSE Degradation</th>\n",
-                            "      <td>1.562385</td>\n",
-                            "      <td>0.306484</td>\n",
-                            "      <td>0.324200</td>\n",
-                            "      <td>1.884834</td>\n",
-                            "      <td>0.0</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>Surrogate Fidelity</th>\n",
-                            "      <td>0.369312</td>\n",
-                            "      <td>0.369902</td>\n",
-                            "      <td>0.411933</td>\n",
-                            "      <td>0.477368</td>\n",
-                            "      <td>0.0</td>\n",
-                            "    </tr>\n",
-                            "    <tr>\n",
-                            "      <th>MSE</th>\n",
-                            "      <td>0.002590</td>\n",
-                            "      <td>0.016753</td>\n",
-                            "      <td>0.016081</td>\n",
-                            "      <td>0.000621</td>\n",
-                            "      <td>0.0</td>\n",
-                            "    </tr>\n",
-                            "  </tbody>\n",
-                            "</table>\n",
-                            "</div>"
-                        ],
-                        "text/plain": [
-                            "                    RandomForestRegressor  BayesianRidge  LinearRegression  \\\n",
-                            "MSE Degradation                  1.562385       0.306484          0.324200   \n",
-                            "Surrogate Fidelity               0.369312       0.369902          0.411933   \n",
-                            "MSE                              0.002590       0.016753          0.016081   \n",
-                            "\n",
-                            "                    MLPRegressor  Reference  \n",
-                            "MSE Degradation         1.884834        0.0  \n",
-                            "Surrogate Fidelity      0.477368        0.0  \n",
-                            "MSE                     0.000621        0.0  "
-                        ]
-                    },
-                    "execution_count": 31,
-                    "metadata": {},
-                    "output_type": "execute_result"
-                }
-            ],
-            "source": [
-                "from holisticai.explainability.metrics import surrogate as surrogate_metrics\n",
-                "\n",
-                "surrogate_results = {}\n",
-                "surrogates = {}\n",
-                "for model_name,model in models.items():\n",
-                "    \n",
-                "    y_pred = model.predict(Xt_train)\n",
-                "    acc = mean_squared_error(train['y'], y_pred)\n",
-                "\n",
-                "    metrics, surrogate = surrogate_metrics.regression_surrogate_explainability_metrics(Xt_train, train['y'], y_pred, surrogate_type=\"shallow_tree\", metric_type=\"performance\", return_surrogate_model=True)\n",
-                "\n",
-                "    metrics.at['MSE', 'Value'] = acc\n",
-                "    metrics.at['MSE', 'Reference'] = 0\n",
-                "\n",
-                "    surrogate_results[model_name] = metrics\n",
-                "    surrogates[model_name] = surrogate\n",
-                "\n",
-                "concatenate_metrics(surrogate_results) "
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": null,
-            "metadata": {},
-            "outputs": [],
-            "source": []
-        }
-    ],
-    "metadata": {
-        "kernelspec": {
-            "display_name": "Python 3 (ipykernel)",
-            "language": "python",
-            "name": "python3"
-        },
-        "language_info": {
-            "codemirror_mode": {
-                "name": "ipython",
-                "version": 3
-            },
-            "file_extension": ".py",
-            "mimetype": "text/x-python",
-            "name": "python",
-            "nbconvert_exporter": "python",
-            "pygments_lexer": "ipython3",
-            "version": "3.10.14"
-        },
-        "orig_nbformat": 4
-    },
-    "nbformat": 4,
-    "nbformat_minor": 2
-}
diff --git a/pyproject.toml b/pyproject.toml
index f0cbe7c8..ddcad07e 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -30,6 +30,7 @@ dependencies = [
   "seaborn",
   "numpy>=1.25",
   "pybind11>=2.12",
+  "pyarrow"
   ]
 
 [project.optional-dependencies]
@@ -83,6 +84,7 @@ dependencies = [
   "pandas",
   "numpy==1.26",
   "pybind11>=2.12",
+  "pyarrow",
 
   "jax",
   "jaxopt",
diff --git a/src/holisticai/datasets/__init__.py b/src/holisticai/datasets/__init__.py
index be92c9d1..30bbc7d8 100644
--- a/src/holisticai/datasets/__init__.py
+++ b/src/holisticai/datasets/__init__.py
@@ -2,44 +2,16 @@
 The :mod:`holisticai.datasets` module includes dataloaders for quick experimentation
 """
 
-from holisticai.datasets._dataloaders import (
-    load_acsincome,
-    load_acspublic,
-    load_adult,
-    load_bank_marketing,
-    load_census_kdd,
-    load_compas_is_recid,
-    load_compas_two_year_recid,
-    load_diabetes,
-    load_german_credit,
-    load_heart,
-    load_last_fm,
-    load_law_school,
-    load_student,
-    load_us_crime,
-)
+from holisticai.datasets._dataloaders import load_hai_datasets
 from holisticai.datasets._dataset import DataLoader, Dataset, DatasetDict, GroupByDataset, concatenate_datasets
 from holisticai.datasets._load_dataset import load_dataset
 
 __all__ = [
     "load_dataset",
+    "load_hai_datasets",
     "Dataset",
     "DatasetDict",
     "GroupByDataset",
     "DataLoader",
     "concatenate_datasets",
-    "load_adult",
-    "load_last_fm",
-    "load_law_school",
-    "load_heart",
-    "load_student",
-    "load_us_crime",
-    "load_german_credit",
-    "load_census_kdd",
-    "load_bank_marketing",
-    "load_compas_two_year_recid",
-    "load_compas_is_recid",
-    "load_diabetes",
-    "load_acsincome",
-    "load_acspublic",
 ]
diff --git a/src/holisticai/datasets/_dataloaders.py b/src/holisticai/datasets/_dataloaders.py
index 6752d27d..f2c9b063 100644
--- a/src/holisticai/datasets/_dataloaders.py
+++ b/src/holisticai/datasets/_dataloaders.py
@@ -4,9 +4,6 @@
 
 import pandas as pd
 
-# sklearn imports
-from sklearn.datasets import fetch_openml
-
 
 def get_data_home(data_home=None):
     """
@@ -34,151 +31,50 @@ def get_data_home(data_home=None):
     return data_home
 
 
-def load_openml(name, version, data_home=None, return_X_y=False, as_frame=True):
+def load_hai_datasets(dataset_name, data_home=None):
     """
-    Generic function to load datasets from OpenML.
+    Generic function to load datasets from holisticai datasets repository.
+
+    Available datasets:
+    - adult
+    - law_school
+    - student
+    - lastfm
+    - us_crime
+    - clinical_records
+    - acsincome
+    - acspublic
+    - compass_two_year_recid
+    - compass_is_recid
+    - german_credit
+    - bank_marketing
+    - census_kdd
+    - diabetes
+    - mw_small
+    - mw_medium
 
     Parameters
     ----------
     name : str
-        Name of the dataset on OpenML.
+        Name of the dataset.
     version : int
         Version of the dataset.
     data_home : str, optional
         The directory to which the data is downloaded. If None, we download
         to the default data home directory.
-    return_X_y : bool, default=False
-        If True, returns ``(data, target)`` instead of a Bunch object.
-    as_frame : bool, default=True
-        If True, the data is a pandas DataFrame including columns with
-        appropriate dtypes (numeric).
-
     Returns
     -------
-    data : sklearn.utils.Bunch or tuple
-        Dataset object or (data, target) tuple if return_X_y is True.
+    data : pd.DataFrame
+        The dataset from holisticai datasets.
+
+    References
+    ----------
+    .. [1] https://huggingface.co/datasets/holistic-ai/holisticai-datasets
+
     """
     if data_home is None:
         data_home = get_data_home()
 
-    return fetch_openml(
-        name=name,
-        version=version,
-        data_home=data_home,
-        return_X_y=return_X_y,
-        as_frame=as_frame,
+    return pd.read_parquet(
+        f"https://huggingface.co/datasets/holistic-ai/holisticai-datasets/resolve/main/data/{dataset_name}/{dataset_name}_dataset.parquet"
     )
-
-
-def load_student(data_home=None, return_X_y=False, as_frame=True):
-    return load_openml("UCI-student-performance-mat", 1, data_home, return_X_y, as_frame)
-
-
-def load_adult(data_home=None, return_X_y=False, as_frame=True):
-    return load_openml("adult", 2, data_home, return_X_y, as_frame)
-
-
-def load_law_school(data_home=None, return_X_y=False, as_frame=True):
-    return load_openml("law-school-admission-bianry", 1, data_home, return_X_y, as_frame)
-
-
-def load_last_fm(data_home=None, return_X_y=False, as_frame=True):
-    return load_openml("LastFM_dataset", 1, data_home, return_X_y, as_frame)
-
-
-def load_us_crime(data_home=None, return_X_y=False, as_frame=True):
-    return load_openml("us_crime", 1, data_home, return_X_y, as_frame)
-
-
-def load_heart(data_home=None, return_X_y=False, as_frame=True):
-    return load_openml("heart-failure", 1, data_home, return_X_y, as_frame)
-
-
-def load_german_credit(data_home=None, return_X_y=False, as_frame=True):
-    return load_openml("German-Credit-Risk-with-Target", 1, data_home, return_X_y, as_frame)
-
-
-def load_census_kdd(data_home=None, return_X_y=False, as_frame=True):
-    return load_openml("Census-Income-KDD", 3, data_home, return_X_y, as_frame)
-
-
-def load_bank_marketing(data_home=None, return_X_y=False, as_frame=True):
-    return load_openml("bank-marketing", 9, data_home, return_X_y, as_frame)
-
-
-def load_compas_two_year_recid():
-    data = pd.read_csv(
-        "https://raw.githubusercontent.com/propublica/compas-analysis/master/compas-scores-two-years.csv"
-    )
-    df = data.loc[
-        (data["days_b_screening_arrest"] <= 30)
-        & (data["days_b_screening_arrest"] >= -30)
-        & (data["is_recid"] != -1)
-        & (data["c_charge_degree"] != "O")
-        & (data["score_text"] != "N/A"),
-        [
-            "age",
-            "c_charge_degree",
-            "race",
-            "age_cat",
-            "score_text",
-            "sex",
-            "priors_count",
-            "days_b_screening_arrest",
-            "decile_score",
-            "juv_fel_count",
-            "juv_misd_count",
-            "juv_other_count",
-            "v_type_of_assessment",
-            "c_days_from_compas",
-            "v_score_text",
-            "v_decile_score",
-            "two_year_recid",
-        ],
-    ]
-    return df
-
-
-def load_compas_is_recid():
-    data = pd.read_csv(
-        "https://raw.githubusercontent.com/propublica/compas-analysis/master/compas-scores-two-years.csv"
-    )
-    df = data.loc[
-        (data["days_b_screening_arrest"] <= 30)
-        & (data["days_b_screening_arrest"] >= -30)
-        & (data["is_recid"] != -1)
-        & (data["c_charge_degree"] != "O")
-        & (data["score_text"] != "N/A"),
-        [
-            "age",
-            "c_charge_degree",
-            "race",
-            "age_cat",
-            "score_text",
-            "sex",
-            "priors_count",
-            "days_b_screening_arrest",
-            "decile_score",
-            "juv_fel_count",
-            "juv_misd_count",
-            "juv_other_count",
-            "v_type_of_assessment",
-            "c_days_from_compas",
-            "v_score_text",
-            "v_decile_score",
-            "is_recid",
-        ],
-    ]
-    return df
-
-
-def load_diabetes(data_home=None, return_X_y=False, as_frame=True):
-    return load_openml("Diabetes-130-Hospitals_(Fairlearn)", 2, data_home, return_X_y, as_frame)
-
-
-def load_acsincome(data_home=None, return_X_y=False, as_frame=True):
-    return load_openml("ACSIncome", 3, data_home, return_X_y, as_frame)
-
-
-def load_acspublic(data_home=None, return_X_y=False, as_frame=True):
-    return load_openml("ACSPublicCoverage", 2, data_home, return_X_y, as_frame)
diff --git a/src/holisticai/datasets/_load_dataset.py b/src/holisticai/datasets/_load_dataset.py
index a1043e29..aa0cb1f8 100644
--- a/src/holisticai/datasets/_load_dataset.py
+++ b/src/holisticai/datasets/_load_dataset.py
@@ -5,21 +5,7 @@
 import numpy as np
 import pandas as pd
 
-from holisticai.datasets._dataloaders import (
-    load_acsincome,
-    load_acspublic,
-    load_adult,
-    load_bank_marketing,
-    load_census_kdd,
-    load_compas_is_recid,
-    load_compas_two_year_recid,
-    load_diabetes,
-    load_german_credit,
-    load_last_fm,
-    load_law_school,
-    load_student,
-    load_us_crime,
-)
+from holisticai.datasets._dataloaders import load_hai_datasets
 from holisticai.datasets._dataset import Dataset
 from holisticai.datasets._utils import convert_float_to_categorical, get_protected_values
 
@@ -76,8 +62,8 @@ def load_adult_dataset(protected_attribute: Optional[Literal["race", "sex"]] = "
     }
     output_variable = "class"
 
-    data = load_adult()
-    df = pd.concat([data["data"], data["target"]], axis=1)
+    data = load_hai_datasets(dataset_name="adult")
+    df = data.copy()
     df = df.dropna().reset_index(drop=True)
     p_attrs = df[sensitive_attribute]
     if preprocessed:
@@ -111,11 +97,11 @@ def load_adult_dataset(protected_attribute: Optional[Literal["race", "sex"]] = "
 
 
 def load_law_school_dataset(protected_attribute: Optional[Literal["race", "sex"]] = "sex", preprocessed: bool = True):
-    bunch = load_law_school()
+    data = load_hai_datasets(dataset_name="law_school")
     sensitive_attribute = ["race1", "gender", "age"]
     output_variable = "bar"
     drop_columns = ["ugpagt3", "bar", *sensitive_attribute]
-    df = bunch["frame"]
+    df = data.copy()
     df = df.dropna()
     p_attrs = df[sensitive_attribute]
     y = df[output_variable]
@@ -150,8 +136,8 @@ def load_student_multiclass_dataset(
     sensitive_attributes = ["sex", "address", "Mjob", "Fjob"]
     output_column = "G3"
     drop_columns = ["G1", "G2", "G3", "sex", "address", "Mjob", "Fjob"]
-    bunch = load_student()
-    df = bunch["frame"]
+    data = load_hai_datasets(dataset_name="student")
+    df = data.copy()
 
     # we don't want to encode protected attributes
     df = df.dropna()
@@ -204,9 +190,9 @@ def load_student_dataset(
 
     sensitive_attributes = ["sex", "address", "Mjob", "Fjob"]
     drop_columns = ["G1", "G2", "G3", "sex", "address", "Mjob", "Fjob"]
-    bunch = load_student()
+    data = load_hai_datasets(dataset_name="student")
 
-    df = bunch["frame"]
+    df = data.copy()
     for col in ["sex", "address", "Mjob", "Fjob"]:
         df[col] = df[col].apply(lambda x: x.replace("'", ""))
 
@@ -250,7 +236,7 @@ def load_student_dataset(
 
 def load_lastfm_dataset():
     """
-    Processes the lastfm dataset and returns the data, output variable, protected group A and protected group B as numerical arrays
+    Processes the last_fm dataset and returns the data, output variable, protected group A and protected group B as numerical arrays
 
     Parameters
     ----------
@@ -264,8 +250,8 @@ def load_lastfm_dataset():
     p_attr : np.ndarray
         The protected attribute
     """
-    bunch = load_last_fm()
-    df = bunch["frame"]
+    data = load_hai_datasets(dataset_name="lastfm")
+    df = data.copy()
     user_column = "user"
     item_column = "artist"
     protected_attribute = "sex"
@@ -305,12 +291,12 @@ def load_us_crime_dataset(preprocessed=True, protected_attribute: Optional[Liter
         A tuple with two lists containing the data, output variable, protected group A and protected group B
     """
     min_nonan_values = 1000
-    data = load_us_crime()
+    data = load_hai_datasets(dataset_name="us_crime")
     protected_attributes = ["racePctWhite"]
     mapping_name2column = {"race": "racePctWhite"}
     protected_attribute_column = mapping_name2column.get(protected_attribute)
     output_variable = "ViolentCrimesPerPop"
-    df = pd.concat([data["data"], data["target"]], axis=1)
+    df = data.copy()
     df = df.iloc[:, [i for i, n in enumerate(df.isna().sum(axis=0).T.values) if n < min_nonan_values]]
     df = df.dropna()
     p_attrs = df[protected_attributes]
@@ -356,12 +342,12 @@ def load_us_crime_multiclass_dataset(preprocessed=True, protected_attribute: Opt
     tuple
         A tuple with two lists containing the data, output variable, protected group A and protected group B
     """
-    data = load_us_crime()
+    data = load_hai_datasets(dataset_name="us_crime")
     protected_attributes = ["racePctWhite"]
     mapping_name2column = {"race": "racePctWhite"}
     protected_attribute_column = mapping_name2column.get(protected_attribute)
     output_column = "ViolentCrimesPerPop"
-    df = pd.concat([data["data"], data["target"]], axis=1)
+    df = data.copy()
     remove_columns = [*protected_attributes, output_column]
     df = df.dropna()
     df.reset_index(drop=True, inplace=True)
@@ -408,9 +394,7 @@ def load_clinical_records_dataset(protected_attribute: Optional[Literal["sex"]]
     tuple
         A tuple with two lists containing the data, output variable, protected group A and protected group B
     """
-    df = pd.read_csv(
-        "https://archive.ics.uci.edu/ml/machine-learning-databases/00519/heart_failure_clinical_records_dataset.csv"
-    )
+    df = load_hai_datasets(dataset_name="clinical_records")
     protected_attributes = ["age", "sex"]
     output_variable = "DEATH_EVENT"
     drop_columns = ["age", "sex", "DEATH_EVENT"]
@@ -450,12 +434,12 @@ def load_german_credit_dataset(preprocessed=True, protected_attribute: Optional[
     tuple
         A tuple with two lists containing the data, output variable, protected group A and protected group B
     """
-    data = load_german_credit()
+    data = load_hai_datasets(dataset_name="german_credit")
     protected_attributes = ["Sex", "Age"]
     output_column = "Risk"
     # change risk to binary
-    data["target"] = data["target"].map({"good": 0, "bad": 1})
-    df = pd.concat([data["data"], data["target"]], axis=1)
+    data[output_column] = data[output_column].map({"good": 0, "bad": 1})
+    df = data.copy()
     remove_columns = [*protected_attributes, output_column]
     df = df.ffill()
     df.reset_index(drop=True, inplace=True)
@@ -500,12 +484,12 @@ def load_census_kdd_dataset(preprocessed=True, protected_attribute: Optional[Lit
     tuple
         A tuple with two lists containing the data, output variable, protected group A and protected group B
     """
-    data = load_census_kdd()
+    data = load_hai_datasets(dataset_name="census_kdd")
     protected_attributes = ["race", "sex"]
     output_column = "income_50k"
     # change risk to binary
-    data["target"] = data["target"].map({"' - 50000.'": 0, "' 50000+.'": 1})
-    df = pd.concat([data["data"], data["target"]], axis=1)
+    data[output_column] = data[output_column].map({"' - 50000.'": 0, "' 50000+.'": 1})
+    df = data.copy()
     remove_columns = [*protected_attributes, output_column]
     df = df.dropna(axis=0)
     df.reset_index(drop=True, inplace=True)
@@ -559,10 +543,10 @@ def load_bank_marketing_dataset(preprocessed=True, protected_attribute: Optional
     tuple
         A tuple with two lists containing the data, output variable, protected group A and protected group B
     """
-    data = load_bank_marketing()
+    data = load_hai_datasets(dataset_name="bank_marketing")
     protected_attributes = ["marital", "age"]
     output_column = "class"
-    data["target"] = data["target"].map({1: 0, 2: 1})
+    data[output_column] = data[output_column].map({1: 0, 2: 1})
 
     rename_columns = {
         "V1": "age",
@@ -582,10 +566,9 @@ def load_bank_marketing_dataset(preprocessed=True, protected_attribute: Optional
         "V15": "previous",
         "V16": "poutcome",
     }
-    data["data"] = data["data"].copy()
-    data["data"].rename(columns=rename_columns, inplace=True)
+    df = data.copy()
+    df.rename(columns=rename_columns, inplace=True)
 
-    df = pd.concat([data["data"], data["target"]], axis=1)
     df["marital"] = [1 if x == "married" else 0 for x in df["marital"]]
     remove_columns = [*protected_attributes, output_column]
     df = df.dropna(axis=0)
@@ -635,7 +618,8 @@ def load_compas_two_year_recid_dataset(
     tuple
         A tuple with two lists containing the data, output variable, protected group A and protected group B
     """
-    data = load_compas_two_year_recid()
+
+    data = load_hai_datasets(dataset_name="compas_two_year_recid")
     protected_attributes = ["race", "sex", "age"]
     output_column = "two_year_recid"
 
@@ -690,10 +674,9 @@ def load_compas_is_recid_dataset(preprocessed=True, protected_attribute: Optiona
     tuple
         A tuple with two lists containing the data, output variable, protected group A and protected group B
     """
-    data = load_compas_is_recid()
+    data = load_hai_datasets(dataset_name="compas_is_recid")
     protected_attributes = ["race", "sex", "age"]
     output_column = "is_recid"
-
     df = data.copy()
     remove_columns = [*protected_attributes, output_column]
     df.reset_index(drop=True, inplace=True)
@@ -744,12 +727,12 @@ def load_diabetes_dataset(preprocessed=True, protected_attribute: Optional[Liter
     tuple
         A tuple with two lists containing the data, output variable, protected group A and protected group B
     """
-    data = load_diabetes()
+    data = load_hai_datasets(dataset_name="diabetes")
     protected_attributes = ["race", "gender", "age"]
     output_column = "readmit_30_days"
-    data["target"] = data["target"].astype(int)
+    data[output_column] = data[output_column].astype(int)
 
-    df = pd.concat([data["data"], data["target"]], axis=1)
+    df = data.copy()
     df["race"] = ["Caucasian" if x == "Caucasian" else "Non-Caucasian" for x in df["race"]]
     # drop gender row with "unknown/invalid" value
     df = df[~df["gender"].isin(["Unknown/Invalid"])]
@@ -802,12 +785,12 @@ def load_acsincome_dataset(preprocessed=True, protected_attribute: Optional[Lite
     tuple
         A tuple with two lists containing the data, output variable, protected group A and protected group B
     """
-    data = load_acsincome()
+    data = load_hai_datasets(dataset_name="acsincome")
     protected_attributes = ["AGEP", "RAC1P", "SEX"]
     output_column = "PINCP"  # Total person's income
-    data["target"] = (data["target"] > 50000).astype(int)  # map income to binary
+    data[output_column] = (data[output_column] > 50000).astype(int)  # map income to binary
 
-    df = pd.concat([data["data"], data["target"]], axis=1)
+    df = data.copy()
     df["RAC1P"] = ["White" if x == 1 else "Non-White" for x in df["RAC1P"]]
     remove_columns = [*protected_attributes, output_column]
     df.reset_index(drop=True, inplace=True)
@@ -858,11 +841,11 @@ def load_acspublic_dataset(preprocessed=True, protected_attribute: Optional[Lite
     tuple
         A tuple with two lists containing the data, output variable, protected group A and protected group B
     """
-    data = load_acspublic()
+    data = load_hai_datasets(dataset_name="acspublic")
     protected_attributes = ["AGEP", "RAC1P", "SEX"]
     output_column = "PUBCOV"  # public health coverage : an individual's label is 1 if PUBCOV == 1 (with public health coverage), otherwise 0.
 
-    df = pd.concat([data["data"], data["target"]], axis=1)
+    df = data.copy()
     df["RAC1P"] = ["White" if x == 1 else "Non-White" for x in df["RAC1P"]]
     remove_columns = [*protected_attributes, output_column]
     df.reset_index(drop=True, inplace=True)
@@ -896,6 +879,118 @@ def load_acspublic_dataset(preprocessed=True, protected_attribute: Optional[Lite
     return Dataset(X=X, y=y, p_attrs=p_attrs)
 
 
+def load_mw_medium_dataset(preprocessed=True, protected_attribute: Optional[Literal["race", "sex"]] = "race"):
+    """
+    Processes the Minimum Wage Medium dataset and returns the data, output variable, protected group A and protected group B as numerical arrays or as dataframe if needed
+    Target: contracted_hours
+
+    Parameters
+    ----------
+    preprocessed : bool
+        Whether to return the preprocessed X and y.
+    protected_attribute : str
+        If this parameter is set, the dataset will be returned with the protected attribute as a binary column group_a and group_b.
+        Otherwise, the dataset will be returned with the protected attribute as a column p_attrs.
+
+    Returns
+    -------
+    tuple
+        A tuple with two lists containing the data, output variable, protected group A and protected group B
+    """
+    data = load_hai_datasets(dataset_name="mw_medium")
+    protected_attributes = ["race", "sex", "age_group", "education_level", "age"]
+    output_column = "class"
+
+    df = data.copy()
+    remove_columns = [*protected_attributes, output_column]
+    df.reset_index(drop=True, inplace=True)
+    X = df.drop(columns=remove_columns)
+
+    if preprocessed:
+        for col in X.select_dtypes(include=["category", "object"]).columns:
+            X[col] = pd.factorize(X[col])[0]
+
+    p_attrs = df[protected_attributes]
+    y = df[output_column]
+
+    if protected_attribute is not None:
+        if protected_attribute == "sex":
+            ga_label = "Male"
+            gb_label = "Female"
+            group_a = pd.Series(df["sex"] == ga_label, name="group_a")
+            group_b = pd.Series(df["sex"] == gb_label, name="group_b")
+        elif protected_attribute == "race":
+            ga_label = "White"
+            gb_label = "Black"
+            group_a = pd.Series(df["race"] == ga_label, name="group_a")
+            group_b = pd.Series(df["race"] == gb_label, name="group_b")
+        else:
+            raise ValueError(
+                f"The protected attribute doesn't exist or not implemented. Please use: {protected_attribute}"
+            )
+
+    if protected_attribute is not None:
+        metadata = f"""{protected_attribute}: {{'group_a': '{ga_label}', 'group_b': '{gb_label}'}}"""
+        return Dataset(X=X, y=y, p_attrs=p_attrs, group_a=group_a, group_b=group_b, _metadata=metadata)
+    return Dataset(X=X, y=y, p_attrs=p_attrs)
+
+
+def load_mw_small_dataset(preprocessed=True, protected_attribute: Optional[Literal["race", "sex"]] = "race"):
+    """
+    Processes the Minimum Wage Small dataset and returns the data, output variable, protected group A and protected group B as numerical arrays or as dataframe if needed
+    Target: contracted_hours
+
+    Parameters
+    ----------
+    preprocessed : bool
+        Whether to return the preprocessed X and y.
+    protected_attribute : str
+        If this parameter is set, the dataset will be returned with the protected attribute as a binary column group_a and group_b.
+        Otherwise, the dataset will be returned with the protected attribute as a column p_attrs.
+
+    Returns
+    -------
+    tuple
+        A tuple with two lists containing the data, output variable, protected group A and protected group B
+    """
+    data = load_hai_datasets(dataset_name="mw_small")
+    protected_attributes = ["race", "sex", "age_group", "education_level", "age"]
+    output_column = "class"
+
+    df = data.copy()
+    remove_columns = [*protected_attributes, output_column]
+    df.reset_index(drop=True, inplace=True)
+    X = df.drop(columns=remove_columns)
+
+    if preprocessed:
+        for col in X.select_dtypes(include=["category", "object"]).columns:
+            X[col] = pd.factorize(X[col])[0]
+
+    p_attrs = df[protected_attributes]
+    y = df[output_column]
+
+    if protected_attribute is not None:
+        if protected_attribute == "sex":
+            ga_label = "Male"
+            gb_label = "Female"
+            group_a = pd.Series(df["sex"] == ga_label, name="group_a")
+            group_b = pd.Series(df["sex"] == gb_label, name="group_b")
+        elif protected_attribute == "race":
+            ga_label = "White"
+            gb_label = "Black"
+            group_a = pd.Series(df["race"] == ga_label, name="group_a")
+            group_b = pd.Series(df["race"] == gb_label, name="group_b")
+        else:
+            raise ValueError(
+                f"The protected attribute doesn't exist or not implemented. Please use: {protected_attribute}"
+            )
+
+    if protected_attribute is not None:
+        metadata = f"""{protected_attribute}: {{'group_a': '{ga_label}', 'group_b': '{gb_label}'}}"""
+        return Dataset(X=X, y=y, p_attrs=p_attrs, group_a=group_a, group_b=group_b, _metadata=metadata)
+    return Dataset(X=X, y=y, p_attrs=p_attrs)
+
+
 ProcessedDatasets = Literal[
     "adult",
     "law_school",
@@ -913,6 +1008,8 @@ def load_acspublic_dataset(preprocessed=True, protected_attribute: Optional[Lite
     "diabetes",
     "acsincome",
     "acspublic",
+    "mw_medium",
+    "mw_small",
 ]
 
 
@@ -976,6 +1073,10 @@ def load_dataset(
         return load_acsincome_dataset(preprocessed=preprocessed, protected_attribute=protected_attribute)
     if dataset_name == "acspublic":
         return load_acspublic_dataset(preprocessed=preprocessed, protected_attribute=protected_attribute)
+    if dataset_name == "mw_medium":
+        return load_mw_medium_dataset(preprocessed=preprocessed, protected_attribute=protected_attribute)
+    if dataset_name == "mw_small":
+        return load_mw_small_dataset(preprocessed=preprocessed, protected_attribute=protected_attribute)
     raise NotImplementedError
 
 
@@ -1044,16 +1145,16 @@ def _load_dataset_benchmark(
         return load_bank_marketing_dataset(preprocessed=preprocessed, protected_attribute="marital")
 
     if dataset_name == "compas_two_year_recid_sex":
-        return load_compas_two_year_recid(preprocessed=preprocessed, protected_attribute="sex")
+        return load_compas_two_year_recid_dataset(preprocessed=preprocessed, protected_attribute="sex")
 
     if dataset_name == "compas_two_year_recid_race":
-        return load_compas_two_year_recid(preprocessed=preprocessed, protected_attribute="race")
+        return load_compas_two_year_recid_dataset(preprocessed=preprocessed, protected_attribute="race")
 
     if dataset_name == "compas_is_recid_sex":
-        return load_compas_is_recid(preprocessed=preprocessed, protected_attribute="sex")
+        return load_compas_is_recid_dataset(preprocessed=preprocessed, protected_attribute="sex")
 
     if dataset_name == "compas_is_recid_race":
-        return load_compas_is_recid(preprocessed=preprocessed, protected_attribute="race")
+        return load_compas_is_recid_dataset(preprocessed=preprocessed, protected_attribute="race")
 
     if dataset_name == "diabetes_sex":
         return load_diabetes_dataset(preprocessed=preprocessed, protected_attribute="sex")
@@ -1073,4 +1174,14 @@ def _load_dataset_benchmark(
     if dataset_name == "acspublic_race":
         return load_acspublic_dataset(preprocessed=preprocessed, protected_attribute="race")
 
+    if dataset_name == "mw_medium_race":
+        return load_mw_medium_dataset(preprocessed=preprocessed, protected_attribute="race")
+    if dataset_name == "mw_medium_sex":
+        return load_mw_medium_dataset(preprocessed=preprocessed, protected_attribute="sex")
+
+    if dataset_name == "mw_small_race":
+        return load_mw_small_dataset(preprocessed=preprocessed, protected_attribute="race")
+    if dataset_name == "mw_small_sex":
+        return load_mw_small_dataset(preprocessed=preprocessed, protected_attribute="sex")
+
     raise NotImplementedError

From 1fb319afa53758e9db91c137f43527f8bf34f85f Mon Sep 17 00:00:00 2001
From: "github-actions[bot]" <github-actions[bot]@users.noreply.github.com>
Date: Tue, 19 Nov 2024 15:16:30 +0000
Subject: [PATCH 02/34] Update version and changelog

---
 src/holisticai/__about__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/holisticai/__about__.py b/src/holisticai/__about__.py
index 39e0411d..9fd0f8dd 100644
--- a/src/holisticai/__about__.py
+++ b/src/holisticai/__about__.py
@@ -1 +1 @@
-__version__ = "1.0.9"
+__version__ = "1.0.10"

From 4b1e639d761f9f5822c662dbe8790bc2d4625937 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cristian=20Mu=C3=B1oz?= <cristian.munoz@holisticai.com>
Date: Thu, 12 Dec 2024 12:40:45 -0300
Subject: [PATCH 03/34] chore: update release workflows  (#282)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* chore: update files for new gitflow (#227)

* chore: update files for new-release

* chore: update readme (#229)

* docs: update tutorials (#230)

* feat: new datasets and docs (#231)

* docs: rename lib (#234)

* fix: datasets labels (#245)

* feature: update dataset_shift module (#248)

* feature: update dataset_shift module

* fix: update dataset_shift code and plots

* fix: percent_degradation to ADP nomenclature

* chore(deps): bump actions/checkout from 4.1.7 to 4.2.2 (#250)

Bumps [actions/checkout](https://github.com/actions/checkout) from 4.1.7 to 4.2.2.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/v4.1.7...v4.2.2)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* chore(deps): bump actions/setup-python from 5.2.0 to 5.3.0 (#251)

Bumps [actions/setup-python](https://github.com/actions/setup-python) from 5.2.0 to 5.3.0.
- [Release notes](https://github.com/actions/setup-python/releases)
- [Commits](https://github.com/actions/setup-python/compare/v5.2.0...v5.3.0)

---
updated-dependencies:
- dependency-name: actions/setup-python
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* feat: New Robustness Regression Attacker: Ridge Poissoner (#241)

* feat: adding adaptive and randflip initializers for regression poisoners

* feat: adding ridge-based regression poisoner

* test: adding unit tests for ridge-based regression poisoner

* chore: updating tutorial with ridge-based poisoner

* docs: updating regression poisoner docs with ridge regressor

* docs: adding docstrings for ridge regressor poisoner

* chore: fixing lint

* chore: updating docstrings for poisoners

* chore: updloading notebook file for regression poisoner tutorial

* docs: updating possible parameters in docstrings

* feat: new methods for measuring security privacy risk score (#254)

* feat: adding source code and tutorial for privacy risk score

* tests: adding unit test for privacy risk score metric

* docs: updating reference docstrings for privacy risk score metric

* docs: updating docs for example gallery for security module

* feat: adding tutorial for privacy risk score with different models

* chore: adding tutorial for example gallery

* chore: adding tutorial notebook files for docs section

* Update security.rst

---------

Co-authored-by: Cristian Muñoz <cristian.munoz@holisticai.com>

* feat: new xai metrics based on globa feature importance, local feature importance and surrogate  (#255)

* internal changes

* fix: pfi regression and shap

* update: shap and contrast

* chore: improved xai metrics

* fix: paper regression results

* ok

* chore:  xai-metrics updated

* chore: format files

* test: add test for new metrics

* docs: update documentation and docstring format

* chore: hatch dmt

---------

Co-authored-by: Kleyton da Costa <kleyton.vsc@gmail.com>

* chore: Improve Accuracy Degradation Profile Documentation  (#249)

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* fix: update dataset_shift code and plots

* fix: update dataset_shift code and plots

* fix: update dataset_shift code and plots

* fix: percent_degradation to ADP nomenclature

* fix: uptade documentation

* chore: clean adp tutorial

* chore: remove inccorect reference

* chore: format

* doc: fix docstring

---------

Co-authored-by: crismunoz <crisstrink@gmail.com>

* docs:update tutorials (#257)

* docs: updating docstrings for regression poissoners (#256)

* fix: load dataset (#259)

* Delete paper directory (#262)

* Delete README.rst

* Delete workflows directory (#263)

* Features/improvementes (#265)

* chore: push updates

* fix: compas and add description

* fix: format

---------

Co-authored-by: crismunoz <crisstrink@gmail.com>

* add: bias tradeoff example (#266)

* add: bank marketing description (#267)

* chore: updating hackaton notebook with privacy risk score interpretation (#271)

* docs: update documetnation (#274)

* fix: merge conflicts

* Features/update documentation (#276)

* chore: update documentation HAI

* feat: remove dataset dependence of sklearn (#277)

* feat: remove dataset dependece of sklearn

* fix: lastfm dataset name

* fix: repository name

* fix: format (#280)

* chore(deps): bump numpy from 1.26 to 2.2.0 (#281)

Bumps [numpy](https://github.com/numpy/numpy) from 1.26 to 2.2.0.
- [Release notes](https://github.com/numpy/numpy/releases)
- [Changelog](https://github.com/numpy/numpy/blob/main/doc/RELEASE_WALKTHROUGH.rst)
- [Commits](https://github.com/numpy/numpy/compare/v1.26.0...v2.2.0)

---
updated-dependencies:
- dependency-name: numpy
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* chore(deps): bump slackapi/slack-github-action from 1.27.0 to 2.0.0 (#278)

Bumps [slackapi/slack-github-action](https://github.com/slackapi/slack-github-action) from 1.27.0 to 2.0.0.
- [Release notes](https://github.com/slackapi/slack-github-action/releases)
- [Commits](https://github.com/slackapi/slack-github-action/compare/v1.27.0...v2.0.0)

---
updated-dependencies:
- dependency-name: slackapi/slack-github-action
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: Kleyton da Costa <44351707+Kleyt0n@users.noreply.github.com>
Co-authored-by: andrelfnovaes <40208986+andrelfnovaes@users.noreply.github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Franklin Cardenoso <44931423+fracarfer5@users.noreply.github.com>
Co-authored-by: Kleyton da Costa <kleyton.vsc@gmail.com>
---
 .github/workflows/publish-workflow.yml | 2 +-
 docs/requirements.txt                  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/publish-workflow.yml b/.github/workflows/publish-workflow.yml
index ab926ad2..ca09a991 100644
--- a/.github/workflows/publish-workflow.yml
+++ b/.github/workflows/publish-workflow.yml
@@ -48,7 +48,7 @@ jobs:
 
       - name: Post to a Slack channel
         id: slack
-        uses: slackapi/slack-github-action@v1.27.0
+        uses: slackapi/slack-github-action@v2.0.0
         with:
           channel-id: "${{ vars.SLACK_CHANNEL_ID }}"
           payload: |
diff --git a/docs/requirements.txt b/docs/requirements.txt
index 478110cb..c2393559 100644
--- a/docs/requirements.txt
+++ b/docs/requirements.txt
@@ -8,7 +8,7 @@ sphinx_togglebutton
 sphinxcontrib.youtube
 jupyter
 pandas
-numpy==1.26
+numpy==2.2.0
 pybind11>=2.12
 cvxpy
 jax

From d78005568689b9a9eca76c64e12563ac6b0cf975 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]" <github-actions[bot]@users.noreply.github.com>
Date: Thu, 12 Dec 2024 15:46:38 +0000
Subject: [PATCH 04/34] Update version and changelog

---
 CHANGELOG.md                | 26 ++++++++++++++++----------
 src/holisticai/__about__.py |  2 +-
 2 files changed, 17 insertions(+), 11 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0db98186..29384ea4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,8 +2,18 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.0.11] - 2024-12-12
+
+### ⚙️ Miscellaneous Tasks
+
+- Update release workflows  (#282)
+
 ## [1.0.7] - 2024-11-01
 
+### 💼 Other
+
+- Develop -> main (#260)
+
 ### 📚 Documentation
 
 - Update Documentation (#235)
@@ -12,10 +22,6 @@ All notable changes to this project will be documented in this file.
 
 - Fix documentation (#233)
 
-### Merge
-
-- Develop -> main (#260)
-
 ## [1.0.6] - 2024-09-23
 
 ### 🚀 Features
@@ -216,7 +222,7 @@ All notable changes to this project will be documented in this file.
 
 - Release new mitigation techniques (#4)
 
-### Bump
+### 💼 Other
 
 - Version 0.2.0 → 0.3.0
 
@@ -226,7 +232,7 @@ All notable changes to this project will be documented in this file.
 
 - Test new version
 
-### Bump
+### 💼 Other
 
 - Version 0.1.3 → 0.1.4
 
@@ -240,13 +246,13 @@ All notable changes to this project will be documented in this file.
 - Remove unused imports
 - Test new version
 
+### 💼 Other
+
+- Version 0.1.1 → 0.1.2
+
 ### 🚜 Refactor
 
 - Second commit
 - Remove .idea directory
 
-### Bump
-
-- Version 0.1.1 → 0.1.2
-
 <!-- generated by git-cliff -->
diff --git a/src/holisticai/__about__.py b/src/holisticai/__about__.py
index 9fd0f8dd..9eb1ebec 100644
--- a/src/holisticai/__about__.py
+++ b/src/holisticai/__about__.py
@@ -1 +1 @@
-__version__ = "1.0.10"
+__version__ = "1.0.11"

From bb51e35b8a417bff2279834142047114a5f835ca Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cristian=20Mu=C3=B1oz?= <cristian.munoz@holisticai.com>
Date: Thu, 12 Dec 2024 14:22:34 -0300
Subject: [PATCH 05/34] fix: Update publish-workflow.yml (#283)

* Update publish-workflow.yml

* Create publish-slack-workflow.yml

* Update publish-workflow.yml

* Rename publish-workflow.yml to publish-pypi-workflow.yml
---
 .github/workflows/publish-pypi-workflow.yml   | 51 +++++++++++++++++++
 ...orkflow.yml => publish-slack-workflow.yml} | 26 +---------
 2 files changed, 53 insertions(+), 24 deletions(-)
 create mode 100644 .github/workflows/publish-pypi-workflow.yml
 rename .github/workflows/{publish-workflow.yml => publish-slack-workflow.yml} (75%)

diff --git a/.github/workflows/publish-pypi-workflow.yml b/.github/workflows/publish-pypi-workflow.yml
new file mode 100644
index 00000000..587a6bff
--- /dev/null
+++ b/.github/workflows/publish-pypi-workflow.yml
@@ -0,0 +1,51 @@
+name: Publish and Notification
+
+on:
+    workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/create-github-app-token@v1
+        id: app-token
+        with:
+          app-id: ${{ secrets.APPLICATION_ID }}
+          private-key: ${{ secrets.APPLICATION_PRIVATE_KEY }}
+
+      - name: Checkout code
+        uses: actions/checkout@v4.2.2
+        with:
+          fetch-tags: true
+          fetch-depth: 0
+          ref: main
+          token: ${{ steps.app-token.outputs.token }} # Needed to trigger other actions
+
+      - name: Set up Python
+        uses: actions/setup-python@v5.3.0
+        with:
+            python-version: "3.9"
+
+      - name: Install dependencies
+        run: |
+            python -m pip install --upgrade pip
+            pip install hatch
+
+      - name: Get Latest Release Version
+        id: get_release
+        run: |
+            latest_tag=$(git describe --tags `git rev-list --tags --max-count=1`)
+            echo "Latest release version: $latest_tag"
+            echo "tag=$latest_tag" >> $GITHUB_ENV # Save the tag to an environment variable
+
+      - name: Publish to PyPI
+        env:
+            HATCH_INDEX_USER: __token__
+            HATCH_INDEX_AUTH: ${{ secrets.PYPI_TOKEN }}
+        run: |
+            hatch build
+            hatch publish
+
+
+
+        
diff --git a/.github/workflows/publish-workflow.yml b/.github/workflows/publish-slack-workflow.yml
similarity index 75%
rename from .github/workflows/publish-workflow.yml
rename to .github/workflows/publish-slack-workflow.yml
index ca09a991..d3aabbe1 100644
--- a/.github/workflows/publish-workflow.yml
+++ b/.github/workflows/publish-slack-workflow.yml
@@ -21,16 +21,6 @@ jobs:
           ref: main
           token: ${{ steps.app-token.outputs.token }} # Needed to trigger other actions
 
-      - name: Set up Python
-        uses: actions/setup-python@v5.3.0
-        with:
-            python-version: "3.9"
-
-      - name: Install dependencies
-        run: |
-            python -m pip install --upgrade pip
-            pip install hatch
-
       - name: Get Latest Release Version
         id: get_release
         run: |
@@ -38,25 +28,17 @@ jobs:
             echo "Latest release version: $latest_tag"
             echo "tag=$latest_tag" >> $GITHUB_ENV # Save the tag to an environment variable
 
-      - name: Publish to PyPI
-        env:
-            HATCH_INDEX_USER: __token__
-            HATCH_INDEX_AUTH: ${{ secrets.PYPI_TOKEN }}
-        run: |
-            hatch build
-            hatch publish
-
       - name: Post to a Slack channel
         id: slack
         uses: slackapi/slack-github-action@v2.0.0
         with:
-          channel-id: "${{ vars.SLACK_CHANNEL_ID }}"
           payload: |
             {
+              "channel": "${{ vars.SLACK_CHANNEL_ID }}",
+              "text": "Release holisticai *v${{env.tag}}* is on the way :rocket:",
               "attachments": [
               {
                 "color": "#36a64f",
-                "pretext": "Release holisticai *v${{env.tag}}* is on the way :rocket:",
                 "fields": [
                   {
                     "title": "Release Notes",
@@ -79,7 +61,3 @@ jobs:
             }
         env:
           SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}
-
-
-
-        

From d8b0cf39f2ffb1fc885296d3a3994526437bd59b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cristian=20Mu=C3=B1oz?= <cristian.munoz@holisticai.com>
Date: Thu, 12 Dec 2024 14:29:26 -0300
Subject: [PATCH 06/34] chore: Update Workflow Names (#284)

* Update publish-pypi-workflow.yml

* Update publish-slack-workflow.yml
---
 .github/workflows/publish-pypi-workflow.yml  | 2 +-
 .github/workflows/publish-slack-workflow.yml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/publish-pypi-workflow.yml b/.github/workflows/publish-pypi-workflow.yml
index 587a6bff..545f05f1 100644
--- a/.github/workflows/publish-pypi-workflow.yml
+++ b/.github/workflows/publish-pypi-workflow.yml
@@ -1,4 +1,4 @@
-name: Publish and Notification
+name: Publish PyPI
 
 on:
     workflow_dispatch:
diff --git a/.github/workflows/publish-slack-workflow.yml b/.github/workflows/publish-slack-workflow.yml
index d3aabbe1..e04710e5 100644
--- a/.github/workflows/publish-slack-workflow.yml
+++ b/.github/workflows/publish-slack-workflow.yml
@@ -1,4 +1,4 @@
-name: Publish and Notification
+name: Slack Notification
 
 on:
     workflow_dispatch:

From d9accfbbbdf24adf53ceeac8a4ed35041ff14a09 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cristian=20Mu=C3=B1oz?= <cristian.munoz@holisticai.com>
Date: Thu, 12 Dec 2024 14:39:55 -0300
Subject: [PATCH 07/34] Update publish-slack-workflow.yml (#285)

---
 .github/workflows/publish-slack-workflow.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/publish-slack-workflow.yml b/.github/workflows/publish-slack-workflow.yml
index e04710e5..440575e1 100644
--- a/.github/workflows/publish-slack-workflow.yml
+++ b/.github/workflows/publish-slack-workflow.yml
@@ -32,6 +32,8 @@ jobs:
         id: slack
         uses: slackapi/slack-github-action@v2.0.0
         with:
+          method: chat.postMessage
+          token: ${{ secrets.SLACK_BOT_TOKEN }}
           payload: |
             {
               "channel": "${{ vars.SLACK_CHANNEL_ID }}",
@@ -59,5 +61,3 @@ jobs:
               }
               ]
             }
-        env:
-          SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}

From a8689831a6f4d11c46df4fe3c98b822cd6b5c25b Mon Sep 17 00:00:00 2001
From: franklincf <fracarfer5@gmail.com>
Date: Tue, 17 Dec 2024 11:34:29 -0300
Subject: [PATCH 08/34] feat: adding attribute inference attacker codes to
 security module

---
 .../attackers/attribute_inference/__init__.py |    0
 .../attackers/attribute_inference/attack.py   |  219 +++
 .../attackers/attribute_inference/baseline.py |  105 ++
 .../attribute_inference/black_box.py          |  169 ++
 .../attribute_inference/dataset_utils.py      |  379 ++++
 .../attribute_inference/exceptions.py         |   68 +
 .../mitigation/__init__.py                    |    0
 .../mitigation/attacks/__init__.py            |    0
 .../white_box_lifestyle_decision_tree.py      |  128 ++
 .../attribute_inference/mitigation/config.py  |   25 +
 .../mitigation/defences/__init__.py           |    0
 .../defences/postprocessor/__init__.py        |    0
 .../defences/postprocessor/postprocessor.py   |  132 ++
 .../defences/preprocessor/__init__.py         |    0
 .../defences/preprocessor/preprocessor.py     |  178 ++
 .../mitigation/preprocessing/__init__.py      |    0
 .../mitigation/preprocessing/preprocessing.py |   22 +
 .../preprocessing/standardisation/__init__.py |    0
 .../preprocessing/standardisation/numpy.py    |  139 ++
 .../preprocessing/standardisation/utils.py    |   53 +
 .../mitigation/scikitlearn.py                 |  140 ++
 .../mitigation/utils/__init__.py              |    0
 .../mitigation/utils/exceptions.py            |   68 +
 .../mitigation/utils/formatting.py            |   50 +
 .../verification_decisions_trees.py           |  152 ++
 .../true_label_baseline.py                    |  145 ++
 .../attackers/attribute_inference/utils.py    |  150 ++
 .../attribute_inference/wrappers/__init__.py  |    0
 .../wrappers/classification/__init__.py       |    0
 .../wrappers/classification/classifier.py     |  254 +++
 .../wrappers/classification/scikitlearn.py    | 1627 +++++++++++++++++
 .../attribute_inference/wrappers/estimator.py |  468 +++++
 .../wrappers/regression/__init__.py           |    0
 .../wrappers/regression/regressor.py          |   28 +
 .../wrappers/regression/scikitlearn.py        |  417 +++++
 .../wrappers/scikitlearn.py                   |   54 +
 36 files changed, 5170 insertions(+)
 create mode 100644 src/holisticai/security/attackers/attribute_inference/__init__.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/attack.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/baseline.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/black_box.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/dataset_utils.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/exceptions.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/__init__.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/attacks/__init__.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/attacks/white_box_lifestyle_decision_tree.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/config.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/defences/__init__.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/defences/postprocessor/__init__.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/defences/postprocessor/postprocessor.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/defences/preprocessor/__init__.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/defences/preprocessor/preprocessor.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/__init__.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/preprocessing.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/standardisation/__init__.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/standardisation/numpy.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/standardisation/utils.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/scikitlearn.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/utils/__init__.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/utils/exceptions.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/utils/formatting.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/verification_decisions_trees.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/true_label_baseline.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/utils.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/wrappers/__init__.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/wrappers/classification/__init__.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/wrappers/classification/classifier.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/wrappers/classification/scikitlearn.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/wrappers/estimator.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/wrappers/regression/__init__.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/wrappers/regression/regressor.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/wrappers/regression/scikitlearn.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/wrappers/scikitlearn.py

diff --git a/src/holisticai/security/attackers/attribute_inference/__init__.py b/src/holisticai/security/attackers/attribute_inference/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/src/holisticai/security/attackers/attribute_inference/attack.py b/src/holisticai/security/attackers/attribute_inference/attack.py
new file mode 100644
index 00000000..15f15780
--- /dev/null
+++ b/src/holisticai/security/attackers/attribute_inference/attack.py
@@ -0,0 +1,219 @@
+from __future__ import annotations
+
+import abc
+import logging
+from typing import Any, Optional, Union
+
+import numpy as np
+from holisticai.security.attackers.attribute_inference.exceptions import EstimatorError
+from holisticai.security.attackers.attribute_inference.utils import is_estimator_valid
+
+logger = logging.getLogger(__name__)
+
+
+class InputFilter(abc.ABCMeta):  # pragma: no cover
+    """
+    Metaclass to ensure that inputs are ndarray for all of the subclass generate and extract calls
+
+    This metaclass is used to ensure that the input to all generate and extract methods is an ndarray. This is
+    necessary because the input to these methods is often a list or a pandas DataFrame, and the methods themselves
+    are not always implemented to handle these types of inputs. This metaclass overrides the generate and extract
+    methods with new methods that ensure the input is an ndarray.
+
+    Parameters
+    ----------
+    name : str
+        The name of the class.
+    bases : tuple
+        The base classes of the class.
+    clsdict : dict
+        The class dictionary.
+    """
+
+    def __init__(cls, name, bases, clsdict):  # noqa: ARG003
+        def make_replacement(fdict, func_name):
+            """
+            This function overrides creates replacement functions dynamically.
+
+            Parameters
+            ----------
+            fdict : dict
+                The class dictionary.
+            func_name : str
+                The name of the function to override.
+
+            Returns
+            -------
+            replacement_function : function
+                The replacement function.
+            """
+
+            def replacement_function(self, *args, **kwargs):
+                if len(args) > 0:
+                    lst = list(args)
+
+                if "x" in kwargs:
+                    if not isinstance(kwargs["x"], np.ndarray):
+                        kwargs["x"] = np.array(kwargs["x"])
+                elif not isinstance(args[0], np.ndarray):
+                    lst[0] = np.array(args[0])
+
+                if "y" in kwargs:
+                    if kwargs["y"] is not None and not isinstance(kwargs["y"], np.ndarray):
+                        kwargs["y"] = np.array(kwargs["y"])
+                elif len(args) == 2 and not isinstance(args[1], np.ndarray):
+                    lst[1] = np.array(args[1])
+
+                if len(args) > 0:
+                    args = tuple(lst)
+                return fdict[func_name](self, *args, **kwargs)
+
+            replacement_function.__doc__ = fdict[func_name].__doc__
+            replacement_function.__name__ = "new_" + func_name
+            return replacement_function
+
+        replacement_list = ["generate", "extract"]
+        for item in replacement_list:
+            if item in clsdict:
+                new_function = make_replacement(clsdict, item)
+                setattr(cls, item, new_function)
+
+
+class Attack(abc.ABC):
+    """
+    Abstract base class for all attack abstract base classes.
+
+    Parameters
+    ----------
+    estimator : :class:`.holisticai.wrappers.estimator.BaseEstimator`
+        An estimator.
+    """
+
+    attack_params: list[str] = []
+    # The _estimator_requirements define the requirements an estimator must satisfy to be used as a target for an
+    # attack. They should be a tuple of requirements, where each requirement is either a class the estimator must
+    # inherit from, or a tuple of classes which define a union, i.e. the estimator must inherit from at least one class
+    # in the requirement tuple.
+    _estimator_requirements: Optional[Union[tuple[Any, ...], tuple[()]]] = None
+
+    def __init__(self, estimator):
+        super().__init__()
+
+        if self.estimator_requirements is None:
+            raise ValueError("Estimator requirements have not been defined in `_estimator_requirements`.")
+
+        if not is_estimator_valid(estimator, self._estimator_requirements):
+            raise EstimatorError(self.__class__, self.estimator_requirements, estimator)
+
+        self._estimator = estimator
+
+    @property
+    def estimator(self):
+        """
+        The estimator.
+
+        Returns
+        -------
+        object
+            The estimator.
+        """
+        return self._estimator
+
+    @property
+    def estimator_requirements(self):
+        """
+        The estimator requirements.
+
+        Returns
+        -------
+        tuple
+            The estimator requirements.
+        """
+        return self._estimator_requirements
+
+    def set_params(self, **kwargs) -> None:
+        """
+        Take in a dictionary of parameters and apply attack-specific checks before saving them as attributes.
+
+        Parameters
+        ----------
+        **kwargs
+            A dictionary of attack-specific parameters.
+        """
+        for key, value in kwargs.items():
+            if key in self.attack_params:
+                setattr(self, key, value)
+        self._check_params()
+
+
+class InferenceAttack(Attack):
+    """
+    Abstract base class for inference attack classes.
+
+    Parameters
+    ----------
+    estimator : object
+        A trained estimator targeted for inference attack.
+    """
+
+    def __init__(self, estimator):
+        super().__init__(estimator)
+
+    @abc.abstractmethod
+    def infer(self, x: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> np.ndarray:
+        """
+        Infer sensitive attributes from the targeted estimator. This method
+        should be overridden by all concrete inference attack implementations.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            An array with reference inputs to be used in the attack.
+        y : np.ndarray, optional
+            Labels for `x`. This parameter is only used by some of the attacks.
+
+        Returns
+        -------
+        np.ndarray
+            An array holding the inferred attribute values.
+        """
+        raise NotImplementedError
+
+
+class AttributeInferenceAttack(InferenceAttack):
+    """
+    Abstract base class for attribute inference attack classes.
+
+    Parameters
+    ----------
+    estimator : object
+        A trained estimator targeted for inference attack.
+    attack_feature : int or slice
+        The index of the feature to be attacked.
+    """
+
+    attack_params = [*InferenceAttack.attack_params, "attack_feature"]
+
+    def __init__(self, estimator, attack_feature: Union[int, slice] = 0):
+        super().__init__(estimator)
+        self.attack_feature = attack_feature
+
+    @abc.abstractmethod
+    def infer(self, x: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> np.ndarray:
+        """
+        Infer sensitive attributes from the targeted estimator. This method
+        should be overridden by all concrete inference attack implementations.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            An array with reference inputs to be used in the attack.
+        y : np.ndarray, optional
+            Labels for `x`. This parameter is only used by some of the attacks.
+
+        Returns
+        -------
+        np.ndarray
+            An array holding the inferred attribute values.
+        """
+        raise NotImplementedError
diff --git a/src/holisticai/security/attackers/attribute_inference/baseline.py b/src/holisticai/security/attackers/attribute_inference/baseline.py
new file mode 100644
index 00000000..c6cf3e80
--- /dev/null
+++ b/src/holisticai/security/attackers/attribute_inference/baseline.py
@@ -0,0 +1,105 @@
+# from typing import Optional, Union, TYPE_CHECKING
+import numpy as np
+from holisticai.security.attackers.attribute_inference.attack import AttributeInferenceAttack
+from holisticai.security.attackers.attribute_inference.dataset_utils import AttributeInferenceDataPreprocessor
+from holisticai.security.attackers.attribute_inference.utils import get_attack_model, get_feature_index
+from sklearn.base import ClassifierMixin
+
+
+class AttributeInferenceBaseline(AttributeInferenceAttack):
+    """
+    Implementation of a baseline attribute inference, not using a model.
+
+    The idea is to train a simple neural network to learn the attacked feature from the rest of the features. Should
+    be used to compare with other attribute inference results.
+
+    Parameters
+    ----------
+    attack_model_type : str
+        The type of default attack model to train, optional. Should be one of `nn` (for neural network, default) or `rf`
+        (for random forest). If `attack_model` is supplied, this option will be ignored.
+    attack_model : object
+        The attack model to train, optional. If none is provided, a default model will be created.
+    attack_feature : int or slice
+        The index of the feature to be attacked or a slice representing multiple indexes in case of a one-hot encoded
+        feature.
+    """
+
+    _estimator_requirements = ()
+
+    def __init__(
+        self,
+        attack_model_type="nn",
+        attack_model=None,
+        attack_feature=0,
+    ):
+        super().__init__(estimator=None, attack_feature=attack_feature)
+
+        self._values = None
+        self._nb_classes = None
+
+        if attack_model:
+            if ClassifierMixin not in type(attack_model).__mro__:
+                raise ValueError("Attack model must be of type Classifier.")
+            self.attack_model = attack_model
+        else:
+            self.attack_model = get_attack_model(attack_model_type)
+
+        self._check_params()
+        self.attack_feature = get_feature_index(self.attack_feature)
+        self.ai_preprocessor = AttributeInferenceDataPreprocessor(attack_feature=attack_feature)
+
+    def fit(self, x: np.ndarray) -> None:
+        """
+        Train the attack model.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Input to training process. Includes all features used to train the original model.
+        """
+        # train attack model
+        attack_x, attack_y = self.ai_preprocessor.fit_transform(x)
+        self._values = self.ai_preprocessor._values  # noqa: SLF001
+        self.attack_model.fit(attack_x, attack_y)
+
+    def infer(self, x: np.ndarray, **kwargs) -> np.ndarray:
+        """
+        Infer the attacked feature.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Input to attack. Includes all features except the attacked feature.
+        values : list
+            Possible values for attacked feature. For a single column feature this should be a simple list containing
+            all possible values, in increasing order (the smallest value in the 0 index and so on). For a multi-column
+            feature (for example 1-hot encoded and then scaled), this should be a list of lists, where each internal
+            list represents a column (in increasing order) and the values represent the possible values for that column
+            (in increasing order).
+
+        Returns
+        -------
+        np.ndarray
+            The inferred feature values.
+        """
+        # if values are provided, override the values computed in fit()
+        values = kwargs.get("values", self._values)
+        attack_x = self.ai_preprocessor.transform(x)
+        predictions = self.attack_model.predict_proba(attack_x).astype(np.float32)
+
+        if values is not None:
+            if isinstance(self.attack_feature, int):
+                predictions = np.array([values[np.argmax(arr)] for arr in predictions])
+            else:
+                for value, column in zip(values, predictions.T):
+                    for index in range(len(value)):
+                        np.place(column, [column == index], value[index])
+        return np.array(predictions)
+
+    def _check_params(self) -> None:
+        if not isinstance(self.attack_feature, int) and not isinstance(self.attack_feature, slice):
+            raise TypeError("Attack feature must be either an integer or a slice object.")
+
+        if isinstance(self.attack_feature, int) and self.attack_feature < 0:
+            raise ValueError("Attack feature index must be non-negative.")
diff --git a/src/holisticai/security/attackers/attribute_inference/black_box.py b/src/holisticai/security/attackers/attribute_inference/black_box.py
new file mode 100644
index 00000000..e5a401c9
--- /dev/null
+++ b/src/holisticai/security/attackers/attribute_inference/black_box.py
@@ -0,0 +1,169 @@
+"""
+This module implements attribute inference attacks.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Optional, Union
+
+import numpy as np
+from holisticai.security.attackers.attribute_inference.attack import AttributeInferenceAttack
+from holisticai.security.attackers.attribute_inference.dataset_utils import AttributeInferenceDataPreprocessor
+from holisticai.security.attackers.attribute_inference.utils import get_attack_model, get_feature_index
+from holisticai.security.attackers.attribute_inference.wrappers.classification.classifier import ClassifierMixin
+from holisticai.security.attackers.attribute_inference.wrappers.estimator import BaseEstimator
+from holisticai.security.attackers.attribute_inference.wrappers.regression.regressor import RegressorMixin
+
+logger = logging.getLogger(__name__)
+
+
+class AttributeInferenceBlackBox(AttributeInferenceAttack):
+    """
+    Implementation of a simple black-box attribute inference attack.
+
+    The idea is to train a simple neural network to learn the attacked feature from the rest of the features and the
+    model's predictions. Assumes the availability of the attacked model's predictions for the samples under attack,
+    in addition to the rest of the feature values. If this is not available, the true class label of the samples may be
+    used as a proxy.
+
+    Parameters
+    ----------
+    estimator : object
+        Target estimator.
+    attack_model_type : str
+        The type of default attack model to train, optional. Should be one of `nn` (for neural network, default) or `rf`
+        (for random forest). If `attack_model` is supplied, this option will be ignored.
+    attack_model : object
+        The attack model to train, optional. If none is provided, a default model will be created.
+    attack_feature : int or slice
+        The index of the feature to be attacked or a slice representing multiple indexes in case of a one-hot encoded
+        feature.
+    scale_range : tuple
+        If supplied, the class labels (both true and predicted) will be scaled to the given range. Only applicable when
+        `estimator` is a regressor.
+    prediction_normal_factor : float
+        If supplied, the class labels (both true and predicted) are multiplied by the factor when used as inputs to the
+        attack-model. Only applicable when `estimator` is a regressor and if `scale_range` is not supplied.
+    """
+
+    attack_params = [
+        *AttributeInferenceAttack.attack_params,
+        "prediction_normal_factor",
+        "scale_range",
+        "attack_model_type",
+    ]
+    _estimator_requirements = (BaseEstimator, (ClassifierMixin, RegressorMixin))
+
+    def __init__(
+        self,
+        estimator,
+        attack_model_type: str = "nn",
+        attack_model=None,
+        attack_feature: Union[int, slice] = 0,
+        scale_range: Optional[tuple[float, float]] = None,
+        prediction_normal_factor: Optional[float] = 1,
+    ):
+        super().__init__(estimator=estimator, attack_feature=attack_feature)
+
+        self._values: Optional[list] = None
+        self._nb_classes: Optional[int] = None
+        self._attack_model_type = attack_model_type
+        self._attack_model = attack_model
+
+        if attack_model:
+            if ClassifierMixin not in type(attack_model).__mro__:
+                raise ValueError("Attack model must be of type Classifier.")
+            self.attack_model = attack_model
+        else:
+            self.attack_model = get_attack_model(attack_model_type)
+
+        self.prediction_normal_factor = prediction_normal_factor
+        self.scale_range = scale_range
+        is_regression = ClassifierMixin not in type(self.estimator).__mro__
+        self._check_params()
+        self.attack_feature = get_feature_index(self.attack_feature)
+        self.ai_preprocessor = AttributeInferenceDataPreprocessor(
+            is_regression=is_regression,
+            scale_range=scale_range,
+            prediction_normal_factor=prediction_normal_factor,
+            attack_feature=attack_feature,
+        )
+
+    def fit(self, x: np.ndarray, y: Optional[np.ndarray] = None, pred: Optional[np.ndarray] = None) -> None:
+        """
+        Train the attack model.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Input to training process. Includes all features used to train the original model.
+        y : np.ndarray
+            True labels for x.
+        pred : np.ndarray
+            Predictions of the original model for x.
+        """
+
+        # train attack model
+        attack_x, attack_y = self.ai_preprocessor.fit_transform(x, y, pred)
+        self._values = self.ai_preprocessor._values  # noqa: SLF001
+        self.attack_model.fit(attack_x, attack_y)
+
+    def infer(self, x: np.ndarray, y: np.ndarray, pred: np.ndarray, **kwargs) -> np.ndarray:
+        """
+        Infer the attacked feature.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Input to attack. Includes all features except the attacked feature.
+        y : np.ndarray
+            True labels for x.
+        pred : np.ndarray
+            Original model's predictions for x.
+        values : list
+            Possible values for attacked feature. For a single column feature this should be a simple list
+            containing all possible values, in increasing order (the smallest value in the 0 index and so
+            on). For a multi-column feature (for example 1-hot encoded and then scaled), this should be a
+            list of lists, where each internal list represents a column (in increasing order) and the values
+            represent the possible values for that column (in increasing order). If not provided, is
+            computed from the training data when calling `fit`.
+
+        Returns
+        -------
+        np.ndarray
+            The inferred feature values.
+        """
+
+        values: Optional[list] = kwargs.get("values")
+
+        # if provided, override the values computed in fit()
+        if values is not None:
+            self._values = values
+
+        attack_x = self.ai_preprocessor.transform(x, y, pred)
+        predictions = self.attack_model.predict_proba(attack_x).astype(np.float32)
+
+        if self._values is not None:
+            if isinstance(self.attack_feature, int):
+                predictions = np.array([self._values[np.argmax(arr)] for arr in predictions])
+            else:
+                i = 0
+                for column in predictions.T:
+                    for index in range(len(self._values[i])):
+                        np.place(column, [column == index], self._values[i][index])
+                    i += 1
+        return np.array(predictions)
+
+    def _check_params(self) -> None:
+        if not isinstance(self.attack_feature, int) and not isinstance(self.attack_feature, slice):
+            raise TypeError("Attack feature must be either an integer or a slice object.")
+
+        if isinstance(self.attack_feature, int) and self.attack_feature < 0:
+            raise ValueError("Attack feature index must be positive.")
+
+        if self._attack_model_type not in ["nn", "rf"]:
+            raise ValueError("Illegal value for parameter `attack_model_type`.")
+
+        if RegressorMixin not in type(self.estimator).__mro__ and self.prediction_normal_factor != 1:
+            raise ValueError("Prediction normal factor is only applicable to regressor models.")
diff --git a/src/holisticai/security/attackers/attribute_inference/dataset_utils.py b/src/holisticai/security/attackers/attribute_inference/dataset_utils.py
new file mode 100644
index 00000000..fec1696f
--- /dev/null
+++ b/src/holisticai/security/attackers/attribute_inference/dataset_utils.py
@@ -0,0 +1,379 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import numpy as np
+from sklearn.preprocessing import minmax_scale
+
+
+def to_categorical(labels, nb_classes) -> np.ndarray:
+    """
+    Convert an array of labels to binary class matrix.
+
+    Parameters
+    ----------
+    labels : np.ndarray
+        An array of integer labels of shape `(nb_samples,)`.
+    nb_classes : int
+        The number of classes (possible labels).
+
+    Returns
+    -------
+    np.ndarray
+        A binary matrix representation of `y` in the shape `(nb_samples, nb_classes)`.
+    """
+    labels = np.array(labels, dtype=int)
+    if nb_classes is None:
+        nb_classes = np.max(labels) + 1
+    categorical = np.zeros((labels.shape[0], nb_classes), dtype=np.float32)
+    categorical[np.arange(labels.shape[0]), np.squeeze(labels)] = 1
+    return categorical
+
+
+def check_and_transform_label_format(
+    labels: np.ndarray, nb_classes: Optional[int], return_one_hot: bool = True
+) -> np.ndarray:
+    """
+    Check label format and transform to one-hot-encoded labels if necessary
+
+    Parameters
+    ----------
+    labels : np.ndarray
+        An array of integer labels of shape `(nb_samples,)`, `(nb_samples, 1)` or `(nb_samples, nb_classes)`.
+    nb_classes : int
+        The number of classes. If None the number of classes is determined automatically.
+    return_one_hot : bool
+        True if returning one-hot encoded labels, False if returning index labels.
+
+    Returns
+    -------
+    np.ndarray
+        Labels with shape `(nb_samples, nb_classes)` (one-hot) or `(nb_samples,)` (index).
+    """
+    labels_return = labels
+
+    if len(labels.shape) == 2 and labels.shape[1] > 1:  # multi-class, one-hot encoded
+        if not return_one_hot:
+            labels_return = np.argmax(labels, axis=1)
+            labels_return = np.expand_dims(labels_return, axis=1)
+    elif len(labels.shape) == 2 and labels.shape[1] == 1:
+        if nb_classes is None:
+            nb_classes = np.max(labels) + 1
+        if nb_classes > 2:  # multi-class, index labels
+            labels_return = to_categorical(labels, nb_classes) if return_one_hot else np.expand_dims(labels, axis=1)
+        elif nb_classes == 2:  # binary, index labels
+            if return_one_hot:
+                labels_return = to_categorical(labels, nb_classes)
+        else:
+            raise ValueError(
+                "Shape of labels not recognised."
+                "Please provide labels in shape (nb_samples,) or (nb_samples, "
+                "nb_classes)"
+            )
+    elif len(labels.shape) == 1:  # index labels
+        labels_return = to_categorical(labels, nb_classes) if return_one_hot else np.expand_dims(labels, axis=1)
+    else:
+        raise ValueError(
+            "Shape of labels not recognised."
+            "Please provide labels in shape (nb_samples,) or (nb_samples, "
+            "nb_classes)"
+        )
+
+    return labels_return
+
+
+def get_feature_values(x: np.ndarray, single_index_feature: bool) -> list:
+    """
+    Returns a list of unique values of a given feature.
+
+    Parameters
+    ----------
+    x : np.ndarray
+        The feature column(s).
+    single_index_feature : bool
+        Bool representing whether this is a single-column or multiple-column feature (for
+        example 1-hot encoded and then scaled).
+
+    Returns
+    -------
+    list
+        For a single-column feature, a simple list containing all possible values, in increasing order.
+        For a multi-column feature, a list of lists, where each internal list represents a column and the values
+        represent the possible values for that column (in increasing order).
+    """
+    values = None
+    if single_index_feature:
+        values = np.unique(x).tolist()
+    else:
+        for column in x.T:
+            column_values = np.unique(column)
+            values = column_values if values is None else np.vstack((values, column_values))
+        if values is not None:
+            values = values.tolist()
+    return values
+
+
+def floats_to_one_hot(labels: np.ndarray):
+    """
+    Convert a 2D-array of floating point labels to binary class matrix.
+
+    Parameters
+    ----------
+    labels : np.ndarray
+        A 2D-array of floating point labels of shape `(nb_samples, nb_classes)`.
+
+    Returns
+    -------
+    np.ndarray
+        A binary matrix representation of `labels` in the shape `(nb_samples, nb_classes)`.
+    """
+    labels = np.array(labels)
+    for feature in labels.T:  # pylint: disable=E1133
+        unique = np.unique(feature)
+        unique.sort()
+        for index, value in enumerate(unique):
+            feature[feature == value] = index
+    return labels.astype(np.float32)
+
+
+def float_to_categorical(labels: np.ndarray, nb_classes: Optional[int] = None):
+    """
+    Convert an array of floating point labels to binary class matrix.
+
+    Parameters
+    ----------
+    labels : np.ndarray
+        An array of floating point labels of shape `(nb_samples,)`.
+    nb_classes : int
+        The number of classes (possible labels).
+
+    Returns
+    -------
+    np.ndarray
+        A binary matrix representation of `labels` in the shape `(nb_samples, nb_classes)`.
+    """
+    labels = np.array(labels)
+    unique = np.unique(labels)
+    unique.sort()
+    indexes = [np.where(unique == value)[0] for value in labels]
+    if nb_classes is None:
+        nb_classes = len(unique)
+    categorical = np.zeros((labels.shape[0], nb_classes), dtype=np.float32)
+    categorical[np.arange(labels.shape[0]), np.squeeze(indexes)] = 1
+    return categorical
+
+
+class AttackDataset:
+    """
+    Class for splitting data into training and test sets for membership and attribute inference attacks.
+
+    Parameters
+    ----------
+    x : np.ndarray or tuple
+        Input data. If tuple, the first element is the training data and the second element is the test data.
+    y : np.ndarray or tuple, optional
+        Labels. If tuple, the first element is the training labels and the second element is the test labels.
+    attack_train_ratio : float, optional
+        The ratio of training data to use for the attack. Default is 0.5.
+    """
+
+    def __init__(self, x, y=None, attack_train_ratio: Optional[float] = 0.5):
+        if type(x) is tuple:
+            self.x_train, self.x_test = x
+            self.attack_train_size = int(len(self.x_train) * attack_train_ratio)
+            self.attack_test_size = int(len(self.x_test) * attack_train_ratio)
+        else:
+            self.x_train = x
+            self.attack_train_size = int(len(self.x_train) * attack_train_ratio)
+
+        self.y_output = y is not None
+
+        if self.y_output:
+            if type(y) is tuple:
+                self.y_train, self.y_test = y
+            else:
+                self.y_train = y
+
+    def membership_inference_train(self):
+        """
+        Get the training set for the membership inference attack.
+
+        Returns
+        -------
+        tuple
+            Tuple containing the training data and the membership
+        """
+        x = np.concatenate([self.x_train[: self.attack_train_size :], self.x_test[: self.attack_test_size]])
+        train_membership = np.ones(self.attack_train_size)
+        test_membership = np.zeros(self.attack_test_size)
+        membership = np.concatenate([train_membership, test_membership])
+
+        if not self.y_output:
+            return x, membership
+
+        y = np.concatenate([self.y_train[: self.attack_train_size :], self.y_test[: self.attack_test_size]])
+        return x, y, membership
+
+    def membership_inference_test(self):
+        """
+        Get the test set for the membership inference attack.
+
+        Returns
+        -------
+        tuple
+            Tuple containing the test data and the membership
+        """
+        x = np.concatenate([self.x_train[self.attack_train_size :], self.x_test[self.attack_test_size :]])
+        train_membership = np.ones(self.attack_train_size)
+        test_membership = np.zeros(self.attack_test_size)
+        membership = np.concatenate([train_membership, test_membership])
+
+        if not self.y_output:
+            return x, membership
+
+        y = np.concatenate([self.y_train[self.attack_train_size :], self.y_test[self.attack_test_size :]])
+        return x, y, membership
+
+    def attribute_inference_train(self):
+        """
+        Get the training set for the attribute inference attack.
+
+        Returns
+        -------
+        tuple
+            Tuple containing the training data and the attribute.
+        """
+        attack_x_train = self.x_train[: self.attack_train_size]
+
+        if not self.y_output:
+            return attack_x_train
+
+        attack_y_train = self.y_train[: self.attack_train_size]
+        return attack_x_train, attack_y_train
+
+    def attribute_inference_test(self):
+        """
+        Get the test set for the attribute inference attack.
+
+        Returns
+        -------
+        tuple
+            Tuple containing the test data and the attribute.
+        """
+        attack_x_test = self.x_train[self.attack_train_size :]
+
+        if not self.y_output:
+            return attack_x_test
+
+        attack_y_test = self.y_train[self.attack_train_size :]
+        return attack_x_test, attack_y_test
+
+
+class AttributeInferenceDataPreprocessor:
+    """
+    Class for preprocessing data for attribute inference attacks.
+
+    Parameters
+    ----------
+    attack_feature : int or slice
+        The feature to be attacked.
+    is_regression : bool, optional
+        Whether the attack is a regression attack. Default is False.
+    scale_range : tuple, optional
+        The range to scale the labels to. Default is None.
+    prediction_normal_factor : float, optional
+        The factor to normalize the predictions by. Default is 1.
+    """
+
+    def __init__(self, attack_feature, is_regression=None, scale_range=None, prediction_normal_factor=None):
+        self.is_regression = is_regression  # if RegressorMixin in type(self.estimator).__mro__:
+        self.scale_range = scale_range
+        self.prediction_normal_factor = prediction_normal_factor
+        self.attack_feature = attack_feature
+
+    def fit_transform(self, x, y=None, pred=None):
+        """
+        Prepare the data for training the attack model.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            The input data.
+        y : np.ndarray, optional
+            The true labels.
+
+        Returns
+        -------
+        np.ndarray or tuple
+            The training data for the attack model. If `y` is provided, a tuple is returned with the training data and
+            the labels.
+        """
+        y_ready = self._get_feature_labels(x)
+        x_ready = np.delete(x, self.attack_feature, 1)
+
+        # create training set for attack model
+        if y is not None:
+            normalized_labels = self._normalized_labels(y)
+            x_ready = np.c_[x_ready, normalized_labels].astype(np.float32)
+
+        if pred is not None:
+            normalized_labels = self._normalized_labels(pred)
+            x_ready = np.c_[x_ready, normalized_labels].astype(np.float32)
+
+        if y_ready is None:
+            return x_ready
+        return x_ready, y_ready
+
+    def transform(self, x, y=None, pred=None):
+        """
+        Prepare the data for inference with the attack model.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            The input data.
+        y : np.ndarray, optional
+            The true labels.
+
+        Returns
+        -------
+        np.ndarray or tuple
+            The data for the attack model. If `y` is provided, a tuple is returned with the data and the labels.
+        """
+        x_ready = x  # np.delete(x, self.attack_feature, 1)
+
+        # create training set for attack model
+        if y is not None:
+            normalized_labels = self._normalized_labels(y)
+            x_ready = np.c_[x_ready, normalized_labels].astype(np.float32)
+
+        if pred is not None:
+            normalized_labels = self._normalized_labels(pred)
+            x_ready = np.c_[x_ready, normalized_labels].astype(np.float32)
+
+        return x_ready
+
+    def _get_feature_labels(self, x):
+        attacked_feature = x[:, self.attack_feature]
+
+        self._values = get_feature_values(attacked_feature, isinstance(self.attack_feature, int))
+        self._nb_classes = len(self._values)
+
+        if isinstance(self.attack_feature, int):
+            y_one_hot = float_to_categorical(attacked_feature)
+        else:
+            y_one_hot = floats_to_one_hot(attacked_feature)
+
+        y_ready = check_and_transform_label_format(y_one_hot, nb_classes=self._nb_classes, return_one_hot=True)
+        return y_ready
+
+    def _normalized_labels(self, y):
+        if self.is_regression:
+            if self.scale_range is not None:
+                normalized_labels = minmax_scale(y, feature_range=self.scale_range)
+            else:
+                normalized_labels = y * self.prediction_normal_factor
+            normalized_labels = normalized_labels.reshape(-1, 1)
+        else:
+            normalized_labels = check_and_transform_label_format(y, nb_classes=None, return_one_hot=True)
+        return normalized_labels
diff --git a/src/holisticai/security/attackers/attribute_inference/exceptions.py b/src/holisticai/security/attackers/attribute_inference/exceptions.py
new file mode 100644
index 00000000..db1f8be6
--- /dev/null
+++ b/src/holisticai/security/attackers/attribute_inference/exceptions.py
@@ -0,0 +1,68 @@
+# MIT License
+#
+# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2018
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+"""
+Module containing ART's exceptions.
+"""
+
+from __future__ import annotations
+
+from typing import Union
+
+
+class EstimatorError(TypeError):
+    """
+    Basic exception for errors raised by unexpected estimator types.
+
+    Parameters
+    ----------
+    this_class : type
+        The class that raised the exception.
+    class_expected_list : list[Union[type, tuple[type]]]
+        The expected classes for the estimator.
+    classifier_given : object
+        The classifier that was given.
+    """
+
+    def __init__(self, this_class, class_expected_list: list[Union[type, tuple[type]]], classifier_given) -> None:
+        super().__init__()
+        self.this_class = this_class
+        self.class_expected_list = class_expected_list
+        self.classifier_given = classifier_given
+
+        classes_expected_message = ""
+        for idx, class_expected in enumerate(class_expected_list):
+            if idx != 0:
+                classes_expected_message += " and "
+            if isinstance(class_expected, type):
+                classes_expected_message += f"{class_expected}"
+            else:
+                classes_expected_message += "("
+                for or_idx, or_class in enumerate(class_expected):
+                    if or_idx != 0:
+                        classes_expected_message += " or "
+                    classes_expected_message += f"{or_class}"
+                classes_expected_message += ")"
+
+        self.message = (
+            f"{this_class.__name__} requires an estimator derived from {classes_expected_message}, "
+            f"the provided classifier is an instance of {type(classifier_given)} "
+            f"and is derived from {classifier_given.__class__.__bases__}."
+        )
+
+    def __str__(self) -> str:
+        return self.message
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/__init__.py b/src/holisticai/security/attackers/attribute_inference/mitigation/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/attacks/__init__.py b/src/holisticai/security/attackers/attribute_inference/mitigation/attacks/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/attacks/white_box_lifestyle_decision_tree.py b/src/holisticai/security/attackers/attribute_inference/mitigation/attacks/white_box_lifestyle_decision_tree.py
new file mode 100644
index 00000000..b572b7d2
--- /dev/null
+++ b/src/holisticai/security/attackers/attribute_inference/mitigation/attacks/white_box_lifestyle_decision_tree.py
@@ -0,0 +1,128 @@
+"""
+This module implements attribute inference attacks.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+import numpy as np
+from holisticai.security.attackers.attribute_inference.attack import AttributeInferenceAttack
+from holisticai.security.attackers.attribute_inference.wrappers.classification.scikitlearn import (
+    ScikitlearnDecisionTreeClassifier,
+)
+from holisticai.security.attackers.attribute_inference.wrappers.regression.scikitlearn import (
+    ScikitlearnDecisionTreeRegressor,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class AttributeInferenceWhiteBoxLifestyleDecisionTree(AttributeInferenceAttack):
+    """
+    Implementation of Fredrikson et al. white box inference attack for decision trees.
+
+    Assumes that the attacked feature is discrete or categorical, with limited number of possible values. For example:
+    a boolean feature.
+
+    Parameters
+    ----------
+    estimator : object
+        Target estimator.
+    attack_feature : int
+        The index of the feature to be attacked.
+
+    References
+    ----------
+    .. [1] Fredrikson, M., Jha, S., & Ristenpart, T. (2015, August). Model inversion attacks that exploit confidence\\
+          information and basic countermeasures. In Proceedings of the 22nd ACM SIGSAC Conference on Computer and\\
+              Communications Security (pp. 1322-1333).
+
+    | Paper link: https://dl.acm.org/doi/10.1145/2810103.2813677
+    """
+
+    _estimator_requirements = ((ScikitlearnDecisionTreeClassifier, ScikitlearnDecisionTreeRegressor),)
+
+    def __init__(self, estimator, attack_feature: int = 0):
+        super().__init__(estimator=estimator, attack_feature=attack_feature)
+        self.attack_feature: int
+        self._check_params()
+
+    def infer(self, x: np.ndarray, **kwargs) -> np.ndarray:
+        """
+        Infer the attacked feature.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Input to attack. Includes all features except the attacked feature.
+        kwargs : dict
+            Possible values for attacked feature and prior distributions of attacked feature values.
+
+        Returns
+        -------
+        np.ndarray
+            The inferred feature values.
+        """
+        priors: Optional[list] = kwargs.get("priors")
+        values: Optional[list] = kwargs.get("values")
+
+        # Checks:
+        if self.estimator.input_shape[0] != x.shape[1] + 1:  # pragma: no cover
+            raise ValueError("Number of features in x + 1 does not match input_shape of classifier")
+        if priors is None or values is None:  # pragma: no cover
+            raise ValueError("`priors` and `values` are required as inputs.")
+        if len(priors) != len(values):  # pragma: no cover
+            raise ValueError("Number of priors does not match number of values")
+
+        n_samples = x.shape[0]
+
+        # Calculate phi for each possible value of the attacked feature
+        # phi is the total number of samples in all tree leaves corresponding to this value
+        phi = self._calculate_phi(x, values, n_samples)
+
+        # Will contain the probability of each value
+        prob_values = []
+
+        for i, value in enumerate(values):
+            # prepare data with the given value in the attacked feature
+            v_full = np.full((n_samples, 1), value).astype(x.dtype)
+            x_value = np.concatenate((x[:, : self.attack_feature], v_full), axis=1)
+            x_value = np.concatenate((x_value, x[:, self.attack_feature :]), axis=1)
+
+            # find the relative probability of this value for all samples being attacked
+            prob_value = [
+                (
+                    (self.estimator.get_samples_at_node(self.estimator.get_decision_path([row])[-1]) / n_samples)
+                    * priors[i]
+                    / phi[i]
+                )
+                for row in x_value
+            ]
+            prob_values.append(prob_value)
+
+        # Choose the value with highest probability for each sample
+        return np.array([values[np.argmax(list(prob))] for prob in zip(*prob_values)])
+
+    def _calculate_phi(self, x, values, n_samples):
+        phi = []
+        for value in values:
+            v_full = np.full((n_samples, 1), value).astype(x.dtype)
+            x_value = np.concatenate((x[:, : self.attack_feature], v_full), axis=1)
+            x_value = np.concatenate((x_value, x[:, self.attack_feature :]), axis=1)
+            nodes_value = {}
+
+            for row in x_value:
+                # get leaf ids (no duplicates)
+                node_id = self.estimator.get_decision_path([row])[-1]
+                nodes_value[node_id] = self.estimator.get_samples_at_node(node_id)
+            # sum sample numbers
+            num_value = sum(nodes_value.values()) / n_samples
+            phi.append(num_value)
+
+        return phi
+
+    def _check_params(self) -> None:
+        if self.attack_feature < 0:
+            raise ValueError("Attack feature must be positive.")
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/config.py b/src/holisticai/security/attackers/attribute_inference/mitigation/config.py
new file mode 100644
index 00000000..e730d20f
--- /dev/null
+++ b/src/holisticai/security/attackers/attribute_inference/mitigation/config.py
@@ -0,0 +1,25 @@
+# MIT License
+#
+# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2018
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+"""
+This module loads and provides configuration parameters for ART.
+"""
+
+import numpy as np
+
+ART_NUMPY_DTYPE = np.float32  # pylint: disable=C0103
+ART_DATA_PATH: str
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/defences/__init__.py b/src/holisticai/security/attackers/attribute_inference/mitigation/defences/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/defences/postprocessor/__init__.py b/src/holisticai/security/attackers/attribute_inference/mitigation/defences/postprocessor/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/defences/postprocessor/postprocessor.py b/src/holisticai/security/attackers/attribute_inference/mitigation/defences/postprocessor/postprocessor.py
new file mode 100644
index 00000000..3d41f2e9
--- /dev/null
+++ b/src/holisticai/security/attackers/attribute_inference/mitigation/defences/postprocessor/postprocessor.py
@@ -0,0 +1,132 @@
+# MIT License
+#
+# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2020
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+"""
+This module implements the abstract base class for defences that post-process classifier output.
+"""
+
+from __future__ import annotations
+
+import abc
+
+import numpy as np
+
+
+class Postprocessor(abc.ABC):
+    """
+    Abstract base class for postprocessing defences. Postprocessing defences are not included in the loss function
+    evaluation for loss gradients or the calculation of class gradients.
+
+    Parameters
+    ----------
+    is_fitted : bool
+        Whether the postprocessor has already been fitted.
+    apply_fit : bool
+        Whether the postprocessor should be applied at training time.
+    apply_predict : bool
+        Whether the postprocessor should be applied at test time.
+    """
+
+    params: list[str] = []
+
+    def __init__(self, is_fitted: bool = False, apply_fit: bool = True, apply_predict: bool = True) -> None:
+        self._is_fitted = bool(is_fitted)
+        self._apply_fit = bool(apply_fit)
+        self._apply_predict = bool(apply_predict)
+        Postprocessor._check_params(self)
+
+    @property
+    def is_fitted(self) -> bool:
+        """
+        Return the state of the postprocessing object.
+
+        Returns
+        -------
+        bool
+            `True` if the postprocessing model has been fitted (if this applies).
+        """
+        return self._is_fitted
+
+    @property
+    def apply_fit(self) -> bool:
+        """
+        Property of the defence indicating if it should be applied at training time.
+
+        Returns
+        -------
+        bool
+            `True` if the defence should be applied when fitting a model, `False` otherwise.
+        """
+        return self._apply_fit
+
+    @property
+    def apply_predict(self) -> bool:
+        """
+        Property of the defence indicating if it should be applied at test time.
+
+        Returns
+        -------
+        bool
+            `True` if the defence should be applied at prediction time, `False` otherwise.
+        """
+        return self._apply_predict
+
+    @abc.abstractmethod
+    def __call__(self, preds: np.ndarray) -> np.ndarray:
+        """
+        Perform model postprocessing and return postprocessed output.
+
+        Parameters
+        ----------
+        preds : np.ndarray
+            Model output to be postprocessed.
+
+        Returns
+        -------
+        np.ndarray
+            Postprocessed model output.
+        """
+        raise NotImplementedError
+
+    def fit(self, preds: np.ndarray, **kwargs) -> None:
+        """
+        Fit the parameters of the postprocessor if it has any.
+
+        Parameters
+        ----------
+        preds : np.ndarray
+            Training set to fit the postprocessor.
+        kwargs
+            Other parameters.
+        """
+
+    def set_params(self, **kwargs) -> None:
+        """
+        Take in a dictionary of parameters and apply checks before saving them as attributes.
+
+        Parameters
+        ----------
+        kwargs
+            Dictionary of parameters to apply checks to.
+        """
+        for key, value in kwargs.items():
+            if key in self.params:
+                setattr(self, key, value)
+        self._check_params()
+
+    def _check_params(self) -> None:
+        pass
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/defences/preprocessor/__init__.py b/src/holisticai/security/attackers/attribute_inference/mitigation/defences/preprocessor/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/defences/preprocessor/preprocessor.py b/src/holisticai/security/attackers/attribute_inference/mitigation/defences/preprocessor/preprocessor.py
new file mode 100644
index 00000000..3d810cf1
--- /dev/null
+++ b/src/holisticai/security/attackers/attribute_inference/mitigation/defences/preprocessor/preprocessor.py
@@ -0,0 +1,178 @@
+# MIT License
+#
+# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2018
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+"""
+This module implements the abstract base class for defences that pre-process input data.
+"""
+
+from __future__ import annotations
+
+import abc
+from typing import Any, Optional
+
+import numpy as np
+
+
+class Preprocessor(abc.ABC):
+    """
+    Abstract base class for preprocessing defences.
+
+    By default, the gradient is estimated using BPDA with the identity function.
+        To modify, override `estimate_gradient`
+
+    Parameters
+    ----------
+    is_fitted : bool
+        Whether the preprocessor has already been fitted.
+    apply_fit : bool
+        Whether the preprocessor should be applied at training time.
+    apply_predict : bool
+        Whether the preprocessor should be applied at test time.
+    """
+
+    params: list[str] = []
+
+    def __init__(self, is_fitted: bool = False, apply_fit: bool = True, apply_predict: bool = True) -> None:
+        self._is_fitted = bool(is_fitted)
+        self._apply_fit = bool(apply_fit)
+        self._apply_predict = bool(apply_predict)
+
+    @property
+    def is_fitted(self) -> bool:
+        """
+        Return the state of the preprocessing object.
+
+        Returns
+        -------
+        bool
+            `True` if the preprocessing model has been fitted (if this applies).
+        """
+        return self._is_fitted
+
+    @property
+    def apply_fit(self) -> bool:
+        """
+        Property of the defence indicating if it should be applied at training time.
+
+        Returns
+        -------
+        bool
+            `True` if the defence should be applied when fitting a model, `False` otherwise.
+        """
+        return self._apply_fit
+
+    @property
+    def apply_predict(self) -> bool:
+        """
+        Property of the defence indicating if it should be applied at test time.
+
+        Returns
+        -------
+        bool
+            `True` if the defence should be applied at prediction time, `False` otherwise.
+        """
+        return self._apply_predict
+
+    @abc.abstractmethod
+    def __call__(self, x: np.ndarray, y: Optional[np.ndarray] = None) -> tuple[np.ndarray, Optional[np.ndarray]]:
+        """
+        Perform data preprocessing and return preprocessed data as tuple.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Dataset to be preprocessed.
+        y : np.ndarray
+            Labels to be preprocessed.
+
+        Returns
+        -------
+        np.ndarray
+            Preprocessed data.
+        np.ndarray
+            Preprocessed labels.
+        """
+        raise NotImplementedError
+
+    def fit(self, x: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> None:
+        """
+        Fit the parameters of the data preprocessor if it has any.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Training set to fit the preprocessor.
+        y : np.ndarray
+            Labels for the training set.
+        kwargs
+            Other parameters.
+        """
+
+    def estimate_gradient(self, x: np.ndarray, grad: np.ndarray) -> np.ndarray:  # noqa: ARG002
+        """
+        Provide an estimate of the gradients of the defence for the backward pass. If the defence is not differentiable,
+        this is an estimate of the gradient, most often replacing the computation performed by the defence with the
+        identity function (the default).
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Input data for which the gradient is estimated. First dimension is the batch size.
+        grad : np.ndarray
+            Gradient value so far.
+
+        Returns
+        -------
+        np.ndarray
+            The gradient (estimate) of the defence.
+        """
+        return grad
+
+    def set_params(self, **kwargs) -> None:  # pragma: no cover
+        """
+        Take in a dictionary of parameters and apply checks before saving them as attributes.
+
+        Parameters
+        ----------
+        kwargs
+            Dictionary of parameters to apply checks to.
+        """
+        for key, value in kwargs.items():
+            if key in self.params:
+                setattr(self, key, value)
+        self._check_params()
+
+    def _check_params(self) -> None:  # pragma: no cover
+        pass
+
+    def forward(self, x: Any, y: Any = None) -> tuple[Any, Any]:
+        """
+        Perform data preprocessing and return preprocessed data.
+
+        Parameters
+        ----------
+        x : Any
+            Dataset to be preprocessed.
+        y : Any
+            Labels to be preprocessed.
+
+        Returns
+        -------
+        Any
+            Preprocessed data.
+        """
+        raise NotImplementedError
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/__init__.py b/src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/preprocessing.py b/src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/preprocessing.py
new file mode 100644
index 00000000..6745a2e3
--- /dev/null
+++ b/src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/preprocessing.py
@@ -0,0 +1,22 @@
+# MIT License
+#
+# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2020
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+"""
+This module contains the Preprocessor API.
+"""
+# pylint: disable=W0611
+# from holisticai.security.attackers.attribute_inference.mitigation.defences.preprocessor.preprocessor import Preprocessor
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/standardisation/__init__.py b/src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/standardisation/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/standardisation/numpy.py b/src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/standardisation/numpy.py
new file mode 100644
index 00000000..baf6c3b0
--- /dev/null
+++ b/src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/standardisation/numpy.py
@@ -0,0 +1,139 @@
+# MIT License
+#
+# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2020
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+"""
+This module implements the standardisation with mean and standard deviation.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Optional, Union
+
+import numpy as np
+from holisticai.security.attackers.attribute_inference.mitigation.config import ART_NUMPY_DTYPE
+from holisticai.security.attackers.attribute_inference.mitigation.defences.preprocessor.preprocessor import Preprocessor
+from holisticai.security.attackers.attribute_inference.mitigation.preprocessing.standardisation.utils import (
+    broadcastable_mean_std,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class StandardisationMeanStd(Preprocessor):
+    """
+    Implement the standardisation with mean and standard deviation.
+
+    Parameters
+    ----------
+    mean : Union[float, np.ndarray]
+        Mean.
+    std : Union[float, np.ndarray]
+        Standard Deviation.
+    apply_fit : bool
+        Whether the preprocessor should be applied at training time.
+    apply_predict : bool
+        Whether the preprocessor should be applied at test time.
+    """
+
+    params = ["mean", "std", "apply_fit", "apply_predict"]
+
+    def __init__(
+        self,
+        mean: Union[float, np.ndarray] = 0.0,
+        std: Union[float, np.ndarray] = 1.0,
+        apply_fit: bool = True,
+        apply_predict: bool = True,
+    ):
+        super().__init__(is_fitted=True, apply_fit=apply_fit, apply_predict=apply_predict)
+        self.mean = np.asarray(mean, dtype=ART_NUMPY_DTYPE)
+        self.std = np.asarray(std, dtype=ART_NUMPY_DTYPE)
+        self._check_params()
+
+        # init broadcastable mean and std for lazy loading
+        self._broadcastable_mean: Optional[np.ndarray] = None
+        self._broadcastable_std: Optional[np.ndarray] = None
+
+    def __call__(
+        self,
+        x: np.ndarray,
+        y: Optional[np.ndarray] = None,
+    ) -> tuple[np.ndarray, Optional[np.ndarray]]:
+        """
+        Apply StandardisationMeanStd inputs `x`.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Input samples to standardise.
+        y : np.ndarray
+            Label data, will not be affected by this preprocessing.
+
+        Returns
+        -------
+        np.ndarray
+            Standardise input samples.
+        np.ndarray
+            Unmodified labels.
+        """
+        if x.dtype in [np.uint8, np.uint16, np.uint32, np.uint64]:  # pragma: no cover
+            raise TypeError(
+                f"The data type of input data `x` is {x.dtype} and cannot represent negative values. Consider "
+                f"changing the data type of the input data `x` to a type that supports negative values e.g. "
+                f"np.float32."
+            )
+
+        if self._broadcastable_mean is None:
+            self._broadcastable_mean, self._broadcastable_std = broadcastable_mean_std(x, self.mean, self.std)
+
+        x_norm = x - self._broadcastable_mean
+        x_norm = x_norm / self._broadcastable_std
+        x_norm = x_norm.astype(ART_NUMPY_DTYPE)
+
+        return x_norm, y
+
+    def estimate_gradient(self, x: np.ndarray, grad: np.ndarray) -> np.ndarray:
+        """
+        Provide an estimate of the gradients of preprocessor for the backward pass. If the preprocessor is not
+        differentiable, this is an estimate of the gradient, most often replacing the computation performed by the
+        preprocessor with the identity function (the default).
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Input data for which the gradient is estimated. First dimension is the batch size.
+        grad : np.ndarray
+            Gradient value so far.
+
+        Returns
+        -------
+        np.ndarray
+            The gradient (estimate) of the defence.
+        """
+        _, std = broadcastable_mean_std(x, self.mean, self.std)
+        gradient_back = grad / std
+
+        return gradient_back
+
+    def _check_params(self) -> None:
+        pass
+
+    def __repr__(self):
+        return (
+            f"StandardisationMeanStd(mean={self.mean}, std={self.std}, apply_fit={self.apply_fit}, "
+            f"apply_predict={self.apply_predict})"
+        )
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/standardisation/utils.py b/src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/standardisation/utils.py
new file mode 100644
index 00000000..9080eda2
--- /dev/null
+++ b/src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/standardisation/utils.py
@@ -0,0 +1,53 @@
+# MIT License
+#
+# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2021
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+"""
+This module implements utilities for standardisation with mean and standard deviation.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+
+def broadcastable_mean_std(x: np.ndarray, mean: np.ndarray, std: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    """
+    Ensure that the mean and standard deviation are broadcastable with respect to input `x`.
+
+    Parameters
+    ----------
+    x : np.ndarray
+        Input samples to standardise.
+    mean : np.ndarray
+        Mean.
+    std : np.ndarray
+        Standard Deviation.
+    """
+    if mean.shape != std.shape:  # pragma: no cover
+        raise ValueError("The shape of mean and the standard deviation must be identical.")
+
+    # catch non-broadcastable input, when mean and std are vectors
+    if mean.ndim == 1 and mean.shape[0] > 1 and mean.shape[0] != x.shape[-1]:
+        # allow input shapes NC* (batch) and C* (non-batch)
+        channel_idx = 1 if x.shape[1] == mean.shape[0] else 0
+        broadcastable_shape = [1] * x.ndim
+        broadcastable_shape[channel_idx] = mean.shape[0]
+
+        # expand mean and std to new shape
+        mean = mean.reshape(broadcastable_shape)
+        std = std.reshape(broadcastable_shape)
+    return mean, std
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/scikitlearn.py b/src/holisticai/security/attackers/attribute_inference/mitigation/scikitlearn.py
new file mode 100644
index 00000000..601415ee
--- /dev/null
+++ b/src/holisticai/security/attackers/attribute_inference/mitigation/scikitlearn.py
@@ -0,0 +1,140 @@
+"""
+This module implements attribute inference attacks.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+import numpy as np
+from holisticai.security.attackers.attribute_inference.attack import AttributeInferenceAttack
+from holisticai.security.attackers.attribute_inference.wrappers.classification.scikitlearn import (
+    ScikitlearnDecisionTreeClassifier,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class AttributeInferenceWhiteBoxDecisionTree(AttributeInferenceAttack):
+    """
+    A variation of the method proposed by of Fredrikson et al. in:
+    https://dl.acm.org/doi/10.1145/2810103.2813677
+
+    Assumes the availability of the attacked model's predictions for the samples under attack, in addition to access to
+    the model itself and the rest of the feature values. If this is not available, the true class label of the samples
+    may be used as a proxy. Also assumes that the attacked feature is discrete or categorical, with limited number of
+    possible values. For example: a boolean feature.
+
+    Parameters
+    ----------
+    classifier : ScikitlearnDecisionTreeClassifier
+        Target classifier.
+    attack_feature : int
+        The index of the feature to be attacked.
+
+    References
+    ----------
+    .. [1] Fredrikson, M., Jha, S., & Ristenpart, T. (2015, August). Model inversion attacks that exploit confidence
+           information and basic countermeasures. In Proceedings of the 22nd ACM SIGSAC Conference on Computer and
+           Communications Security (pp. 1322-1333).
+    """
+
+    _estimator_requirements = (ScikitlearnDecisionTreeClassifier,)
+
+    # def __init__(self, classifier: ScikitlearnDecisionTreeClassifier, attack_feature: int = 0):
+    def __init__(self, classifier, attack_feature: int = 0):
+        super().__init__(estimator=classifier, attack_feature=attack_feature)
+        self.attack_feature: int
+        self._check_params()
+
+    def infer(self, x: np.ndarray, y: np.ndarray, **kwargs) -> np.ndarray:
+        """
+        Infer the attacked feature.
+
+        If the model's prediction coincides with the real prediction for the sample for a single value, choose it as the
+        predicted value. If not, fall back to the Fredrikson method (without phi)
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Input to attack. Includes all features except the attacked feature.
+        y : np.ndarray
+            Original model's predictions for x.
+        values : list
+            Possible values for attacked feature.
+        priors : list
+            Prior distributions of attacked feature values. Same size array as `values`.
+
+        Returns
+        -------
+        np.ndarray
+            The inferred feature values.
+        """
+        if "priors" not in kwargs:  # pragma: no cover
+            raise ValueError("Missing parameter `priors`.")
+        if "values" not in kwargs:  # pragma: no cover
+            raise ValueError("Missing parameter `values`.")
+        priors: Optional[list] = kwargs.get("priors")
+        values: Optional[list] = kwargs.get("values")
+
+        if priors is None or values is None:  # pragma: no cover
+            raise ValueError("`priors` and `values` are required as inputs.")
+        if len(priors) != len(values):  # pragma: no cover
+            raise ValueError("Number of priors does not match number of values")
+
+        n_values = len(values)
+        n_samples = x.shape[0]
+
+        # Will contain the model's predictions for each value
+        pred_values = []
+        # Will contain the probability of each value
+        prob_values = []
+
+        for i, value in enumerate(values):
+            # prepare data with the given value in the attacked feature
+            v_full = np.full((n_samples, 1), value).astype(x.dtype)
+            x_value = np.concatenate((x[:, : self.attack_feature], v_full), axis=1)
+            x_value = np.concatenate((x_value, x[:, self.attack_feature :]), axis=1)
+
+            # Obtain the model's prediction for each possible value of the attacked feature
+            pred_value = [np.argmax(arr) for arr in self.estimator.predict_proba(x_value)]
+            pred_values.append(pred_value)
+
+            # find the relative probability of this value for all samples being attacked
+            prob_value = [
+                (
+                    (self.estimator.get_samples_at_node(self.estimator.get_decision_path([row])[-1]) / n_samples)
+                    * priors[i]
+                )
+                for row in x_value
+            ]
+            prob_values.append(prob_value)
+
+        # Find the single value that coincides with the real prediction for the sample (if it exists)
+        pred_rows = zip(*pred_values)
+        predicted_pred = []
+        for row_index, row in enumerate(pred_rows):
+            if y is not None:
+                matches = [1 if row[value_index] == y[row_index] else 0 for value_index in range(n_values)]
+                match_values = [
+                    values[value_index] if row[value_index] == y[row_index] else 0 for value_index in range(n_values)
+                ]
+            else:
+                matches = [0 for _ in range(n_values)]
+                match_values = [0 for _ in range(n_values)]
+            predicted_pred.append(sum(match_values) if sum(matches) == 1 else None)
+
+        # Choose the value with highest probability for each sample
+        predicted_prob = [np.argmax(list(prob)) for prob in zip(*prob_values)]
+
+        return np.array(
+            [
+                value if value is not None else values[predicted_prob[index]]
+                for index, value in enumerate(predicted_pred)
+            ]
+        )
+
+    def _check_params(self) -> None:
+        if self.attack_feature < 0:
+            raise ValueError("Attack feature must be positive.")
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/utils/__init__.py b/src/holisticai/security/attackers/attribute_inference/mitigation/utils/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/utils/exceptions.py b/src/holisticai/security/attackers/attribute_inference/mitigation/utils/exceptions.py
new file mode 100644
index 00000000..34568691
--- /dev/null
+++ b/src/holisticai/security/attackers/attribute_inference/mitigation/utils/exceptions.py
@@ -0,0 +1,68 @@
+# MIT License
+#
+# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2018
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+"""
+Module containing ART's exceptions.
+"""
+
+from __future__ import annotations
+
+from typing import Union
+
+
+class EstimatorError(TypeError):
+    """
+    Basic exception for errors raised by unexpected estimator types.
+
+    Parameters
+    ----------
+    this_class : type
+        The class that raised the error.
+    class_expected_list : list[type]
+        The list of expected classes.
+    classifier_given : object
+        The classifier that was given.
+    """
+
+    def __init__(self, this_class, class_expected_list: list[Union[type, tuple[type]]], classifier_given) -> None:
+        super().__init__()
+        self.this_class = this_class
+        self.class_expected_list = class_expected_list
+        self.classifier_given = classifier_given
+
+        classes_expected_message = ""
+        for idx, class_expected in enumerate(class_expected_list):
+            if idx != 0:
+                classes_expected_message += " and "
+            if isinstance(class_expected, type):
+                classes_expected_message += f"{class_expected}"
+            else:
+                classes_expected_message += "("
+                for or_idx, or_class in enumerate(class_expected):
+                    if or_idx != 0:
+                        classes_expected_message += " or "
+                    classes_expected_message += f"{or_class}"
+                classes_expected_message += ")"
+
+        self.message = (
+            f"{this_class.__name__} requires an estimator derived from {classes_expected_message}, "
+            f"the provided classifier is an instance of {type(classifier_given)} "
+            f"and is derived from {classifier_given.__class__.__bases__}."
+        )
+
+    def __str__(self) -> str:
+        return self.message
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/utils/formatting.py b/src/holisticai/security/attackers/attribute_inference/mitigation/utils/formatting.py
new file mode 100644
index 00000000..67be3d32
--- /dev/null
+++ b/src/holisticai/security/attackers/attribute_inference/mitigation/utils/formatting.py
@@ -0,0 +1,50 @@
+# # MIT License
+# #
+# # Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2018
+# #
+# # Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# # documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# # rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# # persons to whom the Software is furnished to do so, subject to the following conditions:
+# #
+# # The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# # Software.
+# #
+# # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# # TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# # SOFTWARE.
+# """
+# Module providing convenience functions.
+# """
+
+from __future__ import annotations
+
+from typing import Optional, Union
+
+import numpy as np
+
+
+def to_categorical(labels: Union[np.ndarray, list[float]], nb_classes: Optional[int] = None) -> np.ndarray:
+    """
+    Convert an array of labels to binary class matrix.
+
+    Parameters
+    ----------
+    labels : Union[np.ndarray, list[float]]
+        An array of integer labels of shape `(nb_samples,)`.
+    nb_classes : Optional[int]
+        The number of classes (possible labels).
+
+    Returns
+    -------
+    np.ndarray
+        A binary matrix representation of `y` in the shape `(nb_samples, nb_classes)`.
+    """
+    labels = np.array(labels, dtype=int)
+    if nb_classes is None:
+        nb_classes = np.max(labels) + 1
+    categorical = np.zeros((labels.shape[0], nb_classes), dtype=np.float32)
+    categorical[np.arange(labels.shape[0]), np.squeeze(labels)] = 1
+    return categorical
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/verification_decisions_trees.py b/src/holisticai/security/attackers/attribute_inference/mitigation/verification_decisions_trees.py
new file mode 100644
index 00000000..05fd7f72
--- /dev/null
+++ b/src/holisticai/security/attackers/attribute_inference/mitigation/verification_decisions_trees.py
@@ -0,0 +1,152 @@
+# MIT License
+#
+# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2018
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+"""
+This module implements robustness verifications for decision-tree-based models.
+"""
+# from __future__ import absolute_import, division, print_function, unicode_literals
+
+from __future__ import annotations
+
+from typing import Optional
+
+
+class Interval:
+    """
+    Representation of an intervals bound.
+    """
+
+    def __init__(self, lower_bound: float, upper_bound: float) -> None:
+        """
+        An interval of a feature.
+
+        :param lower_bound: The lower boundary of the feature.
+        :param upper_bound: The upper boundary of the feature.
+        """
+        self.lower_bound = lower_bound
+        self.upper_bound = upper_bound
+
+
+class Box:
+    """
+    Representation of a box of intervals bounds.
+    """
+
+    def __init__(self, intervals: Optional[dict[int, Interval]] = None) -> None:
+        """
+        A box of intervals.
+
+        :param intervals: A dictionary of intervals with features as keys.
+        """
+        if intervals is None:
+            self.intervals = {}
+        else:
+            self.intervals = intervals
+
+    def intersect_with_box(self, box: Box) -> None:
+        """
+        Get the intersection of two interval boxes. This function modifies this box instance.
+
+        :param box: Interval box to intersect with this box.
+        """
+        for key, value in box.intervals.items():
+            if key not in self.intervals:
+                self.intervals[key] = value
+            else:
+                lower_bound = max(self.intervals[key].lower_bound, value.lower_bound)
+                upper_bound = min(self.intervals[key].upper_bound, value.upper_bound)
+
+                if lower_bound >= upper_bound:  # pragma: no cover
+                    self.intervals.clear()
+                    break
+
+                self.intervals[key] = Interval(lower_bound, upper_bound)
+
+    def get_intersection(self, box: Box) -> Box:
+        """
+        Get the intersection of two interval boxes. This function creates a new box instance.
+
+        :param box: Interval box to intersect with this box.
+        """
+        box_new = Box(intervals=self.intervals.copy())
+
+        for key, value in box.intervals.items():
+            if key not in box_new.intervals:
+                box_new.intervals[key] = value
+            else:
+                lower_bound = max(box_new.intervals[key].lower_bound, value.lower_bound)
+                upper_bound = min(box_new.intervals[key].upper_bound, value.upper_bound)
+
+                if lower_bound >= upper_bound:
+                    box_new.intervals.clear()
+                    return box_new
+
+                box_new.intervals[key] = Interval(lower_bound, upper_bound)
+
+        return box_new
+
+    def __repr__(self):
+        return self.__class__.__name__ + f"({self.intervals})"
+
+
+class LeafNode:
+    """
+    Representation of a leaf node of a decision tree.
+    """
+
+    def __init__(
+        self,
+        tree_id: Optional[int],
+        class_label: int,
+        node_id: Optional[int],
+        box: Box,
+        value: float,
+    ) -> None:
+        """
+        Create a leaf node representation.
+
+        :param tree_id: ID of the decision tree.
+        :param class_label: ID of class to which this leaf node is contributing.
+        :param box: A box representing the n_feature-dimensional bounding intervals that reach this leaf node.
+        :param value: Prediction value at this leaf node.
+        """
+        self.tree_id = tree_id
+        self.class_label = class_label
+        self.node_id = node_id
+        self.box = box
+        self.value = value
+
+    def __repr__(self):
+        return (
+            self.__class__.__name__ + f"({self.tree_id}, {self.class_label}, {self.node_id}, {self.box}, {self.value})"
+        )
+
+
+class Tree:
+    """
+    Representation of a decision tree.
+    """
+
+    def __init__(self, class_id: Optional[int], leaf_nodes: list[LeafNode]) -> None:
+        """
+        Create a decision tree representation.
+
+        :param class_id: ID of the class to which this decision tree contributes.
+        :param leaf_nodes: A list of leaf nodes of this decision tree.
+        """
+        self.class_id = class_id
+        self.leaf_nodes = leaf_nodes
diff --git a/src/holisticai/security/attackers/attribute_inference/true_label_baseline.py b/src/holisticai/security/attackers/attribute_inference/true_label_baseline.py
new file mode 100644
index 00000000..5ec1d363
--- /dev/null
+++ b/src/holisticai/security/attackers/attribute_inference/true_label_baseline.py
@@ -0,0 +1,145 @@
+"""
+This module implements attribute inference attacks.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Optional, Union
+
+import numpy as np
+from holisticai.security.attackers.attribute_inference.attack import AttributeInferenceAttack
+from holisticai.security.attackers.attribute_inference.dataset_utils import AttributeInferenceDataPreprocessor
+from holisticai.security.attackers.attribute_inference.utils import get_attack_model, get_feature_index
+from sklearn.base import ClassifierMixin
+
+logger = logging.getLogger(__name__)
+
+
+class AttributeInferenceBaselineTrueLabel(AttributeInferenceAttack):
+    """
+    Implementation of a baseline attribute inference, not using a model.
+
+    The idea is to train a simple neural network to learn the attacked feature from the rest of the features, and the
+    true label. Should be used to compare with other attribute inference results.
+
+    Parameters
+    ----------
+    attack_model_type : str
+        The type of default attack model to train, optional. Should be one of `nn` (for neural network, default) or `rf`
+        (for random forest). If `attack_model` is supplied, this option will be ignored.
+    attack_model : object
+        The attack model to train, optional. If none is provided, a default model will be created.
+    attack_feature : int or slice
+        The index of the feature to be attacked or a slice representing multiple indexes in case of a one-hot encoded
+        feature.
+    is_regression : bool
+        Whether the model is a regression model. Default is False (classification).
+    scale_range : tuple
+        If supplied, the class labels (both true and predicted) will be scaled to the given range. Only applicable when
+        `is_regression` is True.
+    prediction_normal_factor : float
+        If supplied, the class labels (both true and predicted) are multiplied by the factor when used as inputs to the
+        attack-model. Only applicable when `is_regression` is True and if `scale_range` is not supplied.
+    """
+
+    _estimator_requirements = ()
+
+    def __init__(
+        self,
+        attack_model_type: str = "nn",
+        attack_model=None,
+        attack_feature: Union[int, slice] = 0,
+        is_regression: Optional[bool] = False,
+        scale_range: Optional[tuple[float, float]] = None,
+        prediction_normal_factor: float = 1,
+    ):
+        super().__init__(estimator=None, attack_feature=attack_feature)
+
+        self._values: Optional[list] = None
+        self._nb_classes: Optional[int] = None
+
+        if attack_model:
+            if ClassifierMixin not in type(attack_model).__mro__:
+                raise ValueError("Attack model must be of type Classifier.")
+            self.attack_model = attack_model
+        else:
+            self.attack_model = get_attack_model(attack_model_type)
+
+        self.prediction_normal_factor = prediction_normal_factor
+        self.scale_range = scale_range
+        self.is_regression = is_regression
+        self._check_params()
+        self.attack_feature = get_feature_index(self.attack_feature)
+        self.ai_preprocessor = AttributeInferenceDataPreprocessor(
+            is_regression=is_regression,
+            scale_range=scale_range,
+            prediction_normal_factor=prediction_normal_factor,
+            attack_feature=attack_feature,
+        )
+
+    def fit(self, x: np.ndarray, y: np.ndarray) -> None:
+        """
+        Train the attack model.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Input to training process. Includes all features used to train the original model.
+        y : np.ndarray
+            True labels of the features.
+        """
+
+        # train attack model
+        attack_x, attack_y = self.ai_preprocessor.fit_transform(x, y)
+        self._values = self.ai_preprocessor._values  # noqa: SLF001
+        self.attack_model.fit(attack_x, attack_y)
+
+    def infer(self, x: np.ndarray, y: np.ndarray, **kwargs) -> np.ndarray:
+        """
+        Infer the attacked feature.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Input to attack. Includes all features except the attacked feature.
+        y : np.ndarray
+            True labels of the features.
+        values : list
+            Possible values for attacked feature. For a single column feature this should be a simple list containing
+            all possible values, in increasing order (the smallest value in the 0 index and so on). For a multi-column
+            feature (for example 1-hot encoded and then scaled), this should be a list of lists, where each internal
+            list represents a column (in increasing order) and the values represent the possible values for that column
+            (in increasing order).
+
+        Returns
+        -------
+        np.ndarray
+            The inferred feature values.
+        """
+        values: Optional[list] = kwargs.get("values")
+
+        # if provided, override the values computed in fit()
+        if values is not None:
+            self._values = values
+
+        attack_x = self.ai_preprocessor.transform(x, y)
+        predictions = self.attack_model.predict_proba(attack_x).astype(np.float32)
+
+        if self._values is not None:
+            if isinstance(self.attack_feature, int):
+                predictions = np.array([self._values[np.argmax(arr)] for arr in predictions])
+            else:
+                i = 0
+                for column in predictions.T:
+                    for index in range(len(self._values[i])):
+                        np.place(column, [column == index], self._values[i][index])
+                    i += 1
+        return np.array(predictions)
+
+    def _check_params(self) -> None:
+        if not isinstance(self.attack_feature, int) and not isinstance(self.attack_feature, slice):
+            raise TypeError("Attack feature must be either an integer or a slice object.")
+
+        if isinstance(self.attack_feature, int) and self.attack_feature < 0:
+            raise ValueError("Attack feature index must be positive.")
diff --git a/src/holisticai/security/attackers/attribute_inference/utils.py b/src/holisticai/security/attackers/attribute_inference/utils.py
new file mode 100644
index 00000000..8bc7e6d7
--- /dev/null
+++ b/src/holisticai/security/attackers/attribute_inference/utils.py
@@ -0,0 +1,150 @@
+def get_attack_model(attack_model_type):
+    """
+    Returns an attack model of the specified type.
+
+    Parameters
+    ----------
+    attack_model_type : str
+        The type of the attack model. Possible values are 'nn' for neural network and 'rf' for random forest.
+
+    Returns
+    -------
+    object
+        The attack model.
+    """
+    if attack_model_type == "nn":
+        from sklearn.neural_network import MLPClassifier
+
+        attack_model = MLPClassifier(
+            hidden_layer_sizes=(100,),
+            activation="relu",
+            solver="adam",
+            alpha=0.0001,
+            batch_size="auto",
+            learning_rate="constant",
+            learning_rate_init=0.001,
+            power_t=0.5,
+            max_iter=2000,
+            shuffle=True,
+            random_state=None,
+            tol=0.0001,
+            verbose=False,
+            warm_start=False,
+            momentum=0.9,
+            nesterovs_momentum=True,
+            early_stopping=False,
+            validation_fraction=0.1,
+            beta_1=0.9,
+            beta_2=0.999,
+            epsilon=1e-08,
+            n_iter_no_change=10,
+            max_fun=15000,
+        )
+    elif attack_model_type == "rf":
+        from sklearn.ensemble import RandomForestClassifier
+
+        attack_model = RandomForestClassifier()
+    else:
+        raise ValueError("Illegal value for parameter `attack_model_type`.")
+    return attack_model
+
+
+def is_pipeline(estimator):
+    """
+    Checks if the given estimator is a pipeline.
+
+    Parameters
+    ----------
+    estimator : object
+        The estimator to check.
+
+    Returns
+    -------
+    bool
+        True if the estimator is a pipeline.
+    """
+    from holisticai.pipeline import Pipeline
+
+    if type(estimator) is Pipeline:
+        return True
+    return None
+
+
+def model_in_pipeline(estimator):
+    """
+    Returns the model in a pipeline.
+
+    Parameters
+    ----------
+    estimator : object
+        The estimator to check.
+
+    Returns
+    -------
+    object
+        The model in the pipeline.
+    """
+    return estimator.estimator_hdl.estimator.obj
+
+
+def is_estimator_valid(estimator, estimator_requirements) -> bool:
+    """
+    Checks if the given estimator satisfies the requirements for this attack.
+
+    Parameters
+    ----------
+    estimator : object
+        The estimator to check.
+    estimator_requirements : list
+        The requirements for the estimator.
+
+    Returns
+    -------
+    bool
+        True if the estimator is valid for the attack.
+    """
+
+    if is_pipeline(estimator):
+        model = model_in_pipeline(estimator)
+        return is_estimator_valid(model, estimator_requirements)
+
+    for req in estimator_requirements:
+        # A requirement is either a class which the estimator must inherit from, or a tuple of classes and the
+        # estimator is required to inherit from at least one of the classes
+        if isinstance(req, tuple):
+            if all(p not in type(estimator).__mro__ for p in req):
+                return False
+        elif req not in type(estimator).__mro__:
+            return False
+    return True
+
+
+def get_feature_index(feature):
+    """
+    Returns a modified feature index: in case of a slice of size 1, returns the corresponding integer. Otherwise,
+    returns the same value (integer or slice) as passed.
+
+    Parameters
+    ----------
+    feature : int or slice
+        The index or slice representing a feature to attack (0-based).
+
+    Returns
+    -------
+    int or slice
+        An integer representing a single column index or a slice representing a multi-column index.
+    """
+    if isinstance(feature, int):
+        return feature
+
+    start = feature.start
+    stop = feature.stop
+    step = feature.step
+    if start is None:
+        start = 0
+    if step is None:
+        step = 1
+    if feature.stop is not None and ((stop - start) // step) == 1:
+        return start
+
+    return feature
diff --git a/src/holisticai/security/attackers/attribute_inference/wrappers/__init__.py b/src/holisticai/security/attackers/attribute_inference/wrappers/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/src/holisticai/security/attackers/attribute_inference/wrappers/classification/__init__.py b/src/holisticai/security/attackers/attribute_inference/wrappers/classification/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/src/holisticai/security/attackers/attribute_inference/wrappers/classification/classifier.py b/src/holisticai/security/attackers/attribute_inference/wrappers/classification/classifier.py
new file mode 100644
index 00000000..af70174a
--- /dev/null
+++ b/src/holisticai/security/attackers/attribute_inference/wrappers/classification/classifier.py
@@ -0,0 +1,254 @@
+# MIT License
+#
+# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2018
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+"""
+This module implements mixin abstract base classes defining properties for all classifiers in ART.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, ABCMeta, abstractmethod
+from typing import Optional, Union
+
+import numpy as np
+from holisticai.security.attackers.attribute_inference.wrappers.estimator import (
+    BaseEstimator,
+    DecisionTreeMixin,
+    LossGradientsMixin,
+)
+
+
+class InputFilter(ABCMeta):
+    """
+    Metaclass to ensure that inputs are ndarray for all of the subclass generate and extract calls.
+
+    This metaclass is used to ensure that the input to all generate and extract methods is an ndarray. This is
+    necessary because the input to these methods is often a list or a pandas DataFrame, and the methods themselves
+    are not always implemented to handle these types of inputs. This metaclass overrides the generate and extract
+    methods with new methods that ensure the input is an ndarray.
+
+    Parameters
+    ----------
+    name : str
+        The name of the class.
+    bases : tuple
+        The base classes of the class.
+    clsdict : dict
+        The class dictionary.
+    """
+
+    def __init__(cls, name, bases, clsdict):  # noqa: ARG003
+        def make_replacement(fdict, func_name, has_y):
+            """
+            This function overrides creates replacement functions dynamically.
+
+            Parameters
+            ----------
+            fdict : dict
+                The class dictionary.
+            func_name : str
+                The name of the function to override.
+            has_y : bool
+                Whether the function has a y parameter.
+
+            Returns
+            -------
+            replacement_function : function
+                The replacement function.
+            """
+
+            def replacement_function(self, *args, **kwargs):
+                """
+                Replacement function.
+
+                Parameters
+                ----------
+                self : object
+                    The object.
+                args : list
+                    The arguments.
+                kwargs : dict
+                    The keyword arguments.
+
+                Returns
+                -------
+                result : object
+                    The result.
+                """
+                if len(args) > 0:
+                    lst = list(args)
+
+                if "X" in kwargs:
+                    if not isinstance(kwargs["X"], np.ndarray):
+                        np.array(kwargs["X"])
+                    kwargs["x"] = kwargs["X"].copy()
+                    del kwargs["X"]
+
+                elif "x" in kwargs:  # pragma: no cover
+                    if not isinstance(kwargs["x"], np.ndarray):
+                        kwargs["x"] = np.array(kwargs["x"])
+                elif not isinstance(args[0], np.ndarray):
+                    lst[0] = np.array(args[0])
+
+                if "y" in kwargs:  # pragma: no cover
+                    if kwargs["y"] is not None and not isinstance(kwargs["y"], np.ndarray):
+                        kwargs["y"] = np.array(kwargs["y"])
+                elif has_y:  # pragma: no cover  # noqa: SIM102
+                    if not isinstance(args[1], np.ndarray):
+                        lst[1] = np.array(args[1])
+
+                if len(args) > 0:
+                    args = tuple(lst)
+                return fdict[func_name](self, *args, **kwargs)
+
+            replacement_function.__doc__ = fdict[func_name].__doc__
+            replacement_function.__name__ = "new_" + func_name
+            return replacement_function
+
+        replacement_list_no_y = ["predict"]
+        replacement_list_has_y = ["fit"]
+
+        for item in replacement_list_no_y:
+            if item in clsdict:
+                new_function = make_replacement(clsdict, item, False)
+                setattr(cls, item, new_function)
+        for item in replacement_list_has_y:
+            if item in clsdict:
+                new_function = make_replacement(clsdict, item, True)
+                setattr(cls, item, new_function)
+
+
+class ClassifierMixin(ABC, metaclass=InputFilter):
+    """
+    Mixin abstract base class defining functionality for classifiers.
+
+    This abstract base class defines the properties of a classifier and provides functionality to set and get the number
+    of classes in the data. It also provides an interface to clone the classifier for refitting.
+
+    Parameters
+    ----------
+    nb_classes : int
+        The number of output classes.
+    """
+
+    estimator_params = ["nb_classes"]
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)  # type: ignore
+        self._nb_classes: int = -1
+
+    @property
+    def nb_classes(self) -> int:
+        """
+        Return the number of output classes.
+
+        Returns
+        -------
+        nb_classes : int
+            Number of classes in the data.
+        """
+        return self._nb_classes  # type: ignore
+
+    @nb_classes.setter
+    def nb_classes(self, nb_classes: int):
+        """
+        Set the number of output classes.
+
+        Parameters
+        ----------
+        nb_classes : int
+            Number of classes in the data.
+
+        Raises
+        ------
+        ValueError
+            If `nb_classes` is less than 2.
+        """
+        if nb_classes is None or nb_classes < 2:
+            raise ValueError("nb_classes must be greater than or equal to 2.")
+
+        self._nb_classes = nb_classes
+
+    def clone_for_refitting(self):
+        """
+        Clone classifier for refitting.
+        """
+        raise NotImplementedError
+
+
+class ClassGradientsMixin(ABC):
+    """
+    Mixin abstract base class defining classifiers providing access to class gradients. A classifier of this type can
+    be combined with certain white-box attacks. This mixin abstract base class has to be mixed in with
+    class `Classifier`.
+    """
+
+    @abstractmethod
+    def class_gradient(self, x: np.ndarray, label: Optional[Union[int, list[int]]] = None, **kwargs) -> np.ndarray:
+        """
+        Compute per-class derivatives w.r.t. `x`.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Samples.
+        label : int, list of int, or None
+            Index of a specific per-class derivative. If an integer is provided, the gradient of that class output is
+            computed for all samples. If multiple values as provided, the first dimension should match the batch size of
+            `x`, and each value will be used as target for its corresponding sample in `x`. If `None`, then gradients
+            for all classes will be computed for each sample.
+
+        Returns
+        -------
+        np.ndarray
+            Gradients of input features w.r.t. each class in the form `(batch_size, nb_classes, input_shape)` when
+            computing for all classes, otherwise shape becomes `(batch_size, 1, input_shape)` when `label` parameter is
+            specified.
+        """
+        raise NotImplementedError
+
+
+class Classifier(ClassifierMixin, BaseEstimator, ABC):
+    """
+    Typing variable definition.
+    """
+
+    estimator_params = BaseEstimator.estimator_params + ClassifierMixin.estimator_params
+
+
+class ClassifierLossGradients(ClassifierMixin, LossGradientsMixin, BaseEstimator, ABC):
+    """
+    Typing variable definition.
+    """
+
+    estimator_params = BaseEstimator.estimator_params + ClassifierMixin.estimator_params
+
+
+class ClassifierClassLossGradients(ClassGradientsMixin, ClassifierMixin, LossGradientsMixin, BaseEstimator, ABC):
+    """
+    Typing variable definition.
+    """
+
+    estimator_params = BaseEstimator.estimator_params + ClassifierMixin.estimator_params
+
+
+class ClassifierDecisionTree(DecisionTreeMixin, ClassifierMixin, BaseEstimator, ABC):
+    """
+    Typing variable definition.
+    """
+
+    estimator_params = BaseEstimator.estimator_params + ClassifierMixin.estimator_params
diff --git a/src/holisticai/security/attackers/attribute_inference/wrappers/classification/scikitlearn.py b/src/holisticai/security/attackers/attribute_inference/wrappers/classification/scikitlearn.py
new file mode 100644
index 00000000..c93fdadf
--- /dev/null
+++ b/src/holisticai/security/attackers/attribute_inference/wrappers/classification/scikitlearn.py
@@ -0,0 +1,1627 @@
+# MIT License
+#
+# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2018
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+"""
+This module implements the classifiers for scikit-learn models.
+"""
+
+from __future__ import annotations
+
+import importlib
+import logging
+import os
+import pickle
+from copy import deepcopy
+from typing import Callable, Optional, Union
+
+import numpy as np
+from holisticai.security.attackers.attribute_inference.mitigation import config
+from holisticai.security.attackers.attribute_inference.mitigation.utils.formatting import to_categorical
+from holisticai.security.attackers.attribute_inference.wrappers.classification.classifier import (
+    ClassGradientsMixin,
+    ClassifierMixin,
+)
+from holisticai.security.attackers.attribute_inference.wrappers.estimator import DecisionTreeMixin, LossGradientsMixin
+from holisticai.security.attackers.attribute_inference.wrappers.regression.scikitlearn import (
+    ScikitlearnDecisionTreeRegressor,
+)
+from holisticai.security.attackers.attribute_inference.wrappers.scikitlearn import ScikitlearnEstimator
+
+logger = logging.getLogger(__name__)
+
+
+def SklearnClassifier(  # noqa: N802
+    model,
+    clip_values=None,
+    preprocessing_defences=None,
+    postprocessing_defences=None,
+    preprocessing=(0.0, 1.0),
+    use_logits: bool = False,
+):
+    """
+    Create a `Classifier` instance from a scikit-learn Classifier model. This is a convenience function that
+    instantiates the correct class for the given scikit-learn model.
+
+    Parameters
+    ----------
+    model : scikit-learn Classifier model
+        The scikit-learn Classifier model.
+    clip_values : tuple
+        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
+    preprocessing_defences : `Preprocessor` or `list`
+        Preprocessing defence(s) to be applied by the classifier.
+    postprocessing_defences : `Postprocessor` or `list`
+        Postprocessing defence(s) to be applied by the classifier.
+    preprocessing : tuple
+        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data
+        preprocessing. The first value will be subtracted from the input. The input will then be divided by the
+        second one.
+
+    Returns
+    -------
+    Classifier
+        The `Classifier` instance.
+    """
+    if model.__class__.__module__.split(".")[0] != "sklearn":  # pragma: no cover
+        raise TypeError(f"Model is not an sklearn model. Received '{model.__class__}'")
+
+    sklearn_name = model.__class__.__name__
+    module = importlib.import_module(
+        "holisticai.security.attackers.attribute_inference.wrappers.classification.scikitlearn"
+    )
+    if hasattr(module, f"Scikitlearn{sklearn_name}"):
+        return getattr(module, f"Scikitlearn{sklearn_name}")(
+            model=model,
+            clip_values=clip_values,
+            preprocessing_defences=preprocessing_defences,
+            postprocessing_defences=postprocessing_defences,
+            preprocessing=preprocessing,
+        )
+
+    # This basic class at least generically handles `fit`, `predict` and `save`
+    return ScikitlearnClassifier(
+        model,
+        clip_values,
+        preprocessing_defences,
+        postprocessing_defences,
+        preprocessing,
+        use_logits,
+    )
+
+
+class ScikitlearnClassifier(ClassifierMixin, ScikitlearnEstimator):  # lgtm [py/missing-call-to-init]
+    """
+    Class for scikit-learn classifier models. Create a `Classifier` instance from a scikit-learn classifier model.
+
+    Parameters
+    ----------
+    model : scikit-learn classifier model
+        The scikit-learn classifier model.
+    clip_values : tuple
+        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
+    preprocessing_defences : `Preprocessor` or `list`
+        Preprocessing defence(s) to be applied by the classifier.
+    postprocessing_defences : `Postprocessor` or `list`
+        Postprocessing defence(s) to be applied by the classifier.
+    preprocessing : tuple
+        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data
+        preprocessing. The first value will be subtracted from the input. The input will then be divided by the
+        second one.
+    use_logits : bool
+        Determines whether predict() returns logits instead of probabilities if available. Some adversarial attacks
+        (DeepFool) may perform better if logits are used.
+    """
+
+    estimator_params = ClassifierMixin.estimator_params + ScikitlearnEstimator.estimator_params + ["use_logits"]
+
+    def __init__(
+        self,
+        model,
+        clip_values=None,
+        preprocessing_defences=None,
+        postprocessing_defences=None,
+        preprocessing=(0.0, 1.0),
+        use_logits: bool = False,
+    ) -> None:
+        super().__init__(
+            model=model,
+            clip_values=clip_values,
+            preprocessing_defences=preprocessing_defences,
+            postprocessing_defences=postprocessing_defences,
+            preprocessing=preprocessing,
+        )
+        self._input_shape = self._get_input_shape(model)
+        nb_classes = self._get_nb_classes()
+        if nb_classes is not None:
+            self.nb_classes = nb_classes
+        self._use_logits = use_logits
+
+    @property
+    def input_shape(self) -> tuple[int, ...]:
+        """
+        Return the shape of one input sample.
+
+        Returns
+        -------
+        tuple
+            Shape of one input sample.
+        """
+        return self._input_shape  # type: ignore
+
+    @property
+    def use_logits(self) -> bool:
+        """
+        Return the Boolean for using logits.
+
+        Returns
+        -------
+        bool
+            Boolean for using logits.
+        """
+        return self._use_logits  # type: ignore
+
+    def fit(self, x: np.ndarray, y: np.ndarray, **kwargs) -> None:
+        """
+        Fit the classifier on the training set `(x, y)`.
+
+        Parameters
+        ----------
+        x : `np.ndarray`
+            Training data.
+        y : `np.ndarray`
+            Target values (class labels) one-hot-encoded of shape `(nb_samples, nb_classes)`.
+        kwargs : `dict`
+            Dictionary of framework-specific arguments. These should be parameters supported by the `fit` function in
+            `sklearn` classifier and will be passed to this function as such.
+        """
+        # Apply preprocessing
+        x_preprocessed, y_preprocessed = self._apply_preprocessing(x, y, fit=True)
+
+        self.model.fit(x_preprocessed, y_preprocessed, **kwargs)
+        self._input_shape = self._get_input_shape(self.model)
+        self.nb_classes = self._get_nb_classes()
+
+    def predict_proba(self, x: np.ndarray, **kwargs) -> np.ndarray:  # noqa: ARG002
+        """
+        Perform prediction for a batch of inputs.
+
+        Parameters
+        ----------
+        x : `np.ndarray`
+            Input samples.
+        kwargs : `dict`
+            Dictionary of framework-specific arguments. These should be parameters supported by the `predict_proba`
+            function in `sklearn` classifier and will be passed to this function as such.
+
+        Raises
+        ------
+        ValueError
+            If the model does not have methods `predict_proba` or `predict`.
+
+        Returns
+        -------
+        `np.ndarray`
+            Array of predictions of shape `(nb_inputs, nb_classes)`.
+        """
+        # Apply defences
+        x_preprocessed, _ = self._apply_preprocessing(x, y=None, fit=False)
+
+        if self._use_logits:
+            if callable(getattr(self.model, "predict_log_proba", None)):
+                y_pred = self.model.predict_log_proba(x_preprocessed)
+            else:  # pragma: no cover
+                logger.warning(
+                    "use_logits was True but classifier did not have callable predict_log_proba member. Falling back to"
+                    " probabilities"
+                )
+        elif callable(getattr(self.model, "predict_proba", None)):
+            y_pred = self.model.predict_proba(x_preprocessed)
+        elif callable(getattr(self.model, "predict", None)):
+            y_pred = to_categorical(
+                self.model.predict(x_preprocessed),
+                nb_classes=self.model.classes_.shape[0],
+            )
+        else:  # pragma: no cover
+            raise ValueError("The provided model does not have methods `predict_proba` or `predict`.")
+
+        # Apply postprocessing
+        predictions = self._apply_postprocessing(preds=y_pred, fit=False)
+
+        return predictions
+
+    def predict(self, x: np.ndarray, **kwargs) -> np.ndarray:
+        """
+        Perform prediction for a batch of inputs.
+
+        Parameters
+        ----------
+        x : `np.ndarray`
+            Input samples.
+        kwargs : `dict`
+            Dictionary of framework-specific arguments. These should be parameters supported by the `predict` function in
+            `sklearn` classifier and will be passed to this function as such.
+
+        Returns
+        -------
+        `np.ndarray`
+            Array of predictions of shape `(nb_inputs, nb_classes)`.
+        """
+        predictions = self.predict_proba(x=x, **kwargs)
+        predictions = np.argmax(predictions, axis=1)
+        return predictions
+
+    def save(self, filename: str, path: Optional[str] = None) -> None:
+        """
+        Save a model to file in the format specific to the backend framework.
+
+        Parameters
+        ----------
+        filename : str
+            Name of the file where to store the model.
+        path : str, optional
+            Path of the folder where to store the model. If no path is specified, the model will be stored in the default
+            data location of the library `ART_DATA_PATH`.
+        """
+        full_path = os.path.join(config.ART_DATA_PATH, filename) if path is None else os.path.join(path, filename)
+        folder = os.path.split(full_path)[0]
+        if not os.path.exists(folder):  # pragma: no cover
+            os.makedirs(folder)
+
+        with open(full_path + ".pickle", "wb") as file_pickle:
+            pickle.dump(self.model, file=file_pickle)
+
+    def clone_for_refitting(self):
+        """
+        Create a copy of the classifier that can be refit from scratch.
+
+        Returns
+        -------
+        `Classifier`
+            New estimator.
+        """
+        import sklearn  # lgtm [py/repeated-import]
+
+        clone = type(self)(sklearn.base.clone(self.model))
+        params = self.get_params()
+        del params["model"]
+        clone.set_params(**params)
+        return clone
+
+    def reset(self) -> None:
+        """
+        Resets the weights of the classifier so that it can be refit from scratch.
+
+        """
+        # No need to do anything since scikitlearn models start from scratch each time fit() is called
+
+    def _get_nb_classes(self) -> int:
+        if hasattr(self.model, "n_classes_"):
+            _nb_classes = self.model.n_classes_
+        elif hasattr(self.model, "classes_"):
+            _nb_classes = self.model.classes_.shape[0]
+        elif hasattr(self.model, "steps"):
+            _nb_classes = self.model.steps[-1][1].obj.nb_classes
+        else:
+            logger.warning("Number of classes not recognised. The model might not have been fitted.")
+            _nb_classes = None
+        return _nb_classes
+
+
+class ScikitlearnDecisionTreeClassifier(ScikitlearnClassifier):
+    """
+    Create a `Classifier` instance from a scikit-learn Decision Tree Classifier model.
+
+    Parameters
+    ----------
+    model : scikit-learn Decision Tree Classifier model
+        The scikit-learn Decision Tree Classifier model.
+    clip_values : tuple
+        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
+    preprocessing_defences : `Preprocessor` or `list`
+        Preprocessing defence(s) to be applied by the classifier.
+    postprocessing_defences : `Postprocessor` or `list`
+        Postprocessing defence(s) to be applied by the classifier.
+    preprocessing : tuple
+        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data
+        preprocessing. The first value will be subtracted from the input. The input will then be divided by the
+        second one.
+    """
+
+    def __init__(
+        self,
+        model,
+        clip_values=None,
+        preprocessing_defences=None,
+        postprocessing_defences=None,
+        preprocessing=(0.0, 1.0),
+    ) -> None:
+        import sklearn  # lgtm [py/repeated-import]
+        from holisticai.pipeline import Pipeline
+
+        if isinstance(model, Pipeline):
+            if not isinstance(model.estimator_hdl.estimator, sklearn.tree.DecisionTreeClassifier) and model is not None:
+                raise TypeError("Model must be of type sklearn.tree.DecisionTreeClassifier.")
+
+        elif not isinstance(model, sklearn.tree.DecisionTreeClassifier) and model is not None:
+            raise TypeError("Model must be of type sklearn.tree.DecisionTreeClassifier.")
+
+        super().__init__(
+            model=model,
+            clip_values=clip_values,
+            preprocessing_defences=preprocessing_defences,
+            postprocessing_defences=postprocessing_defences,
+            preprocessing=preprocessing,
+        )
+
+    def get_classes_at_node(self, node_id: int) -> np.ndarray:
+        """
+        Returns the classification for a given node.
+
+        Parameters
+        ----------
+        node_id : int
+            Node id.
+
+        Returns
+        -------
+        np.ndarray
+            Classification for the node.
+        """
+        return np.argmax(self.model.tree_.value[node_id])  # type: ignore
+
+    def get_threshold_at_node(self, node_id: int) -> float:
+        """
+        Returns the threshold of given id for a node.
+
+        Parameters
+        ----------
+        node_id : int
+            Node id.
+
+        Returns
+        -------
+        float
+            Threshold value of feature split in this node.
+        """
+        return self.model.tree_.threshold[node_id]
+
+    def get_feature_at_node(self, node_id: int) -> int:
+        """
+        Returns the feature of given id for a node.
+
+        Parameters
+        ----------
+        node_id : int
+            Node id.
+
+        Returns
+        -------
+        int
+            Feature index of feature split in this node.
+        """
+        return self.model.tree_.feature[node_id]
+
+    def get_samples_at_node(self, node_id: int) -> int:
+        """
+        Returns the number of training samples mapped to a node.
+
+        Parameters
+        ----------
+        node_id : int
+            Node id.
+
+        Returns
+        -------
+        int
+            Number of samples mapped this node.
+        """
+        return self.model.tree_.n_node_samples[node_id]
+
+    def get_left_child(self, node_id: int) -> int:
+        """
+        Returns the id of the left child node of node_id.
+
+        Parameters
+        ----------
+        node_id : int
+            Node id.
+
+        Returns
+        -------
+        int
+            The indices of the left child in the tree.
+        """
+        return self.model.tree_.children_left[node_id]
+
+    def get_right_child(self, node_id: int) -> int:
+        """
+        Returns the id of the right child node of node_id.
+
+        Parameters
+        ----------
+        node_id : int
+            Node id.
+
+        Returns
+        -------
+        int
+            The indices of the right child in the tree.
+        """
+        return self.model.tree_.children_right[node_id]
+
+    def get_decision_path(self, x: np.ndarray) -> np.ndarray:
+        """
+        Returns the path through nodes in the tree when classifying x. Last one is leaf, first one root node.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Input sample.
+
+        Returns
+        -------
+        np.ndarray
+            The indices of the nodes in the array structure of the tree.
+        """
+        if len(np.shape(x)) == 1:
+            return self.model.decision_path(x.reshape(1, -1)).indices
+
+        return self.model.decision_path(x).indices
+
+    def get_values_at_node(self, node_id: int) -> np.ndarray:
+        """
+        Returns the feature of given id for a node.
+
+        Parameters
+        ----------
+        node_id : int
+            Node id.
+
+        Returns
+        -------
+        np.ndarray
+            Normalized values at node node_id.
+        """
+        return self.model.tree_.value[node_id] / np.linalg.norm(self.model.tree_.value[node_id])
+
+    def _get_leaf_nodes(self, node_id, i_tree, class_label, box):
+        from holisticai.security.attackers.attribute_inference.mitigation.verification_decisions_trees import (
+            Box,
+            Interval,
+            LeafNode,
+        )
+
+        leaf_nodes = []
+
+        if self.get_left_child(node_id) != self.get_right_child(node_id):
+            node_left = self.get_left_child(node_id)
+            node_right = self.get_right_child(node_id)
+
+            box_left = deepcopy(box)
+            box_right = deepcopy(box)
+
+            feature = self.get_feature_at_node(node_id)
+            box_split_left = Box(intervals={feature: Interval(-np.inf, self.get_threshold_at_node(node_id))})
+            box_split_right = Box(intervals={feature: Interval(self.get_threshold_at_node(node_id), np.inf)})
+
+            if box.intervals:
+                box_left.intersect_with_box(box_split_left)
+                box_right.intersect_with_box(box_split_right)
+            else:
+                box_left = box_split_left
+                box_right = box_split_right
+
+            leaf_nodes += self._get_leaf_nodes(node_left, i_tree, class_label, box_left)
+            leaf_nodes += self._get_leaf_nodes(node_right, i_tree, class_label, box_right)
+
+        else:
+            leaf_nodes.append(
+                LeafNode(
+                    tree_id=i_tree,
+                    class_label=class_label,
+                    node_id=node_id,
+                    box=box,
+                    value=self.get_values_at_node(node_id)[0, class_label],
+                )
+            )
+
+        return leaf_nodes
+
+
+class ScikitlearnExtraTreeClassifier(ScikitlearnDecisionTreeClassifier):
+    """
+    Class for scikit-learn Extra TreeClassifier Classifier models.
+
+    Parameters
+    ----------
+    model : scikit-learn Extra TreeClassifier Classifier model
+        The scikit-learn Extra TreeClassifier Classifier model.
+    clip_values : tuple
+        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
+    preprocessing_defences : `Preprocessor` or `list`
+        Preprocessing defence(s) to be applied by the classifier.
+    postprocessing_defences : `Postprocessor` or `list`
+        Postprocessing defence(s) to be applied by the classifier.
+    preprocessing : tuple
+        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data
+        preprocessing. The first value will be subtracted from the input. The input will then be divided by the
+        second one.
+    """
+
+    def __init__(
+        self,
+        model,
+        clip_values=None,
+        preprocessing_defences=None,
+        postprocessing_defences=None,
+        preprocessing=(0.0, 1.0),
+    ) -> None:
+        import sklearn  # lgtm [py/repeated-import]
+
+        if not isinstance(model, sklearn.tree.ExtraTreeClassifier):
+            raise TypeError("Model must be of type sklearn.tree.ExtraTreeClassifier.")
+
+        super().__init__(
+            model=model,
+            clip_values=clip_values,
+            preprocessing_defences=preprocessing_defences,
+            postprocessing_defences=postprocessing_defences,
+            preprocessing=preprocessing,
+        )
+
+
+class ScikitlearnAdaBoostClassifier(ScikitlearnClassifier):
+    """
+    Class for scikit-learn AdaBoost Classifier models.
+
+    Parameters
+    ----------
+    model : scikit-learn AdaBoost Classifier model
+        The scikit-learn AdaBoost Classifier model.
+    clip_values : tuple
+        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
+    preprocessing_defences : `Preprocessor` or `list`
+        Preprocessing defence(s) to be applied by the classifier.
+    postprocessing_defences : `Postprocessor` or `list`
+        Postprocessing defence(s) to be applied by the classifier.
+    preprocessing : tuple
+        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data
+        preprocessing. The first value will be subtracted from the input. The input will then be divided by the
+        second one.
+    """
+
+    def __init__(
+        self,
+        model,
+        clip_values=None,
+        preprocessing_defences=None,
+        postprocessing_defences=None,
+        preprocessing=(0.0, 1.0),
+    ) -> None:
+        import sklearn  # lgtm [py/repeated-import]
+
+        if not isinstance(model, sklearn.ensemble.AdaBoostClassifier):
+            raise TypeError("Model must be of type sklearn.ensemble.AdaBoostClassifier.")
+
+        super().__init__(
+            model=model,
+            clip_values=clip_values,
+            preprocessing_defences=preprocessing_defences,
+            postprocessing_defences=postprocessing_defences,
+            preprocessing=preprocessing,
+        )
+
+
+class ScikitlearnBaggingClassifier(ScikitlearnClassifier):
+    """
+    Class for scikit-learn Bagging Classifier models.
+
+    Parameters
+    ----------
+    model : scikit-learn Bagging Classifier model
+        The scikit-learn Bagging Classifier model.
+    clip_values : tuple
+        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
+    preprocessing_defences : `Preprocessor` or `list`
+        Preprocessing defence(s) to be applied by the classifier.
+    postprocessing_defences : `Postprocessor` or `list`
+        Postprocessing defence(s) to be applied by the classifier.
+    preprocessing : tuple
+        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data
+        preprocessing. The first value will be subtracted from the input. The input will then be divided by the
+        second one.
+    """
+
+    def __init__(
+        self,
+        model,
+        clip_values=None,
+        preprocessing_defences=None,
+        postprocessing_defences=None,
+        preprocessing=(0.0, 1.0),
+    ) -> None:
+        import sklearn  # lgtm [py/repeated-import]
+
+        if not isinstance(model, sklearn.ensemble.BaggingClassifier):
+            raise TypeError("Model must be of type sklearn.ensemble.BaggingClassifier.")
+
+        super().__init__(
+            model=model,
+            clip_values=clip_values,
+            preprocessing_defences=preprocessing_defences,
+            postprocessing_defences=postprocessing_defences,
+            preprocessing=preprocessing,
+        )
+
+
+class ScikitlearnExtraTreesClassifier(ScikitlearnClassifier, DecisionTreeMixin):
+    """
+    Class for scikit-learn Extra Trees Classifier models.
+
+    Parameters
+    ----------
+    model : scikit-learn Extra Trees Classifier model
+        The scikit-learn Extra Trees Classifier model.
+    clip_values : tuple
+        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
+    preprocessing_defences : `Preprocessor` or `list`
+        Preprocessing defence(s) to be applied by the classifier.
+    postprocessing_defences : `Postprocessor` or `list`
+        Postprocessing defence(s) to be applied by the classifier.
+    preprocessing : tuple
+        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data
+        preprocessing. The first value will be subtracted from the input. The input will then be divided by the
+        second one.
+    """
+
+    def __init__(
+        self,
+        model,
+        clip_values=None,
+        preprocessing_defences=None,
+        postprocessing_defences=None,
+        preprocessing=(0.0, 1.0),
+    ):
+        import sklearn  # lgtm [py/repeated-import]
+
+        if not isinstance(model, sklearn.ensemble.ExtraTreesClassifier):
+            raise TypeError("Model must be of type sklearn.ensemble.ExtraTreesClassifier.")
+
+        super().__init__(
+            model=model,
+            clip_values=clip_values,
+            preprocessing_defences=preprocessing_defences,
+            postprocessing_defences=postprocessing_defences,
+            preprocessing=preprocessing,
+        )
+
+    def get_trees(self):  # lgtm [py/similar-function]
+        """
+        Get the decision trees.
+
+        Returns
+        -------
+        list
+            A list of decision trees.
+        """
+        from holisticai.security.attackers.attribute_inference.mitigation.verification_decisions_trees import Box, Tree
+
+        trees = []
+
+        for i_tree, decision_tree_model in enumerate(self.model.estimators_):
+            box = Box()
+
+            extra_tree_classifier = ScikitlearnExtraTreeClassifier(model=decision_tree_model)
+
+            for i_class in range(self.model.n_classes_):
+                class_label = i_class
+
+                trees.append(
+                    Tree(
+                        class_id=class_label,
+                        leaf_nodes=extra_tree_classifier._get_leaf_nodes(0, i_tree, class_label, box),  # noqa: SLF001
+                    )
+                )
+
+        return trees
+
+
+class ScikitlearnGradientBoostingClassifier(ScikitlearnClassifier, DecisionTreeMixin):
+    """
+    Class for scikit-learn Gradient Boosting Classifier models.
+
+    Parameters
+    ----------
+    model : scikit-learn Gradient Boosting Classifier model
+        The scikit-learn Gradient Boosting Classifier model.
+    clip_values : tuple
+        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
+    preprocessing_defences : `Preprocessor` or `list`
+        Preprocessing defence(s) to be applied by the classifier.
+    postprocessing_defences : `Postprocessor` or `list`
+        Postprocessing defence(s) to be applied by the classifier.
+    preprocessing : tuple
+        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data
+        preprocessing. The first value will be subtracted from the input. The input will then be divided by the
+        second one.
+    """
+
+    def __init__(
+        self,
+        model,
+        clip_values=None,
+        preprocessing_defences=None,
+        postprocessing_defences=None,
+        preprocessing=(0.0, 1.0),
+    ) -> None:
+        import sklearn
+
+        if not isinstance(model, sklearn.ensemble.GradientBoostingClassifier):
+            raise TypeError("Model must be of type sklearn.ensemble.GradientBoostingClassifier.")
+
+        super().__init__(
+            model=model,
+            clip_values=clip_values,
+            preprocessing_defences=preprocessing_defences,
+            postprocessing_defences=postprocessing_defences,
+            preprocessing=preprocessing,
+        )
+
+    def get_trees(self):
+        """
+        Get the decision trees.
+
+        Returns
+        -------
+        list
+            A list of decision trees.
+        """
+        from holisticai.security.attackers.attribute_inference.mitigation.verification_decisions_trees import Box, Tree
+
+        trees = []
+        num_trees, num_classes = self.model.estimators_.shape
+
+        for i_tree in range(num_trees):
+            box = Box()
+
+            for i_class in range(num_classes):
+                decision_tree_classifier = ScikitlearnDecisionTreeRegressor(
+                    model=self.model.estimators_[i_tree, i_class]
+                )
+
+                class_label = None if num_classes == 2 else i_class
+
+                trees.append(
+                    Tree(
+                        class_id=class_label,
+                        leaf_nodes=decision_tree_classifier._get_leaf_nodes(0, i_tree, class_label, box),  # noqa: SLF001
+                    )
+                )
+
+        return trees
+
+
+class ScikitlearnRandomForestClassifier(ScikitlearnClassifier):
+    """
+    Class for scikit-learn Random Forest Classifier models.
+
+    Parameters
+    ----------
+    model : scikit-learn Random Forest Classifier model
+        The scikit-learn Random Forest Classifier model.
+    clip_values : tuple of float
+        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
+    preprocessing_defences : `Preprocessor` or `list`
+        Preprocessing defence(s) to be applied by the classifier.
+    postprocessing_defences : `Postprocessor` or `list`
+        Postprocessing defence(s) to be applied by the classifier.
+    preprocessing : tuple of float
+        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data
+        preprocessing. The first value will be subtracted from the input. The input will then be divided by the
+        second one.
+    """
+
+    def __init__(
+        self,
+        model,
+        clip_values=None,
+        preprocessing_defences=None,
+        postprocessing_defences=None,
+        preprocessing=(0.0, 1.0),
+    ) -> None:
+        import sklearn
+
+        if not isinstance(model, sklearn.ensemble.RandomForestClassifier):
+            raise TypeError("Model must be of type sklearn.ensemble.RandomForestClassifier.")
+
+        super().__init__(
+            model=model,
+            clip_values=clip_values,
+            preprocessing_defences=preprocessing_defences,
+            postprocessing_defences=postprocessing_defences,
+            preprocessing=preprocessing,
+        )
+
+    def get_trees(self):  # lgtm [py/similar-function]
+        """
+        Get the decision trees.
+
+        :return: A list of decision trees.
+        """
+        from holisticai.security.attackers.attribute_inference.mitigation.verification_decisions_trees import Box, Tree
+
+        trees = []
+
+        for i_tree, decision_tree_model in enumerate(self.model.estimators_):
+            box = Box()
+
+            decision_tree_classifier = ScikitlearnDecisionTreeClassifier(model=decision_tree_model)
+
+            for i_class in range(self.model.n_classes_):
+                class_label = i_class
+
+                trees.append(
+                    Tree(
+                        class_id=class_label,
+                        leaf_nodes=decision_tree_classifier._get_leaf_nodes(0, i_tree, class_label, box),  # noqa: SLF001
+                    )
+                )
+
+        return trees
+
+
+class ScikitlearnLogisticRegression(ClassGradientsMixin, LossGradientsMixin, ScikitlearnClassifier):
+    """
+    Class for scikit-learn Logistic Regression models.
+
+    Parameters
+    ----------
+    model : scikit-learn Logistic Regression model
+        The scikit-learn Logistic Regression model.
+    clip_values : tuple
+        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
+    preprocessing_defences : `Preprocessor` or `list`
+        Preprocessing defence(s) to be applied by the classifier.
+    postprocessing_defences : `Postprocessor` or `list`
+        Postprocessing defence(s) to be applied by the classifier.
+    preprocessing : tuple
+        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data
+        preprocessing. The first value will be subtracted from the input. The input will then be divided by the
+        second one.
+    """
+
+    def __init__(
+        self,
+        model,
+        clip_values=None,
+        preprocessing_defences=None,
+        postprocessing_defences=None,
+        preprocessing=(0.0, 1.0),
+    ) -> None:
+        import sklearn
+
+        if not isinstance(model, sklearn.linear_model.LogisticRegression):
+            raise TypeError("Model must be of type sklearn.linear_model.LogisticRegression).")
+
+        super().__init__(
+            model=model,
+            clip_values=clip_values,
+            preprocessing_defences=preprocessing_defences,
+            postprocessing_defences=postprocessing_defences,
+            preprocessing=preprocessing,
+        )
+
+    def class_gradient(self, x: np.ndarray, label: Union[int, list[int], None] = None, **kwargs) -> np.ndarray:  # noqa: ARG002
+        """
+        Compute per-class derivatives w.r.t. `x`.
+
+        | Paper link: http://cs229.stanford.edu/proj2016/report/ItkinaWu-AdversarialAttacksonImageRecognition-report.pdf
+        | Typo in https://arxiv.org/abs/1605.07277 (equation 6)
+
+        Parameters
+        ----------
+        x : `np.ndarray`
+            Sample input with shape as expected by the model.
+        label : `int`, `list` of `int` or `None`
+            Index of a specific per-class derivative. If an integer is provided, the gradient of that class output is
+            computed for all samples. If multiple values as provided, the first dimension should match the batch size
+            of `x`, and each value will be used as target for its corresponding sample in `x`. If `None`, then gradients
+            for all classes will be computed for each sample.
+
+        Returns
+        -------
+        `np.ndarray`
+            Array of gradients of input features w.r.t. each class in the form `(batch_size, nb_classes, input_shape)`
+
+        Raises
+        ------
+        ValueError
+            If the model has not been fitted prior to calling this method or if the number of classes in the classifier
+            is not known.
+        TypeError
+            If the requested label cannot be processed.
+        """
+        if not hasattr(self.model, "coef_"):  # pragma: no cover
+            raise ValueError(
+                """Model has not been fitted. Run function `fit(x, y)` of classifier first or provide a
+            fitted model."""
+            )
+        if self.nb_classes is None:  # pragma: no cover
+            raise ValueError("Unknown number of classes in classifier.")
+        nb_samples = x.shape[0]
+
+        # Apply preprocessing
+        x_preprocessed, _ = self._apply_preprocessing(x, y=None, fit=False)
+
+        y_pred = self.model.predict_proba(X=x_preprocessed)
+        weights = self.model.coef_
+
+        if self.nb_classes > 2:  # type: ignore
+            w_weighted = np.matmul(y_pred, weights)
+
+        def _f_class_gradient(i_class, i_sample):
+            if self.nb_classes == 2:
+                return (-1.0) ** (i_class + 1.0) * y_pred[i_sample, 0] * y_pred[i_sample, 1] * weights[0, :]
+
+            return weights[i_class, :] - w_weighted[i_sample, :]
+
+        if label is None:
+            # Compute the gradients w.r.t. all classes
+            class_gradients = []
+
+            for i_class in range(self.nb_classes):  # type: ignore
+                class_gradient = np.zeros(x.shape)
+                for i_sample in range(nb_samples):
+                    class_gradient[i_sample, :] += _f_class_gradient(i_class, i_sample)
+                class_gradients.append(class_gradient)
+
+            gradients = np.swapaxes(np.array(class_gradients), 0, 1)
+
+        elif isinstance(label, int):
+            # Compute the gradients only w.r.t. the provided label
+            class_gradient = np.zeros(x.shape)
+            for i_sample in range(nb_samples):
+                class_gradient[i_sample, :] += _f_class_gradient(label, i_sample)
+
+            gradients = np.swapaxes(np.array([class_gradient]), 0, 1)
+
+        elif (
+            (isinstance(label, list) and len(label) == nb_samples)
+            or isinstance(label, np.ndarray)
+            and label.shape == (nb_samples,)
+        ):
+            # For each sample, compute the gradients w.r.t. the indicated target class (possibly distinct)
+            class_gradients = []
+            unique_labels = list(np.unique(label))
+
+            for unique_label in unique_labels:
+                class_gradient = np.zeros(x.shape)
+                for i_sample in range(nb_samples):
+                    # class_gradient[i_sample, :] += label[i_sample, unique_label] * (weights[unique_label, :]
+                    # - w_weighted[i_sample, :])
+                    class_gradient[i_sample, :] += _f_class_gradient(unique_label, i_sample)
+
+                class_gradients.append(class_gradient)
+
+            gradients = np.swapaxes(np.array(class_gradients), 0, 1)
+            lst = [unique_labels.index(i) for i in label]
+            gradients = np.expand_dims(gradients[np.arange(len(gradients)), lst], axis=1)
+
+        else:
+            raise TypeError("Unrecognized type for argument `label` with type " + str(type(label)))
+
+        gradients = self._apply_preprocessing_gradient(x, gradients)
+
+        return gradients
+
+    def loss_gradient(self, x: np.ndarray, y: np.ndarray, **kwargs) -> np.ndarray:  # noqa: ARG002
+        """
+        Compute the gradient of the loss function w.r.t. `x`.
+
+        Parameters
+        ----------
+        x : `np.ndarray`
+            Sample input with shape as expected by the model.
+        y : `np.ndarray`
+            Target values (class labels) one-hot-encoded of shape `(nb_samples, nb_classes)`.
+        kwargs : `dict`
+            Dictionary of framework-specific arguments. These should be parameters supported by the `loss_gradient`
+            function in `sklearn` classifier and will be passed to this function as such.
+
+        Returns
+        -------
+        `np.ndarray`
+            Array of gradients of the same shape as `x`.
+
+        Raises
+        ------
+        ValueError
+            If the model has not been fitted prior to calling this method.
+        """
+        from sklearn.utils.class_weight import compute_class_weight
+
+        if not hasattr(self.model, "coef_"):  # pragma: no cover
+            raise ValueError(
+                """Model has not been fitted. Run function `fit(x, y)` of classifier first or provide a
+            fitted model."""
+            )
+
+        # Apply preprocessing
+        x_preprocessed, y_preprocessed = self._apply_preprocessing(x, y, fit=False)
+
+        y_index = np.argmax(y_preprocessed, axis=1)
+        if self.model.class_weight is None or self.model.class_weight == "balanced":
+            class_weight = np.ones(self.nb_classes)
+        else:
+            class_weight = compute_class_weight(
+                class_weight=self.model.class_weight,
+                classes=self.model.classes_,
+                y=y_index,
+            )
+
+        y_pred = self.predict(x=x_preprocessed)
+        weights = self.model.coef_
+
+        errors = class_weight * (y_pred - y)
+
+        if weights.shape[0] == 1:
+            weights = np.append(-weights, weights, axis=0)
+
+        gradients = (errors @ weights) / self.model.classes_.size
+
+        gradients = self._apply_preprocessing_gradient(x, gradients)
+
+        return gradients
+
+    @staticmethod
+    def get_trainable_attribute_names() -> tuple[str, str]:
+        """
+        Get the names of trainable attributes.
+
+        Returns
+        -------
+        `tuple`
+            A tuple of trainable attributes.
+        """
+        return "intercept_", "coef_"
+
+
+class ScikitlearnGaussianNB(ScikitlearnClassifier):
+    """
+    Class for scikit-learn Gaussian Naive Bayes models.
+
+    Parameters
+    ----------
+    model : scikit-learn Gaussian Naive Bayes model
+        The scikit-learn Gaussian Naive Bayes model.
+    clip_values : tuple
+        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
+    preprocessing_defences : `Preprocessor` or `list`
+        Preprocessing defence(s) to be applied by the classifier.
+    postprocessing_defences : `Postprocessor` or `list`
+        Postprocessing defence(s) to be applied by the classifier.
+    preprocessing : tuple
+        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data
+        preprocessing. The first value will be subtracted from the input. The input will then be divided by the
+        second one.
+    """
+
+    def __init__(
+        self,
+        model,
+        clip_values=None,
+        preprocessing_defences=None,
+        postprocessing_defences=None,
+        preprocessing=(0.0, 1.0),
+    ) -> None:
+        import sklearn  # lgtm [py/repeated-import]
+
+        if not isinstance(model, sklearn.naive_bayes.GaussianNB):  # pragma: no cover
+            raise TypeError(f"Model must be of type sklearn.naive_bayes.GaussianNB. Found type {type(model)}")
+
+        super().__init__(
+            model=model,
+            clip_values=clip_values,
+            preprocessing_defences=preprocessing_defences,
+            postprocessing_defences=postprocessing_defences,
+            preprocessing=preprocessing,
+        )
+
+    @staticmethod
+    def get_trainable_attribute_names() -> tuple[str, str]:
+        """
+        Get the names of trainable attributes.
+
+        Returns
+        -------
+        `tuple`
+            A tuple of trainable attributes.
+        """
+        return "sigma_", "theta_"
+
+
+class ScikitlearnSVC(ClassGradientsMixin, LossGradientsMixin, ScikitlearnClassifier):
+    """
+    Class for scikit-learn C-Support Vector Classification models.
+
+    Parameters
+    ----------
+    model : scikit-learn C-Support Vector Classification model
+        The scikit-learn C-Support Vector Classification model.
+    clip_values : tuple
+        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
+    preprocessing_defences : `Preprocessor` or `list`
+        Preprocessing defence(s) to be applied by the classifier.
+    postprocessing_defences : `Postprocessor` or `list`
+        Postprocessing defence(s) to be applied by the classifier.
+    preprocessing : tuple
+        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data
+        preprocessing. The first value will be subtracted from the input. The input will then be divided by the
+        second one.
+    """
+
+    def __init__(
+        self,
+        model,
+        clip_values=None,
+        preprocessing_defences=None,
+        postprocessing_defences=None,
+        preprocessing=(0.0, 1.0),
+    ) -> None:
+        import sklearn  # lgtm [py/repeated-import]
+
+        if not isinstance(model, sklearn.svm.SVC) and not isinstance(model, sklearn.svm.LinearSVC):
+            raise TypeError(f"Model must be of type sklearn.svm.SVC or sklearn.svm.LinearSVC. Found type {type(model)}")
+
+        super().__init__(
+            model=model,
+            clip_values=clip_values,
+            preprocessing_defences=preprocessing_defences,
+            postprocessing_defences=postprocessing_defences,
+            preprocessing=preprocessing,
+        )
+        self._kernel = self._kernel_func()
+
+    def class_gradient(self, x: np.ndarray, label: Union[int, list[int], None] = None, **kwargs) -> np.ndarray:  # noqa: ARG002
+        """
+        Compute per-class derivatives w.r.t. `x`.
+
+        Parameters
+        ----------
+        x : `np.ndarray`
+            Sample input with shape as expected by the model.
+        label : `int`, `list` of `int` or `None`
+            Index of a specific per-class derivative. If an integer is provided, the gradient of that class output is
+            computed for all samples. If multiple values as provided, the first dimension should match the batch size
+            of `x`, and each value will be used as target for its corresponding sample in `x`. If `None`, then gradients
+            for all classes will be computed for each sample.
+
+        Returns
+        -------
+        `np.ndarray`
+            Array of gradients of input features w.r.t. each class in the form `(batch_size, nb_classes, input_shape)`
+        """
+        import sklearn  # lgtm [py/repeated-import]
+
+        # Apply preprocessing
+        x_preprocessed, _ = self._apply_preprocessing(x, y=None, fit=False)
+
+        num_samples, _ = x_preprocessed.shape
+
+        if isinstance(self.model, sklearn.svm.SVC):
+            if self.model.fit_status_:  # pragma: no cover
+                raise AssertionError("Model has not been fitted correctly.")
+
+            support_indices = [0, *list(np.cumsum(self.model.n_support_))]
+
+            sign_multiplier = -1 if self.nb_classes == 2 else 1
+
+            if label is None:
+                gradients = np.zeros(
+                    (
+                        x_preprocessed.shape[0],
+                        self.nb_classes,
+                        x_preprocessed.shape[1],
+                    )
+                )
+
+                for i_label in range(self.nb_classes):  # type: ignore
+                    for i_sample in range(num_samples):
+                        for not_label in range(self.nb_classes):  # type: ignore
+                            if i_label != not_label:
+                                label_multiplier = -1 if not_label < i_label else 1
+
+                                for label_sv in range(
+                                    support_indices[i_label],
+                                    support_indices[i_label + 1],
+                                ):
+                                    alpha_i_k_y_i = self.model.dual_coef_[
+                                        not_label if not_label < i_label else not_label - 1,
+                                        label_sv,
+                                    ]
+                                    grad_kernel = self._get_kernel_gradient_sv(label_sv, x_preprocessed[i_sample])
+                                    gradients[i_sample, i_label] += label_multiplier * alpha_i_k_y_i * grad_kernel
+
+                                for not_label_sv in range(
+                                    support_indices[not_label],
+                                    support_indices[not_label + 1],
+                                ):
+                                    alpha_i_k_y_i = self.model.dual_coef_[
+                                        i_label if i_label < not_label else i_label - 1,
+                                        not_label_sv,
+                                    ]
+                                    grad_kernel = self._get_kernel_gradient_sv(not_label_sv, x_preprocessed[i_sample])
+                                    gradients[i_sample, i_label] += label_multiplier * alpha_i_k_y_i * grad_kernel
+
+            elif isinstance(label, int):
+                gradients = np.zeros((x_preprocessed.shape[0], 1, x_preprocessed.shape[1]))
+
+                for i_sample in range(num_samples):
+                    for not_label in range(self.nb_classes):  # type: ignore
+                        if label != not_label:
+                            label_multiplier = -1 if not_label < label else 1
+
+                            for label_sv in range(support_indices[label], support_indices[label + 1]):
+                                alpha_i_k_y_i = self.model.dual_coef_[
+                                    not_label if not_label < label else not_label - 1,
+                                    label_sv,
+                                ]
+                                grad_kernel = self._get_kernel_gradient_sv(label_sv, x_preprocessed[i_sample])
+                                gradients[i_sample, 0] += label_multiplier * alpha_i_k_y_i * grad_kernel
+
+                            for not_label_sv in range(
+                                support_indices[not_label],
+                                support_indices[not_label + 1],
+                            ):
+                                alpha_i_k_y_i = self.model.dual_coef_[
+                                    label if label < not_label else label - 1,
+                                    not_label_sv,
+                                ]
+                                grad_kernel = self._get_kernel_gradient_sv(not_label_sv, x_preprocessed[i_sample])
+                                gradients[i_sample, 0] += label_multiplier * alpha_i_k_y_i * grad_kernel
+
+            elif (
+                (isinstance(label, list) and len(label) == num_samples)
+                or isinstance(label, np.ndarray)
+                and label.shape == (num_samples,)
+            ):
+                gradients = np.zeros((x_preprocessed.shape[0], 1, x_preprocessed.shape[1]))
+
+                for i_sample in range(num_samples):
+                    for not_label in range(self.nb_classes):  # type: ignore
+                        if label[i_sample] != not_label:
+                            label_multiplier = -1 if not_label < label[i_sample] else 1
+
+                            for label_sv in range(
+                                support_indices[label[i_sample]],
+                                support_indices[label[i_sample] + 1],
+                            ):
+                                alpha_i_k_y_i = self.model.dual_coef_[
+                                    not_label if not_label < label[i_sample] else not_label - 1,
+                                    label_sv,
+                                ]
+                                grad_kernel = self._get_kernel_gradient_sv(label_sv, x_preprocessed[i_sample])
+                                gradients[i_sample, 0] += label_multiplier * alpha_i_k_y_i * grad_kernel
+
+                            for not_label_sv in range(
+                                support_indices[not_label],
+                                support_indices[not_label + 1],
+                            ):
+                                alpha_i_k_y_i = self.model.dual_coef_[
+                                    label[i_sample] if label[i_sample] < not_label else label[i_sample] - 1,
+                                    not_label_sv,
+                                ]
+                                grad_kernel = self._get_kernel_gradient_sv(not_label_sv, x_preprocessed[i_sample])
+                                gradients[i_sample, 0] += label_multiplier * alpha_i_k_y_i * grad_kernel
+
+            else:
+                raise TypeError("Unrecognized type for argument `label` with type " + str(type(label)))
+
+            gradients = self._apply_preprocessing_gradient(x, gradients * sign_multiplier)
+
+        elif isinstance(self.model, sklearn.svm.LinearSVC):
+            if label is None:
+                gradients = np.zeros(
+                    (
+                        x_preprocessed.shape[0],
+                        self.nb_classes,
+                        x_preprocessed.shape[1],
+                    )
+                )
+
+                for i in range(self.nb_classes):  # type: ignore
+                    for i_sample in range(num_samples):
+                        if self.nb_classes == 2:
+                            gradients[i_sample, i] = self.model.coef_[0] * (2 * i - 1)
+                        else:
+                            gradients[i_sample, i] = self.model.coef_[i]
+
+            elif isinstance(label, int):
+                gradients = np.zeros((x_preprocessed.shape[0], 1, x_preprocessed.shape[1]))
+
+                for i_sample in range(num_samples):
+                    if self.nb_classes == 2:
+                        gradients[i_sample, 0] = self.model.coef_[0] * (2 * label - 1)
+                    else:
+                        gradients[i_sample, 0] = self.model.coef_[label]
+
+            elif (
+                (isinstance(label, list) and len(label) == num_samples)
+                or isinstance(label, np.ndarray)
+                and label.shape == (num_samples,)
+            ):
+                gradients = np.zeros((x_preprocessed.shape[0], 1, x_preprocessed.shape[1]))
+
+                for i_sample in range(num_samples):
+                    if self.nb_classes == 2:
+                        gradients[i_sample, 0] = self.model.coef_[0] * (2 * label[i_sample] - 1)
+                    else:
+                        gradients[i_sample, 0] = self.model.coef_[label[i_sample]]
+
+            else:
+                raise TypeError("Unrecognized type for argument `label` with type " + str(type(label)))
+
+            gradients = self._apply_preprocessing_gradient(x, gradients)
+
+        return gradients
+
+    def _kernel_grad(self, sv: np.ndarray, x_sample: np.ndarray) -> np.ndarray:
+        """
+        Applies the kernel gradient to a support vector.
+
+        Parameters
+        ----------
+        sv : `np.ndarray`
+            A support vector.
+        x_sample : `np.ndarray`
+            The sample the gradient is taken with respect to.
+
+        Returns
+        -------
+        `np.ndarray`
+            The kernel gradient.
+        """
+        if self.model.kernel == "linear":
+            grad = sv
+        elif self.model.kernel == "poly":
+            grad = (
+                self.model.degree
+                * (self.model._gamma * np.sum(x_sample * sv) + self.model.coef0) ** (self.model.degree - 1)  # noqa: SLF001
+                * sv
+            )
+        elif self.model.kernel == "rbf":
+            grad = (
+                2
+                * self.model._gamma  # noqa: SLF001
+                * (-1)
+                * np.exp(-self.model._gamma * np.linalg.norm(x_sample - sv, ord=2) ** 2)  # noqa: SLF001
+                * (x_sample - sv)
+            )
+        elif self.model.kernel == "sigmoid":
+            raise NotImplementedError
+        else:
+            raise NotImplementedError(f"Loss gradients for kernel '{self.model.kernel}' are not implemented.")
+        return grad
+
+    def _get_kernel_gradient_sv(self, i_sv: int, x_sample: np.ndarray) -> np.ndarray:
+        """
+        Applies the kernel gradient to all of a model's support vectors.
+
+        Parameters
+        ----------
+        i_sv : `int`
+            A support vector index.
+        x_sample : `np.ndarray`
+            The sample the gradient is taken with respect to.
+
+        Returns
+        -------
+        `np.ndarray`
+            The kernel gradient.
+        """
+        x_i = self.model.support_vectors_[i_sv, :]
+        return self._kernel_grad(x_i, x_sample)
+
+    def loss_gradient(self, x: np.ndarray, y: np.ndarray, **kwargs) -> np.ndarray:  # noqa: ARG002
+        """
+        Compute the gradient of the loss function w.r.t. `x`.
+        Following equation (1) with lambda=0.
+
+        | Paper link: https://pralab.diee.unica.it/sites/default/files/biggio14-svm-chapter.pdf
+
+        Parameters
+        ----------
+        x : `np.ndarray`
+            Sample input with shape as expected by the model.
+        y : `np.ndarray`
+            Target values (class labels) one-hot-encoded of shape `(nb_samples, nb_classes)`.
+        kwargs : `dict`
+            Dictionary of framework-specific arguments. These should be parameters supported by the `loss_gradient`
+            function in `sklearn` classifier and will be passed to this function as such.
+
+        Returns
+        -------
+        `np.ndarray`
+            Array of gradients of the same shape as `x`.
+
+        Raises
+        ------
+        ValueError
+            If the model has not been fitted prior to calling this method.
+
+        """
+        import sklearn  # lgtm [py/repeated-import]
+
+        # Apply preprocessing
+        x_preprocessed, y_preprocessed = self._apply_preprocessing(x, y, fit=False)
+
+        num_samples, _ = x_preprocessed.shape
+        gradients = np.zeros_like(x_preprocessed)
+        y_index = np.argmax(y_preprocessed, axis=1)
+
+        if isinstance(self.model, sklearn.svm.SVC):
+            if self.model.fit_status_:
+                raise AssertionError("Model has not been fitted correctly.")
+
+            sign_multiplier = 1 if y_preprocessed.shape[1] == 2 else -1
+
+            i_not_label_i = None
+            label_multiplier = None
+            support_indices = [0, *list(np.cumsum(self.model.n_support_))]
+
+            for i_sample in range(num_samples):
+                i_label = y_index[i_sample]
+
+                for i_not_label in range(self.nb_classes):  # type: ignore
+                    if i_label != i_not_label:
+                        if i_not_label < i_label:
+                            i_not_label_i = i_not_label
+                            label_multiplier = -1
+                        elif i_not_label > i_label:
+                            i_not_label_i = i_not_label - 1
+                            label_multiplier = 1
+
+                        for i_label_sv in range(support_indices[i_label], support_indices[i_label + 1]):
+                            alpha_i_k_y_i = self.model.dual_coef_[i_not_label_i, i_label_sv] * label_multiplier
+                            grad_kernel = self._get_kernel_gradient_sv(i_label_sv, x_preprocessed[i_sample])
+                            gradients[i_sample, :] += sign_multiplier * alpha_i_k_y_i * grad_kernel
+
+                        for i_not_label_sv in range(
+                            support_indices[i_not_label],
+                            support_indices[i_not_label + 1],
+                        ):
+                            alpha_i_k_y_i = self.model.dual_coef_[i_not_label_i, i_not_label_sv] * label_multiplier
+                            grad_kernel = self._get_kernel_gradient_sv(i_not_label_sv, x_preprocessed[i_sample])
+                            gradients[i_sample, :] += sign_multiplier * alpha_i_k_y_i * grad_kernel
+
+        elif isinstance(self.model, sklearn.svm.LinearSVC):
+            for i_sample in range(num_samples):
+                i_label = y_index[i_sample]
+                if self.nb_classes == 2:
+                    i_label_i = 0
+                    if i_label == 0:
+                        label_multiplier = 1
+                    elif i_label == 1:
+                        label_multiplier = -1
+                    else:
+                        raise ValueError("Label index not recognized because it is not 0 or 1.")
+                else:
+                    i_label_i = i_label
+                    label_multiplier = -1
+
+                gradients[i_sample] = label_multiplier * self.model.coef_[i_label_i]
+        else:
+            raise TypeError("Model not recognized.")
+
+        gradients = self._apply_preprocessing_gradient(x, gradients)
+        return gradients
+
+    def _kernel_func(self) -> Callable:
+        """
+        Return the function for the kernel of this SVM.
+
+        Returns
+        -------
+        `Callable`
+            A callable kernel function.
+        """
+        import sklearn  # lgtm [py/repeated-import]
+        from sklearn.metrics.pairwise import (
+            linear_kernel,
+            polynomial_kernel,
+            rbf_kernel,
+        )
+
+        if isinstance(self.model, sklearn.svm.LinearSVC):
+            kernel = "linear"
+        elif isinstance(self.model, sklearn.svm.SVC):
+            kernel = self.model.kernel
+        else:
+            raise NotImplementedError("SVM model not yet supported.")
+
+        if kernel == "linear":
+            kernel_func = linear_kernel
+        elif kernel == "poly":
+            kernel_func = polynomial_kernel
+        elif kernel == "rbf":
+            kernel_func = rbf_kernel
+        elif callable(kernel):
+            kernel_func = kernel
+        else:
+            raise NotImplementedError(f"Kernel '{kernel}' not yet supported.")
+
+        return kernel_func
+
+    def q_submatrix(self, rows: np.ndarray, cols: np.ndarray) -> np.ndarray:
+        """
+        Returns the q submatrix of this SVM indexed by the arrays at rows and columns.
+
+        Parameters
+        ----------
+        rows : `np.ndarray`
+            The row vectors.
+        cols : `np.ndarray`
+            The column vectors.
+
+        Returns
+        -------
+        `np.ndarray`
+            A submatrix of Q.
+        """
+        submatrix_shape = (rows.shape[0], cols.shape[0])
+        y_row = self.model.predict(rows)
+        y_col = self.model.predict(cols)
+        y_row[y_row == 0] = -1
+        y_col[y_col == 0] = -1
+        q_rc = np.zeros(submatrix_shape)
+        for row in range(q_rc.shape[0]):
+            for col in range(q_rc.shape[1]):
+                q_rc[row][col] = self._kernel([rows[row]], [cols[col]])[0][0] * y_row[row] * y_col[col]
+
+        return q_rc
+
+    def predict(self, x: np.ndarray, **kwargs) -> np.ndarray:  # noqa: ARG002
+        """
+        Perform prediction for a batch of inputs.
+
+        Parameters
+        ----------
+        x : `np.ndarray`
+            Input samples.
+
+        Returns
+        -------
+        `np.ndarray`
+            Array of predictions of shape `(nb_inputs, nb_classes)`.
+        """
+        import sklearn  # lgtm [py/repeated-import]
+
+        # Apply defences
+        x_preprocessed, _ = self._apply_preprocessing(x, y=None, fit=False)
+
+        if isinstance(self.model, sklearn.svm.SVC) and self.model.probability:
+            y_pred = self.model.predict_proba(X=x_preprocessed)
+        else:
+            y_pred_label = self.model.predict(X=x_preprocessed)
+            targets = np.array(y_pred_label).reshape(-1)
+            one_hot_targets = np.eye(self.nb_classes)[targets]
+            y_pred = one_hot_targets
+
+        return y_pred
+
+
+ScikitlearnLinearSVC = ScikitlearnSVC
diff --git a/src/holisticai/security/attackers/attribute_inference/wrappers/estimator.py b/src/holisticai/security/attackers/attribute_inference/wrappers/estimator.py
new file mode 100644
index 00000000..225cdde5
--- /dev/null
+++ b/src/holisticai/security/attackers/attribute_inference/wrappers/estimator.py
@@ -0,0 +1,468 @@
+"""
+This module implements abstract base and mixin classes for estimators in ART.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+import numpy as np
+from holisticai.security.attackers.attribute_inference.mitigation.config import ART_NUMPY_DTYPE
+
+
+class BaseEstimator(ABC):
+    """
+    The abstract base class `BaseEstimator` defines the basic requirements of an estimator in ART. The BaseEstimator is
+    is the highest abstraction of a machine learning model in ART.
+
+    Parameters
+    ----------
+    model : object
+        The model to be wrapped.
+    clip_values : tuple
+        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
+    preprocessing_defences : `Preprocessor` or `List[Preprocessor]`
+        Preprocessing defence(s) to be applied by the estimator.
+    postprocessing_defences : `Postprocessor` or `List[Postprocessor]`
+        Postprocessing defence(s) to be applied by the estimator.
+    preprocessing : tuple
+        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data preprocessing.
+        The first value will be subtracted from the input and the results will be divided by the second value.
+    """
+
+    estimator_params = [
+        "model",
+        "clip_values",
+        "preprocessing_defences",
+        "postprocessing_defences",
+        "preprocessing",
+    ]
+
+    def __init__(
+        self,
+        model,
+        clip_values,
+        preprocessing_defences=None,
+        postprocessing_defences=None,
+        preprocessing=(0.0, 1.0),
+    ):
+        self._model = model
+        self._clip_values = clip_values
+
+        self.preprocessing = self._set_preprocessing(preprocessing)
+        self.preprocessing_defences = self._set_preprocessing_defences(preprocessing_defences)
+        self.postprocessing_defences = self._set_postprocessing_defences(postprocessing_defences)
+        self.preprocessing_operations = []
+        BaseEstimator._update_preprocessing_operations(self)
+        BaseEstimator._check_params(self)
+
+    def _update_preprocessing_operations(self):
+        from holisticai.security.attackers.attribute_inference.mitigation.defences.preprocessor.preprocessor import (
+            Preprocessor,
+        )
+
+        self.preprocessing_operations.clear()
+
+        if self.preprocessing_defences is None:
+            pass
+        elif isinstance(self.preprocessing_defences, Preprocessor):
+            self.preprocessing_operations.append(self.preprocessing_defences)
+        else:
+            self.preprocessing_operations += self.preprocessing_defences
+
+        if self.preprocessing is None:
+            pass
+        elif isinstance(self.preprocessing, tuple):
+            from holisticai.security.attackers.attribute_inference.mitigation.preprocessing.standardisation.numpy import (
+                StandardisationMeanStd,
+            )
+
+            self.preprocessing_operations.append(
+                StandardisationMeanStd(mean=self.preprocessing[0], std=self.preprocessing[1])
+            )
+        elif isinstance(self.preprocessing, Preprocessor):
+            self.preprocessing_operations.append(self.preprocessing)
+        else:  # pragma: no cover
+            raise ValueError("Preprocessing argument not recognised.")
+
+    @staticmethod
+    def _set_preprocessing(preprocessing):
+        from holisticai.security.attackers.attribute_inference.mitigation.defences.preprocessor.preprocessor import (
+            Preprocessor,
+        )
+
+        if preprocessing is None:
+            return None
+        if isinstance(preprocessing, tuple):
+            from holisticai.security.attackers.attribute_inference.mitigation.preprocessing.standardisation.numpy import (
+                StandardisationMeanStd,
+            )
+
+            return StandardisationMeanStd(mean=preprocessing[0], std=preprocessing[1])  # type: ignore
+        if isinstance(preprocessing, Preprocessor):
+            return preprocessing
+
+        raise ValueError("Preprocessing argument not recognised.")  # pragma: no cover
+
+    @staticmethod
+    def _set_preprocessing_defences(preprocessing_defences):
+        from holisticai.security.attackers.attribute_inference.mitigation.defences.preprocessor.preprocessor import (
+            Preprocessor,
+        )
+
+        if isinstance(preprocessing_defences, Preprocessor):
+            return [preprocessing_defences]
+
+        return preprocessing_defences
+
+    @staticmethod
+    def _set_postprocessing_defences(postprocessing_defences):
+        from holisticai.security.attackers.attribute_inference.mitigation.defences.postprocessor.postprocessor import (
+            Postprocessor,
+        )
+
+        if isinstance(postprocessing_defences, Postprocessor):
+            return [postprocessing_defences]
+
+        return postprocessing_defences
+
+    def set_params(self, **kwargs) -> None:
+        """
+        Take a dictionary of parameters and apply checks before setting them as attributes.
+
+        Parameters
+        ----------
+        **kwargs
+            A dictionary of attributes.
+        """
+        for key, value in kwargs.items():
+            if key in self.estimator_params:
+                if hasattr(type(self), key) and isinstance(getattr(type(self), key), property):
+                    if getattr(type(self), key).fset is not None:
+                        setattr(self, key, value)
+                    else:
+                        setattr(self, "_" + key, value)
+                elif hasattr(self, "_" + key):
+                    setattr(self, "_" + key, value)
+                elif key == "preprocessing":
+                    setattr(self, key, self._set_preprocessing(value))
+                elif key == "preprocessing_defences":
+                    setattr(self, key, self._set_preprocessing_defences(value))
+                elif key == "postprocessing_defences":
+                    setattr(self, key, self._set_postprocessing_defences(value))
+                else:
+                    setattr(self, key, value)
+            else:  # pragma: no cover
+                raise ValueError(f"Unexpected parameter `{key}` found in kwargs.")
+        self._update_preprocessing_operations()
+        self._check_params()
+
+    def get_params(self) -> dict[str, Any]:
+        """
+        Get all parameters and their values of this estimator.
+
+        Returns
+        -------
+        dict
+            A dictionary of string parameter names to their value.
+        """
+        params = {}
+        for key in self.estimator_params:
+            params[key] = getattr(self, key)
+        return params
+
+    def _check_params(self) -> None:
+        from holisticai.security.attackers.attribute_inference.mitigation.defences.postprocessor.postprocessor import (
+            Postprocessor,
+        )
+        from holisticai.security.attackers.attribute_inference.mitigation.defences.preprocessor.preprocessor import (
+            Preprocessor,
+        )
+
+        if self._clip_values is not None:
+            if len(self._clip_values) != 2:  # pragma: no cover
+                raise ValueError(
+                    "`clip_values` should be a tuple of 2 floats or arrays containing the allowed data range."
+                )
+            if np.array(self._clip_values[0] >= self._clip_values[1]).any():  # pragma: no cover
+                raise ValueError("Invalid `clip_values`: min >= max.")
+
+            if isinstance(self._clip_values, np.ndarray):
+                self._clip_values = self._clip_values.astype(ART_NUMPY_DTYPE)
+            else:
+                self._clip_values = np.array(self._clip_values, dtype=ART_NUMPY_DTYPE)  # type: ignore
+
+        if isinstance(self.preprocessing_operations, list):
+            for preprocess in self.preprocessing_operations:
+                if not isinstance(preprocess, Preprocessor):  # pragma: no cover
+                    raise TypeError(
+                        "All preprocessing defences have to be instance of "
+                        "holisticai.security.attackers.attribute_inference.mitigation.defences.preprocessor.preprocessor.Preprocessor."
+                    )
+        else:  # pragma: no cover
+            raise TypeError(
+                "All preprocessing defences have to be instance of "
+                "holisticai.security.attackers.attribute_inference.mitigation.defences.preprocessor.preprocessor.Preprocessor."
+            )
+
+        if isinstance(self.postprocessing_defences, list):
+            for postproc_defence in self.postprocessing_defences:
+                if not isinstance(postproc_defence, Postprocessor):  # pragma: no cover
+                    raise TypeError(
+                        "All postprocessing defences have to be instance of "
+                        "art.defences.postprocessor.postprocessor.Postprocessor."
+                    )
+        elif self.postprocessing_defences is None:
+            pass
+        else:  # pragma: no cover
+            raise ValueError(
+                "All postprocessing defences have to be instance of "
+                "art.defences.postprocessor.postprocessor.Postprocessor."
+            )
+
+    @abstractmethod
+    def predict(self, x, **kwargs) -> Any:  # lgtm [py/inheritance/incorrect-overridden-signature]
+        """
+        Perform prediction of the estimator for input `x`.
+
+        Parameters
+        ----------
+        x : array-like
+            Input samples.
+
+        Returns
+        -------
+        array-like
+            Predictions by the model.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def fit(self, x, y, **kwargs) -> None:  # lgtm [py/inheritance/incorrect-overridden-signature]
+        """
+        Fit the estimator using the training data `(x, y)`.
+
+        Parameters
+        ----------
+        x : array-like
+            Training data.
+        y : array-like
+            Target values.
+        """
+        raise NotImplementedError
+
+    @property
+    def model(self):
+        """
+        Return the model.
+
+        Returns
+        -------
+        model
+            The model.
+        """
+        return self._model
+
+    @property
+    @abstractmethod
+    def input_shape(self) -> tuple[int, ...]:
+        """
+        Return the shape of one input sample.
+
+        Returns
+        -------
+        tuple
+            Shape of one input sample.
+        """
+        raise NotImplementedError
+
+    @property
+    def clip_values(self):
+        """
+        Return the clip values of the input samples.
+
+        Returns
+        -------
+        tuple
+            Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
+        """
+        return self._clip_values
+
+    def _apply_preprocessing(self, x, y, fit: bool) -> tuple[Any, Any]:
+        """
+        Apply all defences and preprocessing operations on the inputs `x` and `y`. This function has to be applied to
+        all raw inputs `x` and `y` provided to the estimator.
+
+        Parameters
+        ----------
+        x : array-like
+            Input samples.
+        y : array-like
+            Target values.
+        fit : bool
+            `True` if the defences are applied during training.
+
+        Returns
+        -------
+        tuple
+            Tuple of `x` and `y` after applying the defences and standardisation.
+        """
+        if self.preprocessing_operations:
+            for preprocess in self.preprocessing_operations:
+                if fit:
+                    if preprocess.apply_fit:
+                        x, y = preprocess(x, y)
+                elif preprocess.apply_predict:
+                    x, y = preprocess(x, y)
+
+        return x, y
+
+    def _apply_postprocessing(self, preds, fit: bool) -> np.ndarray:
+        """
+        Apply all postprocessing defences on model predictions.
+
+        Parameters
+        ----------
+        preds : array-like
+            Model output to be post-processed.
+        fit : bool
+            `True` if the defences are applied during training.
+
+        Returns
+        -------
+        array-like
+            Post-processed model predictions.
+        """
+        post_preds = preds.copy()
+        if self.postprocessing_defences is not None:
+            for defence in self.postprocessing_defences:
+                if fit:
+                    if defence.apply_fit:
+                        post_preds = defence(post_preds)
+                elif defence.apply_predict:
+                    post_preds = defence(post_preds)
+
+        return post_preds
+
+    def compute_loss(self, x: np.ndarray, y: Any, **kwargs) -> np.ndarray:
+        """
+        Compute the loss of the estimator for samples `x`.
+
+        Parameters
+        ----------
+        x : array-like
+            Input samples.
+        y : array-like
+            Target values.
+
+        Returns
+        -------
+        array-like
+            Loss values.
+        """
+        raise NotImplementedError
+
+    def compute_loss_from_predictions(self, pred: np.ndarray, y: np.ndarray, **kwargs) -> np.ndarray:
+        """
+        Compute the loss of the estimator for predictions `pred`.
+
+        Parameters
+        ----------
+        pred : array-like
+            Model predictions.
+        y : array-like
+            Target values.
+
+        Returns
+        -------
+        array-like
+            Loss values.
+        """
+        raise NotImplementedError
+
+    def __repr__(self):
+        class_name = self.__class__.__name__
+        attributes = {}
+        for k, value in self.__dict__.items():
+            k = k[1:] if k[0] == "_" else k  # noqa: PLW2901
+            attributes[k] = value
+        attributes = [f"{k}={v}" for k, v in attributes.items()]
+        repr_string = class_name + "(" + ", ".join(attributes) + ")"
+        return repr_string
+
+
+class LossGradientsMixin(ABC):
+    """
+    Mixin abstract base class defining additional functionality for estimators providing loss gradients. An estimator
+    of this type can be combined with white-box attacks. This mixin abstract base class has to be mixed in with
+    class `BaseEstimator`.
+    """
+
+    @abstractmethod
+    def loss_gradient(self, x, y, **kwargs):
+        """
+        Compute the gradient of the loss function w.r.t. `x`.
+
+        Parameters
+        ----------
+        x : array-like
+            Input samples.
+        y : array-like
+            Target values.
+
+        Returns
+        -------
+        array-like
+            Loss gradients w.r.t. `x`.
+        """
+        raise NotImplementedError
+
+    def _apply_preprocessing_gradient(self, x, gradients, fit=False):
+        """
+        Apply the backward pass to the gradients through all normalization and preprocessing defences that have been
+        applied to `x` and `y` in the forward pass. This function has to be applied to all gradients w.r.t. `x`
+        calculated by the estimator.
+
+        Parameters
+        ----------
+        x : array-like
+            Input samples.
+        gradients : array-like
+            Gradients w.r.t. `x`.
+        fit : bool
+            `True` if the defences are applied during training.
+
+        Returns
+        -------
+        array-like
+            Gradients after backward pass through normalization and preprocessing defences.
+        """
+        if self.preprocessing_operations:
+            for preprocess in self.preprocessing_operations[::-1]:
+                if fit:
+                    if preprocess.apply_fit:
+                        gradients = preprocess.estimate_gradient(x, gradients)
+                elif preprocess.apply_predict:
+                    gradients = preprocess.estimate_gradient(x, gradients)
+
+        return gradients
+
+
+class DecisionTreeMixin(ABC):
+    """
+    Mixin abstract base class defining additional functionality for decision-tree-based estimators. This mixin abstract
+    base class has to be mixed in with class `BaseEstimator`.
+    """
+
+    @abstractmethod
+    def get_trees(self):
+        """
+        Get the decision trees.
+
+        Returns
+        -------
+        list
+            A list of decision trees.
+        """
+        raise NotImplementedError
diff --git a/src/holisticai/security/attackers/attribute_inference/wrappers/regression/__init__.py b/src/holisticai/security/attackers/attribute_inference/wrappers/regression/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/src/holisticai/security/attackers/attribute_inference/wrappers/regression/regressor.py b/src/holisticai/security/attackers/attribute_inference/wrappers/regression/regressor.py
new file mode 100644
index 00000000..e665e730
--- /dev/null
+++ b/src/holisticai/security/attackers/attribute_inference/wrappers/regression/regressor.py
@@ -0,0 +1,28 @@
+# MIT License
+#
+# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2020
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+"""
+This module implements mixin abstract base class for all regressors in ART.
+"""
+
+from abc import ABC
+
+
+class RegressorMixin(ABC):  # noqa: B024
+    """
+    Mixin abstract Base class for ART regressors.
+    """
diff --git a/src/holisticai/security/attackers/attribute_inference/wrappers/regression/scikitlearn.py b/src/holisticai/security/attackers/attribute_inference/wrappers/regression/scikitlearn.py
new file mode 100644
index 00000000..b983069c
--- /dev/null
+++ b/src/holisticai/security/attackers/attribute_inference/wrappers/regression/scikitlearn.py
@@ -0,0 +1,417 @@
+# MIT License
+#
+# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2021
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+"""
+This module implements the regressors for scikit-learn models.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import pickle
+from copy import deepcopy
+from typing import Optional
+
+import numpy as np
+from holisticai.security.attackers.attribute_inference.mitigation import config
+from holisticai.security.attackers.attribute_inference.wrappers.regression.regressor import RegressorMixin
+from holisticai.security.attackers.attribute_inference.wrappers.scikitlearn import ScikitlearnEstimator
+
+logger = logging.getLogger(__name__)
+
+
+class ScikitlearnRegressor(RegressorMixin, ScikitlearnEstimator):  # lgtm [py/missing-call-to-init]
+    """
+    Wrapper class for scikit-learn regression models.
+
+    This class supports all regression models from scikit-learn.
+
+    Parameters
+    ----------
+    model : object
+        scikit-learn regression model.
+    clip_values : tuple(float, float)
+        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
+    preprocessing_defences : `Preprocessor` or `List[Preprocessor]`
+        Preprocessing defence(s) to be applied by the classifier.
+    postprocessing_defences : `Postprocessor` or `List[Postprocessor]`
+        Postprocessing defence(s) to be applied by the classifier.
+    preprocessing : `tuple(float, float)` or `np.ndarray`
+        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data preprocessing.
+        The first value will be subtracted from the input. The input will then be divided by the second one.
+    """
+
+    estimator_params = ScikitlearnEstimator.estimator_params
+
+    def __init__(
+        self,
+        model,
+        clip_values=None,
+        preprocessing_defences=None,
+        postprocessing_defences=None,
+        preprocessing=(0.0, 1.0),
+    ) -> None:
+        super().__init__(
+            model=model,
+            clip_values=clip_values,
+            preprocessing_defences=preprocessing_defences,
+            postprocessing_defences=postprocessing_defences,
+            preprocessing=preprocessing,
+        )
+        self._input_shape = self._get_input_shape(model)
+
+    @property
+    def input_shape(self) -> tuple[int, ...]:
+        """
+        Return the shape of one input sample.
+
+        Returns
+        -------
+        np.ndarray
+            Shape of one input sample.
+        """
+        return self._input_shape  # type: ignore
+
+    def fit(self, x: np.ndarray, y: np.ndarray, **kwargs) -> None:
+        """
+        Fit the regressor on the training set `(x, y)`.
+
+        Parameters
+        ----------
+        x : `np.ndarray`
+            Training data.
+        y : `np.ndarray`
+            Target values.
+        kwargs : `dict`
+            Dictionary of framework-specific arguments. These should be parameters supported by the `fit` function in
+            `sklearn` regressor and will be passed to this function as such.
+        """
+        # Apply preprocessing
+        x_preprocessed, y_preprocessed = self._apply_preprocessing(x, y, fit=True)
+
+        self.model.fit(x_preprocessed, y_preprocessed, **kwargs)
+        self._input_shape = self._get_input_shape(self.model)
+
+    def predict(self, x: np.ndarray, **kwargs) -> np.ndarray:  # noqa: ARG002
+        """
+        Perform prediction for a batch of inputs.
+
+        Parameters
+        ----------
+        x : `np.ndarray`
+            Input samples.
+        kwargs : `dict`
+            Dictionary of framework-specific arguments. These should be parameters supported by the `predict` function in
+            `sklearn` regressor and will be passed to this function as such.
+
+        Returns
+        -------
+        `np.ndarray`
+            Array of predictions.
+        """
+        # Apply defences
+        x_preprocessed, _ = self._apply_preprocessing(x, y=None, fit=False)
+
+        if callable(getattr(self.model, "predict", None)):
+            y_pred = self.model.predict(x_preprocessed)
+        else:
+            raise TypeError("The provided model does not have the method `predict`.")
+
+        # Apply postprocessing
+        predictions = self._apply_postprocessing(preds=y_pred, fit=False)
+
+        return predictions
+
+    def save(self, filename: str, path: Optional[str] = None) -> None:
+        """
+        Save a model to file in the format specific to the backend framework.
+
+        Parameters
+        ----------
+        filename : str
+            Name of the file where to store the model.
+        path : str, optional
+            Path of the folder where to store the model. If no path is specified, the model will be stored in the default
+            data location of the library `ART_DATA_PATH`.
+        """
+        full_path = os.path.join(config.ART_DATA_PATH, filename) if path is None else os.path.join(path, filename)
+        folder = os.path.split(full_path)[0]
+        if not os.path.exists(folder):
+            os.makedirs(folder)
+
+        with open(full_path + ".pickle", "wb") as file_pickle:
+            pickle.dump(self.model, file=file_pickle)
+
+    def clone_for_refitting(self):  # lgtm [py/inheritance/incorrect-overridden-signature]
+        """
+        Create a copy of the classifier that can be refit from scratch.
+
+        Returns
+        -------
+        `Regressor`
+            New estimator.
+        """
+        import sklearn  # lgtm [py/repeated-import]
+
+        clone = type(self)(sklearn.base.clone(self.model))
+        params = self.get_params()
+        del params["model"]
+        clone.set_params(**params)
+        return clone
+
+    def reset(self) -> None:
+        """
+        Resets the weights of the classifier so that it can be refit from scratch.
+
+        """
+        # No need to do anything since scikitlearn models start from scratch each time fit() is called
+
+    def compute_loss(self, x: np.ndarray, y: np.ndarray, **kwargs) -> np.ndarray:  # noqa: ARG002
+        """
+        Compute the MSE loss of the regressor for samples `x`.
+
+        Parameters
+        ----------
+        x : `np.ndarray`
+            Input samples.
+        y : `np.ndarray`
+            Target values.
+
+        Returns
+        -------
+        `np.ndarray`
+            Loss values.
+        """
+
+        return (y - self.predict(x)) ** 2
+
+    def compute_loss_from_predictions(self, pred: np.ndarray, y: np.ndarray, **kwargs) -> np.ndarray:  # noqa: ARG002
+        """
+        Compute the MSE loss of the regressor for predictions `pred`.
+
+        Parameters
+        ----------
+        pred : `np.ndarray`
+            Model predictions.
+        y : `np.ndarray`
+            Target values.
+
+        Returns
+        -------
+        `np.ndarray`
+            Loss values.
+        """
+
+        return (y - pred) ** 2
+
+
+class ScikitlearnDecisionTreeRegressor(ScikitlearnRegressor):
+    """
+    Wrapper class for scikit-learn Decision Tree Regressor models.
+
+    This class supports all Decision Tree Regressor models from scikit-learn.
+
+    Parameters
+    ----------
+    model : object
+        scikit-learn Decision Tree Regressor model.
+    clip_values : tuple(float, float)
+        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
+    preprocessing_defences : `Preprocessor` or `List[Preprocessor]`
+        Preprocessing defence(s) to be applied by the classifier.
+    postprocessing_defences : `Postprocessor` or `List[Postprocessor]`
+        Postprocessing defence(s) to be applied by the classifier.
+    preprocessing : `tuple(float, float)` or `np.ndarray`
+        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data preprocessing.
+        The first value will be subtracted from the input. The input will then be divided by the second one.
+    """
+
+    def __init__(
+        self,
+        model,
+        clip_values=None,
+        preprocessing_defences=None,
+        postprocessing_defences=None,
+        preprocessing=(0.0, 1.0),
+    ) -> None:
+        super().__init__(
+            model=model,
+            clip_values=clip_values,
+            preprocessing_defences=preprocessing_defences,
+            postprocessing_defences=postprocessing_defences,
+            preprocessing=preprocessing,
+        )
+        self._model = model
+
+    def get_values_at_node(self, node_id: int) -> np.ndarray:
+        """
+        Returns the feature of given id for a node.
+
+        Parameters
+        ----------
+        node_id : int
+            Node id.
+
+        Returns
+        -------
+        np.ndarray
+            Normalized values at node node_id.
+        """
+        return self.model.tree_.value[node_id]
+
+    def get_left_child(self, node_id: int) -> int:
+        """
+        Returns the id of the left child node of node_id.
+
+        Parameters
+        ----------
+        node_id : int
+            Node id.
+
+        Returns
+        -------
+        int
+            The indices of the left child in the tree.
+        """
+        return self.model.tree_.children_left[node_id]
+
+    def get_right_child(self, node_id: int) -> int:
+        """
+        Returns the id of the right child node of node_id.
+
+        Parameters
+        ----------
+        node_id : int
+            Node id.
+
+        Returns
+        -------
+        int
+            The indices of the right child in the tree.
+        """
+        return self.model.tree_.children_right[node_id]
+
+    def get_decision_path(self, x: np.ndarray) -> np.ndarray:
+        """
+        Returns the path through nodes in the tree when classifying x. Last one is leaf, first one root node.
+
+        Parameters
+        ----------
+        x : `np.ndarray`
+            Input sample.
+
+        Returns
+        -------
+        np.ndarray
+            The indices of the nodes in the array structure of the tree.
+        """
+        if len(np.shape(x)) == 1:
+            return self.model.decision_path(x.reshape(1, -1)).indices
+
+        return self.model.decision_path(x).indices
+
+    def get_threshold_at_node(self, node_id: int) -> float:
+        """
+        Returns the threshold of given id for a node.
+
+        Parameters
+        ----------
+        node_id : int
+            Node id.
+
+        Returns
+        -------
+        float
+            Threshold value of feature split in this node.
+        """
+        return self.model.tree_.threshold[node_id]
+
+    def get_feature_at_node(self, node_id: int) -> int:
+        """
+        Returns the feature of given id for a node.
+
+        Parameters
+        ----------
+        node_id : int
+            Node id.
+
+        Returns
+        -------
+        int
+            Feature index of feature split in this node.
+        """
+        return self.model.tree_.feature[node_id]
+
+    def get_samples_at_node(self, node_id: int) -> int:
+        """
+        Returns the number of training samples mapped to a node.
+
+        Parameters
+        ----------
+        node_id : int
+            Node id.
+
+        Returns
+        -------
+        int
+            Number of samples mapped this node.
+        """
+        return self.model.tree_.n_node_samples[node_id]
+
+    def _get_leaf_nodes(self, node_id, i_tree, class_label, box):
+        from holisticai.security.attackers.attribute_inference.mitigation.verification_decisions_trees import (
+            Box,
+            Interval,
+            LeafNode,
+        )
+
+        leaf_nodes: list[LeafNode] = []
+
+        if self.get_left_child(node_id) != self.get_right_child(node_id):
+            node_left = self.get_left_child(node_id)
+            node_right = self.get_right_child(node_id)
+
+            box_left = deepcopy(box)
+            box_right = deepcopy(box)
+
+            feature = self.get_feature_at_node(node_id)
+            box_split_left = Box(intervals={feature: Interval(-np.inf, self.get_threshold_at_node(node_id))})
+            box_split_right = Box(intervals={feature: Interval(self.get_threshold_at_node(node_id), np.inf)})
+
+            if box.intervals:
+                box_left.intersect_with_box(box_split_left)
+                box_right.intersect_with_box(box_split_right)
+            else:
+                box_left = box_split_left
+                box_right = box_split_right
+
+            leaf_nodes += self._get_leaf_nodes(node_left, i_tree, class_label, box_left)
+            leaf_nodes += self._get_leaf_nodes(node_right, i_tree, class_label, box_right)
+
+        else:
+            leaf_nodes.append(
+                LeafNode(
+                    tree_id=i_tree,
+                    class_label=class_label,
+                    node_id=node_id,
+                    box=box,
+                    value=self.get_values_at_node(node_id)[0, 0],
+                )
+            )
+
+        return leaf_nodes
diff --git a/src/holisticai/security/attackers/attribute_inference/wrappers/scikitlearn.py b/src/holisticai/security/attackers/attribute_inference/wrappers/scikitlearn.py
new file mode 100644
index 00000000..dfa328ec
--- /dev/null
+++ b/src/holisticai/security/attackers/attribute_inference/wrappers/scikitlearn.py
@@ -0,0 +1,54 @@
+# MIT License
+#
+# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2020
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+# persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
+# Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+"""
+This module implements the abstract estimator for scikit-learn models.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+from holisticai.security.attackers.attribute_inference.wrappers.estimator import BaseEstimator
+
+logger = logging.getLogger(__name__)
+
+
+class ScikitlearnEstimator(BaseEstimator):
+    """
+    Estimator class for scikit-learn models.
+    """
+
+    def _get_input_shape(self, model) -> Optional[tuple[int, ...]]:
+        _input_shape: Optional[tuple[int, ...]]
+        if hasattr(model, "n_features_"):
+            _input_shape = (model.n_features_,)
+        elif hasattr(model, "n_features_in_"):
+            _input_shape = (model.n_features_in_,)
+        elif hasattr(model, "feature_importances_"):
+            _input_shape = (len(model.feature_importances_),)
+        elif hasattr(model, "coef_"):
+            _input_shape = (model.coef_.shape[0],) if len(model.coef_.shape) == 1 else (model.coef_.shape[1],)
+        elif hasattr(model, "support_vectors_"):
+            _input_shape = (model.support_vectors_.shape[1],)
+        elif hasattr(model, "steps"):
+            _input_shape = self._get_input_shape(model.steps[-1][1].obj)
+        else:
+            logger.warning("Input shape not recognised. The model might not have been fitted.")
+            _input_shape = None
+        return _input_shape

From 484dc9fccd1c391eedbd5a69ef0964fd317c9d6e Mon Sep 17 00:00:00 2001
From: franklincf <fracarfer5@gmail.com>
Date: Wed, 18 Dec 2024 12:06:55 -0300
Subject: [PATCH 09/34] chore: adding tutorials for classification tasks in
 inference attribute attacks

---
 .../classification/baseline.ipynb             | 712 ++++++++++++++++++
 .../classification/black_box.ipynb            | 403 ++++++++++
 .../classification/true_label.ipynb           | 625 +++++++++++++++
 .../classification/white_box.ipynb            | 423 +++++++++++
 .../classification/white_box_lifestyle.ipynb  | 423 +++++++++++
 5 files changed, 2586 insertions(+)
 create mode 100644 tutorials/security/attribute_inference_attacks/classification/baseline.ipynb
 create mode 100644 tutorials/security/attribute_inference_attacks/classification/black_box.ipynb
 create mode 100644 tutorials/security/attribute_inference_attacks/classification/true_label.ipynb
 create mode 100644 tutorials/security/attribute_inference_attacks/classification/white_box.ipynb
 create mode 100644 tutorials/security/attribute_inference_attacks/classification/white_box_lifestyle.ipynb

diff --git a/tutorials/security/attribute_inference_attacks/classification/baseline.ipynb b/tutorials/security/attribute_inference_attacks/classification/baseline.ipynb
new file mode 100644
index 00000000..efa06e16
--- /dev/null
+++ b/tutorials/security/attribute_inference_attacks/classification/baseline.ipynb
@@ -0,0 +1,712 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from holisticai.datasets import load_dataset\n",
+    "from holisticai.security.attackers.attribute_inference.baseline import AttributeInferenceBaseline\n",
+    "\n",
+    "np.random.seed(100)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "    <style>\n",
+       "        @import url('https://fonts.googleapis.com/css2?family=Montserrat:ital,wght@0,100..900;1,100..900&display=swap');\n",
+       "\n",
+       "/* Light blue theme (default) */\n",
+       ".generic-object-container.blue {\n",
+       "    background-color: rgba(242, 248, 253, 0.9) !important; /* Light blue with 70% opacity */\n",
+       "    border-color: #4db6ac !important; /* Soft blue border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.blue {\n",
+       "    background-color: rgba(152, 171, 202, 0.4) !important; /* Darker blue with 60% opacity */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.blue:hover {\n",
+       "    background-color: rgba(139, 177, 192, 0.8) !important; /* Darker blue on hover with 60% opacity */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.blue:hover {\n",
+       "    background-color: rgba(178, 223, 219, 0.8) !important; /* Attribute hover background with 60% opacity */\n",
+       "}\n",
+       "\n",
+       "/* Orange theme */\n",
+       ".generic-object-container.orange {\n",
+       "    background-color: #fff9ef !important; /* Container background: light orange */\n",
+       "    border-color: #ffb74d !important; /* Soft orange border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.orange {\n",
+       "    background-color: #ffe0b2 !important; /* Header background: darker orange */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.orange:hover {\n",
+       "    background-color: #ffcc80 !important; /* Darker shade on hover over the header */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.orange:hover {\n",
+       "    background-color: #ffe0b2 !important; /* Attribute background on hover: darker orange */\n",
+       "}\n",
+       "\n",
+       "/* Green theme */\n",
+       ".generic-object-container.green {\n",
+       "    background-color: #f6fff6 !important; /* Container background: light green */\n",
+       "    border-color: #81c784 !important; /* Soft green border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.green {\n",
+       "    background-color: #c8e6c9 !important; /* Header background: darker green */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.green:hover {\n",
+       "    background-color: #a5d6a7 !important; /* Darker shade on hover over the header */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.green:hover {\n",
+       "    background-color: #c8e6c9 !important; /* Attribute background on hover: darker green */\n",
+       "}\n",
+       "\n",
+       "/* Align the first container to the left */\n",
+       ".generic-object-container.first-level {\n",
+       "    margin: 0;\n",
+       "    width: auto;\n",
+       "    max-width: 800px;\n",
+       "    display: block;\n",
+       "    box-sizing: border-box;\n",
+       "}\n",
+       "\n",
+       "/* Nested containers stay centered */\n",
+       ".generic-object-container .generic-object-container {\n",
+       "    margin: 5px auto;\n",
+       "    width: 100%;\n",
+       "    display: block;\n",
+       "    padding: 5px 0;\n",
+       "}\n",
+       "\n",
+       "/* Remove default background color so only themes apply it */\n",
+       ".generic-object-container {\n",
+       "    padding: 0;\n",
+       "    margin: 0 auto;\n",
+       "    border: 0px dashed;\n",
+       "    border-radius: 5px;\n",
+       "    display: block;\n",
+       "    width: auto;\n",
+       "    max-width: 800px;\n",
+       "    box-sizing: border-box;\n",
+       "    margin-bottom: 15px;\n",
+       "    transition: transform 0.2s, box-shadow 0.2s;\n",
+       "    box-shadow: 0px 2px 5px rgba(77, 182, 172, 0.3);\n",
+       "}\n",
+       "\n",
+       ".generic-object-container:hover {\n",
+       "    box-shadow: 0px 8px 20px rgba(77, 182, 172, 0.3);\n",
+       "}\n",
+       "\n",
+       ".generic-object-header {\n",
+       "    font-family: 'Montserrat', Arial, sans-serif;\n",
+       "    font-size: 14px;\n",
+       "    padding: 10px 20px;\n",
+       "    padding-left: 40px;\n",
+       "    text-align: center;\n",
+       "    font-weight: bold;\n",
+       "    cursor: pointer;\n",
+       "    display: flex;\n",
+       "    align-items: center;\n",
+       "    justify-content: center;\n",
+       "    position: relative;\n",
+       "    width: 100%;\n",
+       "    box-sizing: border-box;\n",
+       "    border-radius: 5px;\n",
+       "    transition: background-color 0.3s;\n",
+       "}\n",
+       "\n",
+       ".toggle-button {\n",
+       "    margin-right: 10px;\n",
+       "    background: none;\n",
+       "    border: none;\n",
+       "    font-size: 13px;\n",
+       "    cursor: pointer;\n",
+       "    position: absolute;\n",
+       "    left: 10px;\n",
+       "    color: #004d40;\n",
+       "}\n",
+       "\n",
+       ".generic-object-body {\n",
+       "    padding: 5px 10px;\n",
+       "    display: block;\n",
+       "    border-radius: 0 0 5px 5px;\n",
+       "    background-color: inherit;\n",
+       "    margin: 0 auto;\n",
+       "}\n",
+       "\n",
+       ".hidden {\n",
+       "    display: none;\n",
+       "}\n",
+       "\n",
+       ".attribute-list {\n",
+       "    margin: 2px 0;\n",
+       "    padding: 2px;\n",
+       "    transition: background-color 0.2s;\n",
+       "    display: block;\n",
+       "}\n",
+       "\n",
+       ".flex-space-filler {\n",
+       "    display: flex;\n",
+       "    justify-content: center;\n",
+       "    align-items: center;\n",
+       "}\n",
+       "\n",
+       ".generic-object-container,\n",
+       ".generic-object-header,\n",
+       ".attribute-list {\n",
+       "    color: #000000 !important; /* Establece el color del texto a negro */\n",
+       "}\n",
+       "    </style>\n",
+       "    <div style=\"display: flex;\">\n",
+       "    <div class=\"generic-object-container blue first-level\">\n",
+       "        <div class=\"generic-object-content\">\n",
+       "            <div class=\"generic-object-header blue\" onclick=\"toggleCollapse(this)\">\n",
+       "                <button class=\"toggle-button blue\">[-]</button> [Dataset]\n",
+       "            </div>\n",
+       "            <div class=\"generic-object-body\">\n",
+       "                <div class=\"attribute-list blue\"><strong>Instances</strong>: 800</div><div class=\"attribute-list blue\"><strong>Features</strong>: X , y , p_attrs</div>\n",
+       "                \n",
+       "            </div>\n",
+       "        </div>\n",
+       "    </div>\n",
+       "</div>\n",
+       "    <script>\n",
+       "    function toggleCollapse(element) {\n",
+       "        var body = element.nextElementSibling;\n",
+       "        var button = element.querySelector(\".toggle-button\");\n",
+       "        if (body.classList.contains('hidden')) {\n",
+       "            body.classList.remove('hidden');\n",
+       "            button.textContent = \"[-]\";\n",
+       "        } else {\n",
+       "            body.classList.add('hidden');\n",
+       "            button.textContent = \"[+]\";\n",
+       "        }\n",
+       "    }\n",
+       "    </script>\n",
+       "    "
+      ],
+      "text/plain": [
+       "{\"dtype\":\"Dataset\",\"attributes\":{\"Instances\":800,\"Features\":[\"X , y , p_attrs\"]},\"metadata\":null}"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dataset = load_dataset('german_credit', preprocessed=True)\n",
+    "train_test = dataset.train_test_split(test_size=0.2, stratify=dataset['y'], random_state=0)\n",
+    "train = train_test['train']\n",
+    "test = train_test['test']\n",
+    "train"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Job</th>\n",
+       "      <th>Credit amount</th>\n",
+       "      <th>Duration</th>\n",
+       "      <th>Housing_free</th>\n",
+       "      <th>Housing_own</th>\n",
+       "      <th>Housing_rent</th>\n",
+       "      <th>Saving accounts_quite rich</th>\n",
+       "      <th>Saving accounts_little</th>\n",
+       "      <th>Saving accounts_moderate</th>\n",
+       "      <th>Saving accounts_rich</th>\n",
+       "      <th>...</th>\n",
+       "      <th>Checking account_moderate</th>\n",
+       "      <th>Checking account_rich</th>\n",
+       "      <th>Purpose_'domestic appliances'</th>\n",
+       "      <th>Purpose_business</th>\n",
+       "      <th>Purpose_car</th>\n",
+       "      <th>Purpose_education</th>\n",
+       "      <th>Purpose_furniture/equipment</th>\n",
+       "      <th>Purpose_radio/TV</th>\n",
+       "      <th>Purpose_repairs</th>\n",
+       "      <th>Purpose_vacation/others</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>2</td>\n",
+       "      <td>2181</td>\n",
+       "      <td>30</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2</td>\n",
+       "      <td>6148</td>\n",
+       "      <td>20</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>2</td>\n",
+       "      <td>2058</td>\n",
+       "      <td>24</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>2</td>\n",
+       "      <td>2613</td>\n",
+       "      <td>36</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>1</td>\n",
+       "      <td>731</td>\n",
+       "      <td>8</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>5 rows × 21 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   Job  Credit amount  Duration  Housing_free  Housing_own  Housing_rent  \\\n",
+       "0    2           2181        30           0.0          1.0           0.0   \n",
+       "1    2           6148        20           0.0          1.0           0.0   \n",
+       "2    2           2058        24           0.0          1.0           0.0   \n",
+       "3    2           2613        36           0.0          1.0           0.0   \n",
+       "4    1            731         8           0.0          1.0           0.0   \n",
+       "\n",
+       "   Saving accounts_quite rich  Saving accounts_little  \\\n",
+       "0                         0.0                     1.0   \n",
+       "1                         0.0                     0.0   \n",
+       "2                         0.0                     1.0   \n",
+       "3                         0.0                     1.0   \n",
+       "4                         0.0                     1.0   \n",
+       "\n",
+       "   Saving accounts_moderate  Saving accounts_rich  ...  \\\n",
+       "0                       0.0                   0.0  ...   \n",
+       "1                       1.0                   0.0  ...   \n",
+       "2                       0.0                   0.0  ...   \n",
+       "3                       0.0                   0.0  ...   \n",
+       "4                       0.0                   0.0  ...   \n",
+       "\n",
+       "   Checking account_moderate  Checking account_rich  \\\n",
+       "0                        1.0                    0.0   \n",
+       "1                        1.0                    0.0   \n",
+       "2                        0.0                    0.0   \n",
+       "3                        0.0                    0.0   \n",
+       "4                        0.0                    0.0   \n",
+       "\n",
+       "   Purpose_'domestic appliances'  Purpose_business  Purpose_car  \\\n",
+       "0                            0.0               0.0          1.0   \n",
+       "1                            0.0               0.0          1.0   \n",
+       "2                            0.0               0.0          0.0   \n",
+       "3                            0.0               0.0          0.0   \n",
+       "4                            0.0               0.0          1.0   \n",
+       "\n",
+       "   Purpose_education  Purpose_furniture/equipment  Purpose_radio/TV  \\\n",
+       "0                0.0                          0.0               0.0   \n",
+       "1                0.0                          0.0               0.0   \n",
+       "2                0.0                          0.0               0.0   \n",
+       "3                0.0                          0.0               0.0   \n",
+       "4                0.0                          0.0               0.0   \n",
+       "\n",
+       "   Purpose_repairs  Purpose_vacation/others  \n",
+       "0              0.0                      0.0  \n",
+       "1              0.0                      0.0  \n",
+       "2              1.0                      0.0  \n",
+       "3              1.0                      0.0  \n",
+       "4              0.0                      0.0  \n",
+       "\n",
+       "[5 rows x 21 columns]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "train['X'].head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "job_feat_train = train['X']['Job'].values\n",
+    "job_feat_train[job_feat_train < 2] = 0\n",
+    "job_feat_train[job_feat_train >= 2] = 1\n",
+    "\n",
+    "job_feat_test = test['X']['Job'].values\n",
+    "job_feat_test[job_feat_test < 2] = 0\n",
+    "job_feat_test[job_feat_test >= 2] = 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_train = train['X'].drop(columns=['Credit amount', 'Duration']).values\n",
+    "x_test = test['X'].drop(columns=['Credit amount', 'Duration']).values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_train[:, 0] = job_feat_train\n",
+    "x_test[:, 0] = job_feat_test"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "attack_feature = 0 # job feature\n",
+    "\n",
+    "attack = AttributeInferenceBaseline(attack_feature=attack_feature)\n",
+    "\n",
+    "attack.fit(x_train)\n",
+    "\n",
+    "attack_x_test = np.delete(x_test, attack_feature, axis=1)\n",
+    "feat_true = x_test[:, attack_feature]\n",
+    "\n",
+    "values = [0, 1]\n",
+    "feat_pred = attack.infer(attack_x_test, values=values)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Value</th>\n",
+       "      <th>Reference</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Metric</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Accuracy</th>\n",
+       "      <td>0.750000</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Balanced Accuracy</th>\n",
+       "      <td>0.502259</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Precision</th>\n",
+       "      <td>0.770833</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Recall</th>\n",
+       "      <td>0.961039</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>F1-Score</th>\n",
+       "      <td>0.855491</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                      Value  Reference\n",
+       "Metric                                \n",
+       "Accuracy           0.750000          1\n",
+       "Balanced Accuracy  0.502259          1\n",
+       "Precision          0.770833          1\n",
+       "Recall             0.961039          1\n",
+       "F1-Score           0.855491          1"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from holisticai.efficacy.metrics import classification_efficacy_metrics\n",
+    "\n",
+    "classification_efficacy_metrics(feat_true, feat_pred)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Value</th>\n",
+       "      <th>Reference</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Metric</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Accuracy</th>\n",
+       "      <td>0.802500</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Balanced Accuracy</th>\n",
+       "      <td>0.563374</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Precision</th>\n",
+       "      <td>0.802597</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Recall</th>\n",
+       "      <td>0.990385</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>F1-Score</th>\n",
+       "      <td>0.886657</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                      Value  Reference\n",
+       "Metric                                \n",
+       "Accuracy           0.802500          1\n",
+       "Balanced Accuracy  0.563374          1\n",
+       "Precision          0.802597          1\n",
+       "Recall             0.990385          1\n",
+       "F1-Score           0.886657          1"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "attack_x_train = np.delete(x_train, attack_feature, axis=1)\n",
+    "feat_true = x_train[:, attack_feature]\n",
+    "\n",
+    "values = [0, 1]\n",
+    "feat_pred = attack.infer(attack_x_train, values=values)\n",
+    "\n",
+    "classification_efficacy_metrics(feat_true, feat_pred)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "testing",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/tutorials/security/attribute_inference_attacks/classification/black_box.ipynb b/tutorials/security/attribute_inference_attacks/classification/black_box.ipynb
new file mode 100644
index 00000000..826bb8d8
--- /dev/null
+++ b/tutorials/security/attribute_inference_attacks/classification/black_box.ipynb
@@ -0,0 +1,403 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from holisticai.security.attackers.attribute_inference.dataset_utils import AttackDataset\n",
+    "from holisticai.security.attackers.attribute_inference.wrappers.classification.scikitlearn import SklearnClassifier\n",
+    "from holisticai.datasets import load_dataset\n",
+    "from holisticai.security.attackers.attribute_inference.black_box import AttributeInferenceBlackBox"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "    <style>\n",
+       "        @import url('https://fonts.googleapis.com/css2?family=Montserrat:ital,wght@0,100..900;1,100..900&display=swap');\n",
+       "\n",
+       "/* Light blue theme (default) */\n",
+       ".generic-object-container.blue {\n",
+       "    background-color: rgba(242, 248, 253, 0.9) !important; /* Light blue with 70% opacity */\n",
+       "    border-color: #4db6ac !important; /* Soft blue border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.blue {\n",
+       "    background-color: rgba(152, 171, 202, 0.4) !important; /* Darker blue with 60% opacity */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.blue:hover {\n",
+       "    background-color: rgba(139, 177, 192, 0.8) !important; /* Darker blue on hover with 60% opacity */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.blue:hover {\n",
+       "    background-color: rgba(178, 223, 219, 0.8) !important; /* Attribute hover background with 60% opacity */\n",
+       "}\n",
+       "\n",
+       "/* Orange theme */\n",
+       ".generic-object-container.orange {\n",
+       "    background-color: #fff9ef !important; /* Container background: light orange */\n",
+       "    border-color: #ffb74d !important; /* Soft orange border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.orange {\n",
+       "    background-color: #ffe0b2 !important; /* Header background: darker orange */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.orange:hover {\n",
+       "    background-color: #ffcc80 !important; /* Darker shade on hover over the header */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.orange:hover {\n",
+       "    background-color: #ffe0b2 !important; /* Attribute background on hover: darker orange */\n",
+       "}\n",
+       "\n",
+       "/* Green theme */\n",
+       ".generic-object-container.green {\n",
+       "    background-color: #f6fff6 !important; /* Container background: light green */\n",
+       "    border-color: #81c784 !important; /* Soft green border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.green {\n",
+       "    background-color: #c8e6c9 !important; /* Header background: darker green */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.green:hover {\n",
+       "    background-color: #a5d6a7 !important; /* Darker shade on hover over the header */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.green:hover {\n",
+       "    background-color: #c8e6c9 !important; /* Attribute background on hover: darker green */\n",
+       "}\n",
+       "\n",
+       "/* Align the first container to the left */\n",
+       ".generic-object-container.first-level {\n",
+       "    margin: 0;\n",
+       "    width: auto;\n",
+       "    max-width: 800px;\n",
+       "    display: block;\n",
+       "    box-sizing: border-box;\n",
+       "}\n",
+       "\n",
+       "/* Nested containers stay centered */\n",
+       ".generic-object-container .generic-object-container {\n",
+       "    margin: 5px auto;\n",
+       "    width: 100%;\n",
+       "    display: block;\n",
+       "    padding: 5px 0;\n",
+       "}\n",
+       "\n",
+       "/* Remove default background color so only themes apply it */\n",
+       ".generic-object-container {\n",
+       "    padding: 0;\n",
+       "    margin: 0 auto;\n",
+       "    border: 0px dashed;\n",
+       "    border-radius: 5px;\n",
+       "    display: block;\n",
+       "    width: auto;\n",
+       "    max-width: 800px;\n",
+       "    box-sizing: border-box;\n",
+       "    margin-bottom: 15px;\n",
+       "    transition: transform 0.2s, box-shadow 0.2s;\n",
+       "    box-shadow: 0px 2px 5px rgba(77, 182, 172, 0.3);\n",
+       "}\n",
+       "\n",
+       ".generic-object-container:hover {\n",
+       "    box-shadow: 0px 8px 20px rgba(77, 182, 172, 0.3);\n",
+       "}\n",
+       "\n",
+       ".generic-object-header {\n",
+       "    font-family: 'Montserrat', Arial, sans-serif;\n",
+       "    font-size: 14px;\n",
+       "    padding: 10px 20px;\n",
+       "    padding-left: 40px;\n",
+       "    text-align: center;\n",
+       "    font-weight: bold;\n",
+       "    cursor: pointer;\n",
+       "    display: flex;\n",
+       "    align-items: center;\n",
+       "    justify-content: center;\n",
+       "    position: relative;\n",
+       "    width: 100%;\n",
+       "    box-sizing: border-box;\n",
+       "    border-radius: 5px;\n",
+       "    transition: background-color 0.3s;\n",
+       "}\n",
+       "\n",
+       ".toggle-button {\n",
+       "    margin-right: 10px;\n",
+       "    background: none;\n",
+       "    border: none;\n",
+       "    font-size: 13px;\n",
+       "    cursor: pointer;\n",
+       "    position: absolute;\n",
+       "    left: 10px;\n",
+       "    color: #004d40;\n",
+       "}\n",
+       "\n",
+       ".generic-object-body {\n",
+       "    padding: 5px 10px;\n",
+       "    display: block;\n",
+       "    border-radius: 0 0 5px 5px;\n",
+       "    background-color: inherit;\n",
+       "    margin: 0 auto;\n",
+       "}\n",
+       "\n",
+       ".hidden {\n",
+       "    display: none;\n",
+       "}\n",
+       "\n",
+       ".attribute-list {\n",
+       "    margin: 2px 0;\n",
+       "    padding: 2px;\n",
+       "    transition: background-color 0.2s;\n",
+       "    display: block;\n",
+       "}\n",
+       "\n",
+       ".flex-space-filler {\n",
+       "    display: flex;\n",
+       "    justify-content: center;\n",
+       "    align-items: center;\n",
+       "}\n",
+       "\n",
+       ".generic-object-container,\n",
+       ".generic-object-header,\n",
+       ".attribute-list {\n",
+       "    color: #000000 !important; /* Establece el color del texto a negro */\n",
+       "}\n",
+       "    </style>\n",
+       "    <div style=\"display: flex;\">\n",
+       "    <div class=\"generic-object-container blue first-level\">\n",
+       "        <div class=\"generic-object-content\">\n",
+       "            <div class=\"generic-object-header blue\" onclick=\"toggleCollapse(this)\">\n",
+       "                <button class=\"toggle-button blue\">[-]</button> [Dataset]\n",
+       "            </div>\n",
+       "            <div class=\"generic-object-body\">\n",
+       "                <div class=\"attribute-list blue\"><strong>Instances</strong>: 800</div><div class=\"attribute-list blue\"><strong>Features</strong>: X , y , p_attrs</div>\n",
+       "                \n",
+       "            </div>\n",
+       "        </div>\n",
+       "    </div>\n",
+       "</div>\n",
+       "    <script>\n",
+       "    function toggleCollapse(element) {\n",
+       "        var body = element.nextElementSibling;\n",
+       "        var button = element.querySelector(\".toggle-button\");\n",
+       "        if (body.classList.contains('hidden')) {\n",
+       "            body.classList.remove('hidden');\n",
+       "            button.textContent = \"[-]\";\n",
+       "        } else {\n",
+       "            body.classList.add('hidden');\n",
+       "            button.textContent = \"[+]\";\n",
+       "        }\n",
+       "    }\n",
+       "    </script>\n",
+       "    "
+      ],
+      "text/plain": [
+       "{\"dtype\":\"Dataset\",\"attributes\":{\"Instances\":800,\"Features\":[\"X , y , p_attrs\"]},\"metadata\":null}"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dataset = load_dataset('german_credit', preprocessed=True)\n",
+    "train_test = dataset.train_test_split(test_size=0.2, stratify=dataset['y'], random_state=0)\n",
+    "train = train_test['train']\n",
+    "test = train_test['test']\n",
+    "train"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "job_feat_train = train['X']['Job'].values\n",
+    "job_feat_train[job_feat_train < 2] = 0\n",
+    "job_feat_train[job_feat_train >= 2] = 1\n",
+    "\n",
+    "job_feat_test = test['X']['Job'].values\n",
+    "job_feat_test[job_feat_test < 2] = 0\n",
+    "job_feat_test[job_feat_test >= 2] = 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_train = train['X'].drop(columns=['Credit amount', 'Duration']).values\n",
+    "x_test = test['X'].drop(columns=['Credit amount', 'Duration']).values\n",
+    "\n",
+    "y_train = train['y'].values\n",
+    "y_test = test['y'].values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "attack_feature = 0\n",
+    "x_train[:, attack_feature] = job_feat_train\n",
+    "x_test[:, attack_feature] = job_feat_test"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.tree import DecisionTreeClassifier\n",
+    "\n",
+    "classifier = DecisionTreeClassifier()\n",
+    "classifier.fit(x_train, y_train)\n",
+    "classifier = SklearnClassifier(classifier)\n",
+    "\n",
+    "attack = AttributeInferenceBlackBox(estimator=classifier, attack_feature=attack_feature)\n",
+    "\n",
+    "pred = classifier.predict_proba(x_train)\n",
+    "attack.fit(x_train, y_train, pred)\n",
+    "\n",
+    "attack_x_test = np.delete(x_test, attack_feature, axis=1)\n",
+    "pred = classifier.predict_proba(x_test)\n",
+    "\n",
+    "feat_true = x_test[:, attack_feature]\n",
+    "\n",
+    "values = [0, 1]\n",
+    "feat_pred = attack.infer(attack_x_test, y_test, pred, values=values)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Value</th>\n",
+       "      <th>Reference</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Metric</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Accuracy</th>\n",
+       "      <td>0.915000</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Balanced Accuracy</th>\n",
+       "      <td>0.845709</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Precision</th>\n",
+       "      <td>0.920245</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Recall</th>\n",
+       "      <td>0.974026</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>F1-Score</th>\n",
+       "      <td>0.946372</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                      Value  Reference\n",
+       "Metric                                \n",
+       "Accuracy           0.915000          1\n",
+       "Balanced Accuracy  0.845709          1\n",
+       "Precision          0.920245          1\n",
+       "Recall             0.974026          1\n",
+       "F1-Score           0.946372          1"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from holisticai.efficacy.metrics import classification_efficacy_metrics\n",
+    "\n",
+    "classification_efficacy_metrics(feat_true, feat_pred)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "testing",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/tutorials/security/attribute_inference_attacks/classification/true_label.ipynb b/tutorials/security/attribute_inference_attacks/classification/true_label.ipynb
new file mode 100644
index 00000000..c0b7f489
--- /dev/null
+++ b/tutorials/security/attribute_inference_attacks/classification/true_label.ipynb
@@ -0,0 +1,625 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from holisticai.datasets import load_dataset\n",
+    "from holisticai.security.attackers.attribute_inference.true_label_baseline import AttributeInferenceBaselineTrueLabel\n",
+    "\n",
+    "np.random.seed(100)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "    <style>\n",
+       "        @import url('https://fonts.googleapis.com/css2?family=Montserrat:ital,wght@0,100..900;1,100..900&display=swap');\n",
+       "\n",
+       "/* Light blue theme (default) */\n",
+       ".generic-object-container.blue {\n",
+       "    background-color: rgba(242, 248, 253, 0.9) !important; /* Light blue with 70% opacity */\n",
+       "    border-color: #4db6ac !important; /* Soft blue border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.blue {\n",
+       "    background-color: rgba(152, 171, 202, 0.4) !important; /* Darker blue with 60% opacity */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.blue:hover {\n",
+       "    background-color: rgba(139, 177, 192, 0.8) !important; /* Darker blue on hover with 60% opacity */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.blue:hover {\n",
+       "    background-color: rgba(178, 223, 219, 0.8) !important; /* Attribute hover background with 60% opacity */\n",
+       "}\n",
+       "\n",
+       "/* Orange theme */\n",
+       ".generic-object-container.orange {\n",
+       "    background-color: #fff9ef !important; /* Container background: light orange */\n",
+       "    border-color: #ffb74d !important; /* Soft orange border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.orange {\n",
+       "    background-color: #ffe0b2 !important; /* Header background: darker orange */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.orange:hover {\n",
+       "    background-color: #ffcc80 !important; /* Darker shade on hover over the header */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.orange:hover {\n",
+       "    background-color: #ffe0b2 !important; /* Attribute background on hover: darker orange */\n",
+       "}\n",
+       "\n",
+       "/* Green theme */\n",
+       ".generic-object-container.green {\n",
+       "    background-color: #f6fff6 !important; /* Container background: light green */\n",
+       "    border-color: #81c784 !important; /* Soft green border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.green {\n",
+       "    background-color: #c8e6c9 !important; /* Header background: darker green */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.green:hover {\n",
+       "    background-color: #a5d6a7 !important; /* Darker shade on hover over the header */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.green:hover {\n",
+       "    background-color: #c8e6c9 !important; /* Attribute background on hover: darker green */\n",
+       "}\n",
+       "\n",
+       "/* Align the first container to the left */\n",
+       ".generic-object-container.first-level {\n",
+       "    margin: 0;\n",
+       "    width: auto;\n",
+       "    max-width: 800px;\n",
+       "    display: block;\n",
+       "    box-sizing: border-box;\n",
+       "}\n",
+       "\n",
+       "/* Nested containers stay centered */\n",
+       ".generic-object-container .generic-object-container {\n",
+       "    margin: 5px auto;\n",
+       "    width: 100%;\n",
+       "    display: block;\n",
+       "    padding: 5px 0;\n",
+       "}\n",
+       "\n",
+       "/* Remove default background color so only themes apply it */\n",
+       ".generic-object-container {\n",
+       "    padding: 0;\n",
+       "    margin: 0 auto;\n",
+       "    border: 0px dashed;\n",
+       "    border-radius: 5px;\n",
+       "    display: block;\n",
+       "    width: auto;\n",
+       "    max-width: 800px;\n",
+       "    box-sizing: border-box;\n",
+       "    margin-bottom: 15px;\n",
+       "    transition: transform 0.2s, box-shadow 0.2s;\n",
+       "    box-shadow: 0px 2px 5px rgba(77, 182, 172, 0.3);\n",
+       "}\n",
+       "\n",
+       ".generic-object-container:hover {\n",
+       "    box-shadow: 0px 8px 20px rgba(77, 182, 172, 0.3);\n",
+       "}\n",
+       "\n",
+       ".generic-object-header {\n",
+       "    font-family: 'Montserrat', Arial, sans-serif;\n",
+       "    font-size: 14px;\n",
+       "    padding: 10px 20px;\n",
+       "    padding-left: 40px;\n",
+       "    text-align: center;\n",
+       "    font-weight: bold;\n",
+       "    cursor: pointer;\n",
+       "    display: flex;\n",
+       "    align-items: center;\n",
+       "    justify-content: center;\n",
+       "    position: relative;\n",
+       "    width: 100%;\n",
+       "    box-sizing: border-box;\n",
+       "    border-radius: 5px;\n",
+       "    transition: background-color 0.3s;\n",
+       "}\n",
+       "\n",
+       ".toggle-button {\n",
+       "    margin-right: 10px;\n",
+       "    background: none;\n",
+       "    border: none;\n",
+       "    font-size: 13px;\n",
+       "    cursor: pointer;\n",
+       "    position: absolute;\n",
+       "    left: 10px;\n",
+       "    color: #004d40;\n",
+       "}\n",
+       "\n",
+       ".generic-object-body {\n",
+       "    padding: 5px 10px;\n",
+       "    display: block;\n",
+       "    border-radius: 0 0 5px 5px;\n",
+       "    background-color: inherit;\n",
+       "    margin: 0 auto;\n",
+       "}\n",
+       "\n",
+       ".hidden {\n",
+       "    display: none;\n",
+       "}\n",
+       "\n",
+       ".attribute-list {\n",
+       "    margin: 2px 0;\n",
+       "    padding: 2px;\n",
+       "    transition: background-color 0.2s;\n",
+       "    display: block;\n",
+       "}\n",
+       "\n",
+       ".flex-space-filler {\n",
+       "    display: flex;\n",
+       "    justify-content: center;\n",
+       "    align-items: center;\n",
+       "}\n",
+       "\n",
+       ".generic-object-container,\n",
+       ".generic-object-header,\n",
+       ".attribute-list {\n",
+       "    color: #000000 !important; /* Establece el color del texto a negro */\n",
+       "}\n",
+       "    </style>\n",
+       "    <div style=\"display: flex;\">\n",
+       "    <div class=\"generic-object-container blue first-level\">\n",
+       "        <div class=\"generic-object-content\">\n",
+       "            <div class=\"generic-object-header blue\" onclick=\"toggleCollapse(this)\">\n",
+       "                <button class=\"toggle-button blue\">[-]</button> [Dataset]\n",
+       "            </div>\n",
+       "            <div class=\"generic-object-body\">\n",
+       "                <div class=\"attribute-list blue\"><strong>Instances</strong>: 800</div><div class=\"attribute-list blue\"><strong>Features</strong>: X , y , p_attrs</div>\n",
+       "                \n",
+       "            </div>\n",
+       "        </div>\n",
+       "    </div>\n",
+       "</div>\n",
+       "    <script>\n",
+       "    function toggleCollapse(element) {\n",
+       "        var body = element.nextElementSibling;\n",
+       "        var button = element.querySelector(\".toggle-button\");\n",
+       "        if (body.classList.contains('hidden')) {\n",
+       "            body.classList.remove('hidden');\n",
+       "            button.textContent = \"[-]\";\n",
+       "        } else {\n",
+       "            body.classList.add('hidden');\n",
+       "            button.textContent = \"[+]\";\n",
+       "        }\n",
+       "    }\n",
+       "    </script>\n",
+       "    "
+      ],
+      "text/plain": [
+       "{\"dtype\":\"Dataset\",\"attributes\":{\"Instances\":800,\"Features\":[\"X , y , p_attrs\"]},\"metadata\":null}"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dataset = load_dataset('german_credit', preprocessed=True)\n",
+    "train_test = dataset.train_test_split(test_size=0.2, stratify=dataset['y'], random_state=0)\n",
+    "train = train_test['train']\n",
+    "test = train_test['test']\n",
+    "train"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Job</th>\n",
+       "      <th>Credit amount</th>\n",
+       "      <th>Duration</th>\n",
+       "      <th>Housing_free</th>\n",
+       "      <th>Housing_own</th>\n",
+       "      <th>Housing_rent</th>\n",
+       "      <th>Saving accounts_quite rich</th>\n",
+       "      <th>Saving accounts_little</th>\n",
+       "      <th>Saving accounts_moderate</th>\n",
+       "      <th>Saving accounts_rich</th>\n",
+       "      <th>...</th>\n",
+       "      <th>Checking account_moderate</th>\n",
+       "      <th>Checking account_rich</th>\n",
+       "      <th>Purpose_'domestic appliances'</th>\n",
+       "      <th>Purpose_business</th>\n",
+       "      <th>Purpose_car</th>\n",
+       "      <th>Purpose_education</th>\n",
+       "      <th>Purpose_furniture/equipment</th>\n",
+       "      <th>Purpose_radio/TV</th>\n",
+       "      <th>Purpose_repairs</th>\n",
+       "      <th>Purpose_vacation/others</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>2</td>\n",
+       "      <td>2181</td>\n",
+       "      <td>30</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2</td>\n",
+       "      <td>6148</td>\n",
+       "      <td>20</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>2</td>\n",
+       "      <td>2058</td>\n",
+       "      <td>24</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>2</td>\n",
+       "      <td>2613</td>\n",
+       "      <td>36</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>1</td>\n",
+       "      <td>731</td>\n",
+       "      <td>8</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>5 rows × 21 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   Job  Credit amount  Duration  Housing_free  Housing_own  Housing_rent  \\\n",
+       "0    2           2181        30           0.0          1.0           0.0   \n",
+       "1    2           6148        20           0.0          1.0           0.0   \n",
+       "2    2           2058        24           0.0          1.0           0.0   \n",
+       "3    2           2613        36           0.0          1.0           0.0   \n",
+       "4    1            731         8           0.0          1.0           0.0   \n",
+       "\n",
+       "   Saving accounts_quite rich  Saving accounts_little  \\\n",
+       "0                         0.0                     1.0   \n",
+       "1                         0.0                     0.0   \n",
+       "2                         0.0                     1.0   \n",
+       "3                         0.0                     1.0   \n",
+       "4                         0.0                     1.0   \n",
+       "\n",
+       "   Saving accounts_moderate  Saving accounts_rich  ...  \\\n",
+       "0                       0.0                   0.0  ...   \n",
+       "1                       1.0                   0.0  ...   \n",
+       "2                       0.0                   0.0  ...   \n",
+       "3                       0.0                   0.0  ...   \n",
+       "4                       0.0                   0.0  ...   \n",
+       "\n",
+       "   Checking account_moderate  Checking account_rich  \\\n",
+       "0                        1.0                    0.0   \n",
+       "1                        1.0                    0.0   \n",
+       "2                        0.0                    0.0   \n",
+       "3                        0.0                    0.0   \n",
+       "4                        0.0                    0.0   \n",
+       "\n",
+       "   Purpose_'domestic appliances'  Purpose_business  Purpose_car  \\\n",
+       "0                            0.0               0.0          1.0   \n",
+       "1                            0.0               0.0          1.0   \n",
+       "2                            0.0               0.0          0.0   \n",
+       "3                            0.0               0.0          0.0   \n",
+       "4                            0.0               0.0          1.0   \n",
+       "\n",
+       "   Purpose_education  Purpose_furniture/equipment  Purpose_radio/TV  \\\n",
+       "0                0.0                          0.0               0.0   \n",
+       "1                0.0                          0.0               0.0   \n",
+       "2                0.0                          0.0               0.0   \n",
+       "3                0.0                          0.0               0.0   \n",
+       "4                0.0                          0.0               0.0   \n",
+       "\n",
+       "   Purpose_repairs  Purpose_vacation/others  \n",
+       "0              0.0                      0.0  \n",
+       "1              0.0                      0.0  \n",
+       "2              1.0                      0.0  \n",
+       "3              1.0                      0.0  \n",
+       "4              0.0                      0.0  \n",
+       "\n",
+       "[5 rows x 21 columns]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "train['X'].head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "job_feat_train = train['X']['Job'].values\n",
+    "job_feat_train[job_feat_train < 2] = 0\n",
+    "job_feat_train[job_feat_train >= 2] = 1\n",
+    "\n",
+    "job_feat_test = test['X']['Job'].values\n",
+    "job_feat_test[job_feat_test < 2] = 0\n",
+    "job_feat_test[job_feat_test >= 2] = 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_train = train['X'].drop(columns=['Credit amount', 'Duration']).values\n",
+    "x_test = test['X'].drop(columns=['Credit amount', 'Duration']).values\n",
+    "\n",
+    "y_train = train['y'].values\n",
+    "y_test = test['y'].values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "attack_feature = 0 # job feature\n",
+    "\n",
+    "x_train[:, attack_feature] = job_feat_train\n",
+    "x_test[:, attack_feature] = job_feat_test"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "attack = AttributeInferenceBaselineTrueLabel(attack_feature=attack_feature)\n",
+    "\n",
+    "attack.fit(x_train, y_train)\n",
+    "\n",
+    "attack_x_test = np.delete(x_test, attack_feature, axis=1)\n",
+    "feat_true = x_test[:, attack_feature]\n",
+    "\n",
+    "values = [0, 1]\n",
+    "feat_pred = attack.infer(attack_x_test, y_test, values=values)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Value</th>\n",
+       "      <th>Reference</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Metric</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Accuracy</th>\n",
+       "      <td>0.730000</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Balanced Accuracy</th>\n",
+       "      <td>0.489272</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Precision</th>\n",
+       "      <td>0.765957</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Recall</th>\n",
+       "      <td>0.935065</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>F1-Score</th>\n",
+       "      <td>0.842105</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                      Value  Reference\n",
+       "Metric                                \n",
+       "Accuracy           0.730000          1\n",
+       "Balanced Accuracy  0.489272          1\n",
+       "Precision          0.765957          1\n",
+       "Recall             0.935065          1\n",
+       "F1-Score           0.842105          1"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from holisticai.efficacy.metrics import classification_efficacy_metrics\n",
+    "\n",
+    "classification_efficacy_metrics(feat_true, feat_pred)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "testing",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/tutorials/security/attribute_inference_attacks/classification/white_box.ipynb b/tutorials/security/attribute_inference_attacks/classification/white_box.ipynb
new file mode 100644
index 00000000..4456bbb9
--- /dev/null
+++ b/tutorials/security/attribute_inference_attacks/classification/white_box.ipynb
@@ -0,0 +1,423 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from holisticai.datasets import load_dataset\n",
+    "from holisticai.security.attackers.attribute_inference.wrappers.classification.scikitlearn import ScikitlearnDecisionTreeClassifier\n",
+    "from holisticai.security.attackers.attribute_inference.mitigation.scikitlearn import (\n",
+    "    AttributeInferenceWhiteBoxDecisionTree,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "    <style>\n",
+       "        @import url('https://fonts.googleapis.com/css2?family=Montserrat:ital,wght@0,100..900;1,100..900&display=swap');\n",
+       "\n",
+       "/* Light blue theme (default) */\n",
+       ".generic-object-container.blue {\n",
+       "    background-color: rgba(242, 248, 253, 0.9) !important; /* Light blue with 70% opacity */\n",
+       "    border-color: #4db6ac !important; /* Soft blue border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.blue {\n",
+       "    background-color: rgba(152, 171, 202, 0.4) !important; /* Darker blue with 60% opacity */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.blue:hover {\n",
+       "    background-color: rgba(139, 177, 192, 0.8) !important; /* Darker blue on hover with 60% opacity */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.blue:hover {\n",
+       "    background-color: rgba(178, 223, 219, 0.8) !important; /* Attribute hover background with 60% opacity */\n",
+       "}\n",
+       "\n",
+       "/* Orange theme */\n",
+       ".generic-object-container.orange {\n",
+       "    background-color: #fff9ef !important; /* Container background: light orange */\n",
+       "    border-color: #ffb74d !important; /* Soft orange border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.orange {\n",
+       "    background-color: #ffe0b2 !important; /* Header background: darker orange */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.orange:hover {\n",
+       "    background-color: #ffcc80 !important; /* Darker shade on hover over the header */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.orange:hover {\n",
+       "    background-color: #ffe0b2 !important; /* Attribute background on hover: darker orange */\n",
+       "}\n",
+       "\n",
+       "/* Green theme */\n",
+       ".generic-object-container.green {\n",
+       "    background-color: #f6fff6 !important; /* Container background: light green */\n",
+       "    border-color: #81c784 !important; /* Soft green border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.green {\n",
+       "    background-color: #c8e6c9 !important; /* Header background: darker green */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.green:hover {\n",
+       "    background-color: #a5d6a7 !important; /* Darker shade on hover over the header */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.green:hover {\n",
+       "    background-color: #c8e6c9 !important; /* Attribute background on hover: darker green */\n",
+       "}\n",
+       "\n",
+       "/* Align the first container to the left */\n",
+       ".generic-object-container.first-level {\n",
+       "    margin: 0;\n",
+       "    width: auto;\n",
+       "    max-width: 800px;\n",
+       "    display: block;\n",
+       "    box-sizing: border-box;\n",
+       "}\n",
+       "\n",
+       "/* Nested containers stay centered */\n",
+       ".generic-object-container .generic-object-container {\n",
+       "    margin: 5px auto;\n",
+       "    width: 100%;\n",
+       "    display: block;\n",
+       "    padding: 5px 0;\n",
+       "}\n",
+       "\n",
+       "/* Remove default background color so only themes apply it */\n",
+       ".generic-object-container {\n",
+       "    padding: 0;\n",
+       "    margin: 0 auto;\n",
+       "    border: 0px dashed;\n",
+       "    border-radius: 5px;\n",
+       "    display: block;\n",
+       "    width: auto;\n",
+       "    max-width: 800px;\n",
+       "    box-sizing: border-box;\n",
+       "    margin-bottom: 15px;\n",
+       "    transition: transform 0.2s, box-shadow 0.2s;\n",
+       "    box-shadow: 0px 2px 5px rgba(77, 182, 172, 0.3);\n",
+       "}\n",
+       "\n",
+       ".generic-object-container:hover {\n",
+       "    box-shadow: 0px 8px 20px rgba(77, 182, 172, 0.3);\n",
+       "}\n",
+       "\n",
+       ".generic-object-header {\n",
+       "    font-family: 'Montserrat', Arial, sans-serif;\n",
+       "    font-size: 14px;\n",
+       "    padding: 10px 20px;\n",
+       "    padding-left: 40px;\n",
+       "    text-align: center;\n",
+       "    font-weight: bold;\n",
+       "    cursor: pointer;\n",
+       "    display: flex;\n",
+       "    align-items: center;\n",
+       "    justify-content: center;\n",
+       "    position: relative;\n",
+       "    width: 100%;\n",
+       "    box-sizing: border-box;\n",
+       "    border-radius: 5px;\n",
+       "    transition: background-color 0.3s;\n",
+       "}\n",
+       "\n",
+       ".toggle-button {\n",
+       "    margin-right: 10px;\n",
+       "    background: none;\n",
+       "    border: none;\n",
+       "    font-size: 13px;\n",
+       "    cursor: pointer;\n",
+       "    position: absolute;\n",
+       "    left: 10px;\n",
+       "    color: #004d40;\n",
+       "}\n",
+       "\n",
+       ".generic-object-body {\n",
+       "    padding: 5px 10px;\n",
+       "    display: block;\n",
+       "    border-radius: 0 0 5px 5px;\n",
+       "    background-color: inherit;\n",
+       "    margin: 0 auto;\n",
+       "}\n",
+       "\n",
+       ".hidden {\n",
+       "    display: none;\n",
+       "}\n",
+       "\n",
+       ".attribute-list {\n",
+       "    margin: 2px 0;\n",
+       "    padding: 2px;\n",
+       "    transition: background-color 0.2s;\n",
+       "    display: block;\n",
+       "}\n",
+       "\n",
+       ".flex-space-filler {\n",
+       "    display: flex;\n",
+       "    justify-content: center;\n",
+       "    align-items: center;\n",
+       "}\n",
+       "\n",
+       ".generic-object-container,\n",
+       ".generic-object-header,\n",
+       ".attribute-list {\n",
+       "    color: #000000 !important; /* Establece el color del texto a negro */\n",
+       "}\n",
+       "    </style>\n",
+       "    <div style=\"display: flex;\">\n",
+       "    <div class=\"generic-object-container blue first-level\">\n",
+       "        <div class=\"generic-object-content\">\n",
+       "            <div class=\"generic-object-header blue\" onclick=\"toggleCollapse(this)\">\n",
+       "                <button class=\"toggle-button blue\">[-]</button> [Dataset]\n",
+       "            </div>\n",
+       "            <div class=\"generic-object-body\">\n",
+       "                <div class=\"attribute-list blue\"><strong>Instances</strong>: 800</div><div class=\"attribute-list blue\"><strong>Features</strong>: X , y , p_attrs</div>\n",
+       "                \n",
+       "            </div>\n",
+       "        </div>\n",
+       "    </div>\n",
+       "</div>\n",
+       "    <script>\n",
+       "    function toggleCollapse(element) {\n",
+       "        var body = element.nextElementSibling;\n",
+       "        var button = element.querySelector(\".toggle-button\");\n",
+       "        if (body.classList.contains('hidden')) {\n",
+       "            body.classList.remove('hidden');\n",
+       "            button.textContent = \"[-]\";\n",
+       "        } else {\n",
+       "            body.classList.add('hidden');\n",
+       "            button.textContent = \"[+]\";\n",
+       "        }\n",
+       "    }\n",
+       "    </script>\n",
+       "    "
+      ],
+      "text/plain": [
+       "{\"dtype\":\"Dataset\",\"attributes\":{\"Instances\":800,\"Features\":[\"X , y , p_attrs\"]},\"metadata\":null}"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dataset = load_dataset('german_credit', preprocessed=True)\n",
+    "train_test = dataset.train_test_split(test_size=0.2, stratify=dataset['y'], random_state=0)\n",
+    "train = train_test['train']\n",
+    "test = train_test['test']\n",
+    "train"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "job_feat_train = train['X']['Job'].values\n",
+    "job_feat_train[job_feat_train < 2] = 0\n",
+    "job_feat_train[job_feat_train >= 2] = 1\n",
+    "\n",
+    "job_feat_test = test['X']['Job'].values\n",
+    "job_feat_test[job_feat_test < 2] = 0\n",
+    "job_feat_test[job_feat_test >= 2] = 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((array([0, 1]), array([ 46, 154])), 200)"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "unique_values = np.unique(job_feat_test, return_counts=True)\n",
+    "unique_values, len(job_feat_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_train = train['X'].drop(columns=['Credit amount', 'Duration']).values\n",
+    "x_test = test['X'].drop(columns=['Credit amount', 'Duration']).values\n",
+    "\n",
+    "y_train = train['y'].values\n",
+    "y_test = test['y'].values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "attack_feature = 0\n",
+    "x_train[:, attack_feature] = job_feat_train\n",
+    "x_test[:, attack_feature] = job_feat_test"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.tree import DecisionTreeClassifier\n",
+    "\n",
+    "classifier = DecisionTreeClassifier()\n",
+    "classifier.fit(x_train, y_train)\n",
+    "classifier = ScikitlearnDecisionTreeClassifier(classifier)\n",
+    "\n",
+    "attack = AttributeInferenceWhiteBoxDecisionTree(classifier=classifier, attack_feature=attack_feature)\n",
+    "\n",
+    "attack_x_test = np.delete(x_test, attack_feature, axis=1)\n",
+    "\n",
+    "feat_true = x_test[:, attack_feature]\n",
+    "\n",
+    "values = [0, 1]\n",
+    "priors = [46/200, 154/200]\n",
+    "\n",
+    "feat_pred = attack.infer(attack_x_test, y_test, values=values, priors=priors)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Value</th>\n",
+       "      <th>Reference</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Metric</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Accuracy</th>\n",
+       "      <td>0.710000</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Balanced Accuracy</th>\n",
+       "      <td>0.476285</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Precision</th>\n",
+       "      <td>0.760870</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Recall</th>\n",
+       "      <td>0.909091</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>F1-Score</th>\n",
+       "      <td>0.828402</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                      Value  Reference\n",
+       "Metric                                \n",
+       "Accuracy           0.710000          1\n",
+       "Balanced Accuracy  0.476285          1\n",
+       "Precision          0.760870          1\n",
+       "Recall             0.909091          1\n",
+       "F1-Score           0.828402          1"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from holisticai.efficacy.metrics import classification_efficacy_metrics\n",
+    "\n",
+    "classification_efficacy_metrics(feat_true, feat_pred)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "testing",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/tutorials/security/attribute_inference_attacks/classification/white_box_lifestyle.ipynb b/tutorials/security/attribute_inference_attacks/classification/white_box_lifestyle.ipynb
new file mode 100644
index 00000000..04349202
--- /dev/null
+++ b/tutorials/security/attribute_inference_attacks/classification/white_box_lifestyle.ipynb
@@ -0,0 +1,423 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from holisticai.datasets import load_dataset\n",
+    "from holisticai.security.attackers.attribute_inference.wrappers.classification.scikitlearn import ScikitlearnDecisionTreeClassifier\n",
+    "from holisticai.security.attackers.attribute_inference.mitigation.attacks.white_box_lifestyle_decision_tree import (\n",
+    "    AttributeInferenceWhiteBoxLifestyleDecisionTree\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "    <style>\n",
+       "        @import url('https://fonts.googleapis.com/css2?family=Montserrat:ital,wght@0,100..900;1,100..900&display=swap');\n",
+       "\n",
+       "/* Light blue theme (default) */\n",
+       ".generic-object-container.blue {\n",
+       "    background-color: rgba(242, 248, 253, 0.9) !important; /* Light blue with 70% opacity */\n",
+       "    border-color: #4db6ac !important; /* Soft blue border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.blue {\n",
+       "    background-color: rgba(152, 171, 202, 0.4) !important; /* Darker blue with 60% opacity */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.blue:hover {\n",
+       "    background-color: rgba(139, 177, 192, 0.8) !important; /* Darker blue on hover with 60% opacity */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.blue:hover {\n",
+       "    background-color: rgba(178, 223, 219, 0.8) !important; /* Attribute hover background with 60% opacity */\n",
+       "}\n",
+       "\n",
+       "/* Orange theme */\n",
+       ".generic-object-container.orange {\n",
+       "    background-color: #fff9ef !important; /* Container background: light orange */\n",
+       "    border-color: #ffb74d !important; /* Soft orange border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.orange {\n",
+       "    background-color: #ffe0b2 !important; /* Header background: darker orange */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.orange:hover {\n",
+       "    background-color: #ffcc80 !important; /* Darker shade on hover over the header */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.orange:hover {\n",
+       "    background-color: #ffe0b2 !important; /* Attribute background on hover: darker orange */\n",
+       "}\n",
+       "\n",
+       "/* Green theme */\n",
+       ".generic-object-container.green {\n",
+       "    background-color: #f6fff6 !important; /* Container background: light green */\n",
+       "    border-color: #81c784 !important; /* Soft green border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.green {\n",
+       "    background-color: #c8e6c9 !important; /* Header background: darker green */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.green:hover {\n",
+       "    background-color: #a5d6a7 !important; /* Darker shade on hover over the header */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.green:hover {\n",
+       "    background-color: #c8e6c9 !important; /* Attribute background on hover: darker green */\n",
+       "}\n",
+       "\n",
+       "/* Align the first container to the left */\n",
+       ".generic-object-container.first-level {\n",
+       "    margin: 0;\n",
+       "    width: auto;\n",
+       "    max-width: 800px;\n",
+       "    display: block;\n",
+       "    box-sizing: border-box;\n",
+       "}\n",
+       "\n",
+       "/* Nested containers stay centered */\n",
+       ".generic-object-container .generic-object-container {\n",
+       "    margin: 5px auto;\n",
+       "    width: 100%;\n",
+       "    display: block;\n",
+       "    padding: 5px 0;\n",
+       "}\n",
+       "\n",
+       "/* Remove default background color so only themes apply it */\n",
+       ".generic-object-container {\n",
+       "    padding: 0;\n",
+       "    margin: 0 auto;\n",
+       "    border: 0px dashed;\n",
+       "    border-radius: 5px;\n",
+       "    display: block;\n",
+       "    width: auto;\n",
+       "    max-width: 800px;\n",
+       "    box-sizing: border-box;\n",
+       "    margin-bottom: 15px;\n",
+       "    transition: transform 0.2s, box-shadow 0.2s;\n",
+       "    box-shadow: 0px 2px 5px rgba(77, 182, 172, 0.3);\n",
+       "}\n",
+       "\n",
+       ".generic-object-container:hover {\n",
+       "    box-shadow: 0px 8px 20px rgba(77, 182, 172, 0.3);\n",
+       "}\n",
+       "\n",
+       ".generic-object-header {\n",
+       "    font-family: 'Montserrat', Arial, sans-serif;\n",
+       "    font-size: 14px;\n",
+       "    padding: 10px 20px;\n",
+       "    padding-left: 40px;\n",
+       "    text-align: center;\n",
+       "    font-weight: bold;\n",
+       "    cursor: pointer;\n",
+       "    display: flex;\n",
+       "    align-items: center;\n",
+       "    justify-content: center;\n",
+       "    position: relative;\n",
+       "    width: 100%;\n",
+       "    box-sizing: border-box;\n",
+       "    border-radius: 5px;\n",
+       "    transition: background-color 0.3s;\n",
+       "}\n",
+       "\n",
+       ".toggle-button {\n",
+       "    margin-right: 10px;\n",
+       "    background: none;\n",
+       "    border: none;\n",
+       "    font-size: 13px;\n",
+       "    cursor: pointer;\n",
+       "    position: absolute;\n",
+       "    left: 10px;\n",
+       "    color: #004d40;\n",
+       "}\n",
+       "\n",
+       ".generic-object-body {\n",
+       "    padding: 5px 10px;\n",
+       "    display: block;\n",
+       "    border-radius: 0 0 5px 5px;\n",
+       "    background-color: inherit;\n",
+       "    margin: 0 auto;\n",
+       "}\n",
+       "\n",
+       ".hidden {\n",
+       "    display: none;\n",
+       "}\n",
+       "\n",
+       ".attribute-list {\n",
+       "    margin: 2px 0;\n",
+       "    padding: 2px;\n",
+       "    transition: background-color 0.2s;\n",
+       "    display: block;\n",
+       "}\n",
+       "\n",
+       ".flex-space-filler {\n",
+       "    display: flex;\n",
+       "    justify-content: center;\n",
+       "    align-items: center;\n",
+       "}\n",
+       "\n",
+       ".generic-object-container,\n",
+       ".generic-object-header,\n",
+       ".attribute-list {\n",
+       "    color: #000000 !important; /* Establece el color del texto a negro */\n",
+       "}\n",
+       "    </style>\n",
+       "    <div style=\"display: flex;\">\n",
+       "    <div class=\"generic-object-container blue first-level\">\n",
+       "        <div class=\"generic-object-content\">\n",
+       "            <div class=\"generic-object-header blue\" onclick=\"toggleCollapse(this)\">\n",
+       "                <button class=\"toggle-button blue\">[-]</button> [Dataset]\n",
+       "            </div>\n",
+       "            <div class=\"generic-object-body\">\n",
+       "                <div class=\"attribute-list blue\"><strong>Instances</strong>: 800</div><div class=\"attribute-list blue\"><strong>Features</strong>: X , y , p_attrs</div>\n",
+       "                \n",
+       "            </div>\n",
+       "        </div>\n",
+       "    </div>\n",
+       "</div>\n",
+       "    <script>\n",
+       "    function toggleCollapse(element) {\n",
+       "        var body = element.nextElementSibling;\n",
+       "        var button = element.querySelector(\".toggle-button\");\n",
+       "        if (body.classList.contains('hidden')) {\n",
+       "            body.classList.remove('hidden');\n",
+       "            button.textContent = \"[-]\";\n",
+       "        } else {\n",
+       "            body.classList.add('hidden');\n",
+       "            button.textContent = \"[+]\";\n",
+       "        }\n",
+       "    }\n",
+       "    </script>\n",
+       "    "
+      ],
+      "text/plain": [
+       "{\"dtype\":\"Dataset\",\"attributes\":{\"Instances\":800,\"Features\":[\"X , y , p_attrs\"]},\"metadata\":null}"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dataset = load_dataset('german_credit', preprocessed=True)\n",
+    "train_test = dataset.train_test_split(test_size=0.2, stratify=dataset['y'], random_state=0)\n",
+    "train = train_test['train']\n",
+    "test = train_test['test']\n",
+    "train"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "job_feat_train = train['X']['Job'].values\n",
+    "job_feat_train[job_feat_train < 2] = 0\n",
+    "job_feat_train[job_feat_train >= 2] = 1\n",
+    "\n",
+    "job_feat_test = test['X']['Job'].values\n",
+    "job_feat_test[job_feat_test < 2] = 0\n",
+    "job_feat_test[job_feat_test >= 2] = 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((array([0, 1]), array([ 46, 154])), 200)"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "unique_values = np.unique(job_feat_test, return_counts=True)\n",
+    "unique_values, len(job_feat_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_train = train['X'].drop(columns=['Credit amount', 'Duration']).values\n",
+    "x_test = test['X'].drop(columns=['Credit amount', 'Duration']).values\n",
+    "\n",
+    "y_train = train['y'].values\n",
+    "y_test = test['y'].values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "attack_feature = 0\n",
+    "x_train[:, attack_feature] = job_feat_train\n",
+    "x_test[:, attack_feature] = job_feat_test"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.tree import DecisionTreeClassifier\n",
+    "\n",
+    "classifier = DecisionTreeClassifier()\n",
+    "classifier.fit(x_train, y_train)\n",
+    "classifier = ScikitlearnDecisionTreeClassifier(classifier)\n",
+    "\n",
+    "attack = AttributeInferenceWhiteBoxLifestyleDecisionTree(estimator=classifier, attack_feature=attack_feature)\n",
+    "\n",
+    "attack_x_test = np.delete(x_test, attack_feature, axis=1)\n",
+    "\n",
+    "feat_true = x_test[:, attack_feature]\n",
+    "\n",
+    "values = [0, 1]\n",
+    "priors = [46/200, 154/200]\n",
+    "\n",
+    "feat_pred = attack.infer(attack_x_test, values=values, priors=priors)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Value</th>\n",
+       "      <th>Reference</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Metric</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Accuracy</th>\n",
+       "      <td>0.735000</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Balanced Accuracy</th>\n",
+       "      <td>0.500141</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Precision</th>\n",
+       "      <td>0.770053</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Recall</th>\n",
+       "      <td>0.935065</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>F1-Score</th>\n",
+       "      <td>0.844575</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                      Value  Reference\n",
+       "Metric                                \n",
+       "Accuracy           0.735000          1\n",
+       "Balanced Accuracy  0.500141          1\n",
+       "Precision          0.770053          1\n",
+       "Recall             0.935065          1\n",
+       "F1-Score           0.844575          1"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from holisticai.efficacy.metrics import classification_efficacy_metrics\n",
+    "\n",
+    "classification_efficacy_metrics(feat_true, feat_pred)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "testing",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

From 5b6dde0d2270691e8d23e554851a8355545385d7 Mon Sep 17 00:00:00 2001
From: franklincf <fracarfer5@gmail.com>
Date: Thu, 19 Dec 2024 11:21:09 -0300
Subject: [PATCH 10/34] refactor: updating attribute inference classification
 tutorials

---
 .../classification/baseline.ipynb             | 158 ++++++++----------
 .../classification/black_box.ipynb            |  64 ++++++-
 .../classification/true_label.ipynb           |  66 ++++++++
 .../classification/white_box.ipynb            |  61 +++++++
 .../classification/white_box_lifestyle.ipynb  |  63 ++++++-
 5 files changed, 318 insertions(+), 94 deletions(-)

diff --git a/tutorials/security/attribute_inference_attacks/classification/baseline.ipynb b/tutorials/security/attribute_inference_attacks/classification/baseline.ipynb
index efa06e16..8afb6ce7 100644
--- a/tutorials/security/attribute_inference_attacks/classification/baseline.ipynb
+++ b/tutorials/security/attribute_inference_attacks/classification/baseline.ipynb
@@ -1,5 +1,16 @@
 {
  "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# **Attribute inference attack with the baseline module**\n",
+    "\n",
+    "In this notebook, we will demonstrate how to perform an attribute inference attack with the baseline module. The goal of an attribute inference attack is to infer the value of a sensitive attribute of a data record by querying a model trained on the data. In this case, we will consider the 'Job' attribute of the German credit dataset as the attribute to be inferred. \n",
+    "\n",
+    "### **Importing the necessary libraries and loading the data** "
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -457,6 +468,17 @@
     "train['X'].head()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Dataset preprocessing**\n",
+    "\n",
+    "The German credit dataset is a dataset that contains information about 1000 loan applicants. The dataset has 20 attributes, including the 'Job' attribute, which will be the attribute to be inferred. The 'Job' attribute has four possible values: 'Unskilled', 'Unskilled Resident', 'Skilled', and 'Highly Skilled'. The dataset also contains a binary target attribute, 'Credit', which indicates whether the loan application was approved or not.\n",
+    "\n",
+    "For this demonstration, we will transform the 'Job' attribute into a binary attribute by considering only two values: 'Highly Skilled', represented by 1, and 'Not Highly Skilled', represented by 0. The goal of the attack will be to infer the value of the 'Job' attribute of a data record by querying a model trained on the data."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 4,
@@ -472,6 +494,13 @@
     "job_feat_test[job_feat_test >= 2] = 1"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To make this demonstration more simple, we will also remove the 'Credit amount' attribute and the 'Duration' attribute from the dataset."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 5,
@@ -483,23 +512,39 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 6,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "x_train[:, 0] = job_feat_train\n",
-    "x_test[:, 0] = job_feat_test"
+    "We will also replace the transformed 'Job' attribute into the original training data and test data."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "attack_feature = 0 # job feature\n",
     "\n",
+    "x_train[:, attack_feature] = job_feat_train\n",
+    "x_test[:, attack_feature] = job_feat_test"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Attribute inference attack - baseline**\n",
+    "\n",
+    "Now, we will perform a baseline attack to infer the selected attribute using the `AttributeInferenceBaseline` class from the `holisticai` library. This class, creates an object that uses an internal model to perform the attack. The internal model is trained on the same dataset used to train the target model to learn the attacked feature from the remaining features. The attack is performed by querying the internal model with the target model's predictions and the target model's input data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "attack = AttributeInferenceBaseline(attack_feature=attack_feature)\n",
     "\n",
     "attack.fit(x_train)\n",
@@ -511,6 +556,15 @@
     "feat_pred = attack.infer(attack_x_test, values=values)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Measuring the attack success**\n",
+    "\n",
+    "The success of the attack is measured by the accuracy of the inferred attribute. The accuracy is calculated as the ratio of the correctly inferred attributes to the total number of data records. This can be done by using traditional classification metrics such as accuracy, precision, recall, and F1-score. For our case, we will use the `classification_efficacy_metrics` function from the `holisticai` library to calculate these metrics."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 8,
@@ -598,94 +652,16 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 9,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<div>\n",
-       "<style scoped>\n",
-       "    .dataframe tbody tr th:only-of-type {\n",
-       "        vertical-align: middle;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe tbody tr th {\n",
-       "        vertical-align: top;\n",
-       "    }\n",
-       "\n",
-       "    .dataframe thead th {\n",
-       "        text-align: right;\n",
-       "    }\n",
-       "</style>\n",
-       "<table border=\"1\" class=\"dataframe\">\n",
-       "  <thead>\n",
-       "    <tr style=\"text-align: right;\">\n",
-       "      <th></th>\n",
-       "      <th>Value</th>\n",
-       "      <th>Reference</th>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>Metric</th>\n",
-       "      <th></th>\n",
-       "      <th></th>\n",
-       "    </tr>\n",
-       "  </thead>\n",
-       "  <tbody>\n",
-       "    <tr>\n",
-       "      <th>Accuracy</th>\n",
-       "      <td>0.802500</td>\n",
-       "      <td>1</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>Balanced Accuracy</th>\n",
-       "      <td>0.563374</td>\n",
-       "      <td>1</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>Precision</th>\n",
-       "      <td>0.802597</td>\n",
-       "      <td>1</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>Recall</th>\n",
-       "      <td>0.990385</td>\n",
-       "      <td>1</td>\n",
-       "    </tr>\n",
-       "    <tr>\n",
-       "      <th>F1-Score</th>\n",
-       "      <td>0.886657</td>\n",
-       "      <td>1</td>\n",
-       "    </tr>\n",
-       "  </tbody>\n",
-       "</table>\n",
-       "</div>"
-      ],
-      "text/plain": [
-       "                      Value  Reference\n",
-       "Metric                                \n",
-       "Accuracy           0.802500          1\n",
-       "Balanced Accuracy  0.563374          1\n",
-       "Precision          0.802597          1\n",
-       "Recall             0.990385          1\n",
-       "F1-Score           0.886657          1"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
    "source": [
-    "attack_x_train = np.delete(x_train, attack_feature, axis=1)\n",
-    "feat_true = x_train[:, attack_feature]\n",
-    "\n",
-    "values = [0, 1]\n",
-    "feat_pred = attack.infer(attack_x_train, values=values)\n",
-    "\n",
-    "classification_efficacy_metrics(feat_true, feat_pred)"
+    "As we can see, our attack achieved an accuracy of 0.75, which means that the attack was able to infer the 'Job' attribute with an accuracy of 75%."
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
   }
  ],
  "metadata": {
diff --git a/tutorials/security/attribute_inference_attacks/classification/black_box.ipynb b/tutorials/security/attribute_inference_attacks/classification/black_box.ipynb
index 826bb8d8..6d67bda1 100644
--- a/tutorials/security/attribute_inference_attacks/classification/black_box.ipynb
+++ b/tutorials/security/attribute_inference_attacks/classification/black_box.ipynb
@@ -1,13 +1,23 @@
 {
  "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# **Attribute inference attack with the blackbox module**\n",
+    "\n",
+    "In this notebook, we will demonstrate how to perform an attribute inference attack with the blackbox module on a classification model. The goal of an attribute inference attack is to infer the value of a sensitive attribute of a data record by querying a model trained on the data. In this case, we will consider the 'Job' attribute of the German credit dataset as the attribute to be inferred. \n",
+    "\n",
+    "### **Importing the necessary libraries and loading the data** "
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "import numpy as np\n",
-    "from holisticai.security.attackers.attribute_inference.dataset_utils import AttackDataset\n",
     "from holisticai.security.attackers.attribute_inference.wrappers.classification.scikitlearn import SklearnClassifier\n",
     "from holisticai.datasets import load_dataset\n",
     "from holisticai.security.attackers.attribute_inference.black_box import AttributeInferenceBlackBox"
@@ -220,6 +230,17 @@
     "train"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Dataset preprocessing**\n",
+    "\n",
+    "The German credit dataset is a dataset that contains information about 1000 loan applicants. The dataset has 20 attributes, including the 'Job' attribute, which will be the attribute to be inferred. The 'Job' attribute has four possible values: 'Unskilled', 'Unskilled Resident', 'Skilled', and 'Highly Skilled'. The dataset also contains a binary target attribute, 'Credit', which indicates whether the loan application was approved or not.\n",
+    "\n",
+    "For this demonstration, we will transform the 'Job' attribute into a binary attribute by considering only two values: 'Highly Skilled', represented by 1, and 'Not Highly Skilled', represented by 0. The goal of the attack will be to infer the value of the 'Job' attribute of a data record by querying a model trained on the data."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 3,
@@ -235,6 +256,13 @@
     "job_feat_test[job_feat_test >= 2] = 1"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To make this demonstration more simple, we will also remove the 'Credit amount' attribute and the 'Duration' attribute from the dataset."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 4,
@@ -248,6 +276,13 @@
     "y_test = test['y'].values"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We will also replace the transformed 'Job' attribute into the original training data and test data."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 5,
@@ -259,6 +294,15 @@
     "x_test[:, attack_feature] = job_feat_test"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Attribute inference attack - blackbox**\n",
+    "\n",
+    "Now, we will perform an attack to infer the selected attribute using the `AttributeInferenceBlackBox` class from the `holisticai` library. This class, creates an object that uses an internal model to perform the attack. The internal model is trained on the same dataset used to train the target model to learn the attacked feature from the remaining features. This module assumes the availability of the attacked model's predictions for the samples under attack, in addition to the rest of the feature values. "
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 7,
@@ -285,6 +329,15 @@
     "feat_pred = attack.infer(attack_x_test, y_test, pred, values=values)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Measuring the attack success**\n",
+    "\n",
+    "The success of the attack is measured by the accuracy of the inferred attribute. The accuracy is calculated as the ratio of the correctly inferred attributes to the total number of data records. This can be done by using traditional classification metrics such as accuracy, precision, recall, and F1-score. For our case, we will use the `classification_efficacy_metrics` function from the `holisticai` library to calculate these metrics."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 8,
@@ -371,6 +424,13 @@
     "classification_efficacy_metrics(feat_true, feat_pred)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As we can see, our attack achieved an accuracy of 0.915, which means that the attack was able to infer the 'Job' attribute with an accuracy of 91.5%, which is a high accuracy. This demonstrates the vulnerability of the model to attribute inference attacks and the importance of protecting sensitive attributes in the data."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
diff --git a/tutorials/security/attribute_inference_attacks/classification/true_label.ipynb b/tutorials/security/attribute_inference_attacks/classification/true_label.ipynb
index c0b7f489..8fc221a5 100644
--- a/tutorials/security/attribute_inference_attacks/classification/true_label.ipynb
+++ b/tutorials/security/attribute_inference_attacks/classification/true_label.ipynb
@@ -1,5 +1,16 @@
 {
  "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# **Attribute inference attack with the TrueLabel module**\n",
+    "\n",
+    "In this notebook, we will demonstrate how to perform an attribute inference attack with the TrueLabel module. The goal of an attribute inference attack is to infer the value of a sensitive attribute of a data record by querying a model trained on the data. In this case, we will consider the 'Job' attribute of the German credit dataset as the attribute to be inferred. \n",
+    "\n",
+    "### **Importing the necessary libraries and loading the data** "
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -457,6 +468,17 @@
     "train['X'].head()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Dataset preprocessing**\n",
+    "\n",
+    "The German credit dataset is a dataset that contains information about 1000 loan applicants. The dataset has 20 attributes, including the 'Job' attribute, which will be the attribute to be inferred. The 'Job' attribute has four possible values: 'Unskilled', 'Unskilled Resident', 'Skilled', and 'Highly Skilled'. The dataset also contains a binary target attribute, 'Credit', which indicates whether the loan application was approved or not.\n",
+    "\n",
+    "For this demonstration, we will transform the 'Job' attribute into a binary attribute by considering only two values: 'Highly Skilled', represented by 1, and 'Not Highly Skilled', represented by 0. The goal of the attack will be to infer the value of the 'Job' attribute of a data record by querying a model trained on the data."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 4,
@@ -472,6 +494,13 @@
     "job_feat_test[job_feat_test >= 2] = 1"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To make this demonstration more simple, we will also remove the 'Credit amount' attribute and the 'Duration' attribute from the dataset."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 5,
@@ -485,6 +514,13 @@
     "y_test = test['y'].values"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We will also replace the transformed 'Job' attribute into the original training data and test data."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 6,
@@ -497,6 +533,15 @@
     "x_test[:, attack_feature] = job_feat_test"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Attribute inference attack - TrueLabel**\n",
+    "\n",
+    "Now, we will perform an attack to infer the selected attribute using the `AttributeInferenceBaselineTrueLabel` class from the `holisticai` library. This class, creates an object that uses an internal model to perform the attack. The internal model is trained on the same dataset used to train the target model to learn the attacked feature from the remaining features. The attack is performed by querying the internal model with the target model's predictions and the target model's input data. This module works similar to the baseline module, but requires the target model's input data to be provided."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 7,
@@ -514,6 +559,15 @@
     "feat_pred = attack.infer(attack_x_test, y_test, values=values)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Measuring the attack success**\n",
+    "\n",
+    "The success of the attack is measured by the accuracy of the inferred attribute. The accuracy is calculated as the ratio of the correctly inferred attributes to the total number of data records. This can be done by using traditional classification metrics such as accuracy, precision, recall, and F1-score. For our case, we will use the `classification_efficacy_metrics` function from the `holisticai` library to calculate these metrics."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 8,
@@ -599,6 +653,18 @@
     "\n",
     "classification_efficacy_metrics(feat_true, feat_pred)"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As we can see, our attack achieved an accuracy of 0.73, which means that the attack was able to infer the 'Job' attribute with an accuracy of 73%."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
   }
  ],
  "metadata": {
diff --git a/tutorials/security/attribute_inference_attacks/classification/white_box.ipynb b/tutorials/security/attribute_inference_attacks/classification/white_box.ipynb
index 4456bbb9..dd882762 100644
--- a/tutorials/security/attribute_inference_attacks/classification/white_box.ipynb
+++ b/tutorials/security/attribute_inference_attacks/classification/white_box.ipynb
@@ -1,5 +1,16 @@
 {
  "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# **Attribute inference attack with the WhiteBox module**\n",
+    "\n",
+    "In this notebook, we will demonstrate how to perform an attribute inference attack with the WhiteBox module. The goal of an attribute inference attack is to infer the value of a sensitive attribute of a data record by querying a model trained on the data. In this case, we will consider the 'Job' attribute of the German credit dataset as the attribute to be inferred. \n",
+    "\n",
+    "### **Importing the necessary libraries and loading the data** "
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -221,6 +232,17 @@
     "train"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Dataset preprocessing**\n",
+    "\n",
+    "The German credit dataset is a dataset that contains information about 1000 loan applicants. The dataset has 20 attributes, including the 'Job' attribute, which will be the attribute to be inferred. The 'Job' attribute has four possible values: 'Unskilled', 'Unskilled Resident', 'Skilled', and 'Highly Skilled'. The dataset also contains a binary target attribute, 'Credit', which indicates whether the loan application was approved or not.\n",
+    "\n",
+    "For this demonstration, we will transform the 'Job' attribute into a binary attribute by considering only two values: 'Highly Skilled', represented by 1, and 'Not Highly Skilled', represented by 0. The goal of the attack will be to infer the value of the 'Job' attribute of a data record by querying a model trained on the data."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 3,
@@ -257,6 +279,13 @@
     "unique_values, len(job_feat_test)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To make this demonstration more simple, we will also remove the 'Credit amount' attribute and the 'Duration' attribute from the dataset."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 7,
@@ -270,6 +299,13 @@
     "y_test = test['y'].values"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We will also replace the transformed 'Job' attribute into the original training data and test data."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 8,
@@ -281,6 +317,15 @@
     "x_test[:, attack_feature] = job_feat_test"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Attribute inference attack - WhiteBox**\n",
+    "\n",
+    "Now, we will perform an attack to infer the selected attribute using the `AttributeInferenceWhiteBoxDecisionTree` class from the `holisticai` library. This class, creates an object that uses an internal model to perform the attack. The internal model is trained on the same dataset used to train the target model to learn the attacked feature from the remaining features. The attack is performed by querying the internal model with the target model's predictions and the target model's input data. This is a variation of the method proposed by [Fredrikson et al.](https://dl.acm.org/doi/10.1145/2810103.2813677), since it assumes the availability of the attacked model's predictions for the samples under attack, in addition to access to the model itself and the rest of the feature values.  Unlike the WhiteBoxLifeStyle module, this module requires the target values to pefrom the attack."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 10,
@@ -305,6 +350,15 @@
     "feat_pred = attack.infer(attack_x_test, y_test, values=values, priors=priors)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Measuring the attack success**\n",
+    "\n",
+    "The success of the attack is measured by the accuracy of the inferred attribute. The accuracy is calculated as the ratio of the correctly inferred attributes to the total number of data records. This can be done by using traditional classification metrics such as accuracy, precision, recall, and F1-score. For our case, we will use the `classification_efficacy_metrics` function from the `holisticai` library to calculate these metrics."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 11,
@@ -391,6 +445,13 @@
     "classification_efficacy_metrics(feat_true, feat_pred)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As we can see, our attack achieved an accuracy of 0.71, which means that the attack was able to infer the 'Job' attribute with an accuracy of 71%."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
diff --git a/tutorials/security/attribute_inference_attacks/classification/white_box_lifestyle.ipynb b/tutorials/security/attribute_inference_attacks/classification/white_box_lifestyle.ipynb
index 04349202..8190fec3 100644
--- a/tutorials/security/attribute_inference_attacks/classification/white_box_lifestyle.ipynb
+++ b/tutorials/security/attribute_inference_attacks/classification/white_box_lifestyle.ipynb
@@ -1,5 +1,16 @@
 {
  "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# **Attribute inference attack with the WhiteBoxLifeStyle module**\n",
+    "\n",
+    "In this notebook, we will demonstrate how to perform an attribute inference attack with the WhiteBoxLifeStyle module. The goal of an attribute inference attack is to infer the value of a sensitive attribute of a data record by querying a model trained on the data. In this case, we will consider the 'Job' attribute of the German credit dataset as the attribute to be inferred. \n",
+    "\n",
+    "### **Importing the necessary libraries and loading the data** "
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -221,6 +232,17 @@
     "train"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Dataset preprocessing**\n",
+    "\n",
+    "The German credit dataset is a dataset that contains information about 1000 loan applicants. The dataset has 20 attributes, including the 'Job' attribute, which will be the attribute to be inferred. The 'Job' attribute has four possible values: 'Unskilled', 'Unskilled Resident', 'Skilled', and 'Highly Skilled'. The dataset also contains a binary target attribute, 'Credit', which indicates whether the loan application was approved or not.\n",
+    "\n",
+    "For this demonstration, we will transform the 'Job' attribute into a binary attribute by considering only two values: 'Highly Skilled', represented by 1, and 'Not Highly Skilled', represented by 0. The goal of the attack will be to infer the value of the 'Job' attribute of a data record by querying a model trained on the data."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 3,
@@ -257,6 +279,13 @@
     "unique_values, len(job_feat_test)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To make this demonstration more simple, we will also remove the 'Credit amount' attribute and the 'Duration' attribute from the dataset."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 5,
@@ -270,6 +299,13 @@
     "y_test = test['y'].values"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We will also replace the transformed 'Job' attribute into the original training data and test data."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 6,
@@ -281,9 +317,18 @@
     "x_test[:, attack_feature] = job_feat_test"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Attribute inference attack - WhiteBoxLifestyle**\n",
+    "\n",
+    "Now, we will perform an attack to infer the selected attribute using the `AttributeInferenceWhiteBoxLifestyleDecisionTree` class from the `holisticai` library. This class, creates an object that uses an internal model to perform the attack. The internal model is trained on the same dataset used to train the target model to learn the attacked feature from the remaining features. The attack is performed by querying the internal model with the target model's predictions and the target model's input data. For our case we will use a implementation of [Fredrikson et al.](https://dl.acm.org/doi/10.1145/2810103.2813677) to perform the attack, specifically for decision trees."
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -305,6 +350,15 @@
     "feat_pred = attack.infer(attack_x_test, values=values, priors=priors)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Measuring the attack success**\n",
+    "\n",
+    "The success of the attack is measured by the accuracy of the inferred attribute. The accuracy is calculated as the ratio of the correctly inferred attributes to the total number of data records. This can be done by using traditional classification metrics such as accuracy, precision, recall, and F1-score. For our case, we will use the `classification_efficacy_metrics` function from the `holisticai` library to calculate these metrics."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 8,
@@ -391,6 +445,13 @@
     "classification_efficacy_metrics(feat_true, feat_pred)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As we can see, our attack achieved an accuracy of 0.735, which means that the attack was able to infer the 'Job' attribute with an accuracy of 73.5%."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,

From 9224c0c1d1aa125a5553d84b8aa32952fca698fc Mon Sep 17 00:00:00 2001
From: franklincf <fracarfer5@gmail.com>
Date: Thu, 19 Dec 2024 11:22:26 -0300
Subject: [PATCH 11/34] chore: adding tutorials for attribute inference for
 regression cases

---
 .../regression/baseline.ipynb                 | 649 +++++++++++++++++
 .../regression/black_box.ipynb                | 668 +++++++++++++++++
 .../regression/true_label.ipynb               | 652 +++++++++++++++++
 .../regression/white_box.ipynb                | 681 ++++++++++++++++++
 4 files changed, 2650 insertions(+)
 create mode 100644 tutorials/security/attribute_inference_attacks/regression/baseline.ipynb
 create mode 100644 tutorials/security/attribute_inference_attacks/regression/black_box.ipynb
 create mode 100644 tutorials/security/attribute_inference_attacks/regression/true_label.ipynb
 create mode 100644 tutorials/security/attribute_inference_attacks/regression/white_box.ipynb

diff --git a/tutorials/security/attribute_inference_attacks/regression/baseline.ipynb b/tutorials/security/attribute_inference_attacks/regression/baseline.ipynb
new file mode 100644
index 00000000..7e61457c
--- /dev/null
+++ b/tutorials/security/attribute_inference_attacks/regression/baseline.ipynb
@@ -0,0 +1,649 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# **Attribute inference attack with the baseline module**\n",
+    "\n",
+    "In this notebook, we will demonstrate how to perform an attribute inference attack with the baseline module. The goal of an attribute inference attack is to infer the value of a sensitive attribute of a data record by querying a model trained on the data. In this case, we will work with the 'us_crime' dataset, which contains information about crime rates in the United States, and we will consider the 'race' attribute to perform the attack.\n",
+    "\n",
+    "### **Importing the necessary libraries and loading the data** "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from holisticai.datasets import load_dataset\n",
+    "from holisticai.security.attackers.attribute_inference.baseline import AttributeInferenceBaseline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "    <style>\n",
+       "        @import url('https://fonts.googleapis.com/css2?family=Montserrat:ital,wght@0,100..900;1,100..900&display=swap');\n",
+       "\n",
+       "/* Light blue theme (default) */\n",
+       ".generic-object-container.blue {\n",
+       "    background-color: rgba(242, 248, 253, 0.9) !important; /* Light blue with 70% opacity */\n",
+       "    border-color: #4db6ac !important; /* Soft blue border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.blue {\n",
+       "    background-color: rgba(152, 171, 202, 0.4) !important; /* Darker blue with 60% opacity */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.blue:hover {\n",
+       "    background-color: rgba(139, 177, 192, 0.8) !important; /* Darker blue on hover with 60% opacity */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.blue:hover {\n",
+       "    background-color: rgba(178, 223, 219, 0.8) !important; /* Attribute hover background with 60% opacity */\n",
+       "}\n",
+       "\n",
+       "/* Orange theme */\n",
+       ".generic-object-container.orange {\n",
+       "    background-color: #fff9ef !important; /* Container background: light orange */\n",
+       "    border-color: #ffb74d !important; /* Soft orange border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.orange {\n",
+       "    background-color: #ffe0b2 !important; /* Header background: darker orange */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.orange:hover {\n",
+       "    background-color: #ffcc80 !important; /* Darker shade on hover over the header */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.orange:hover {\n",
+       "    background-color: #ffe0b2 !important; /* Attribute background on hover: darker orange */\n",
+       "}\n",
+       "\n",
+       "/* Green theme */\n",
+       ".generic-object-container.green {\n",
+       "    background-color: #f6fff6 !important; /* Container background: light green */\n",
+       "    border-color: #81c784 !important; /* Soft green border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.green {\n",
+       "    background-color: #c8e6c9 !important; /* Header background: darker green */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.green:hover {\n",
+       "    background-color: #a5d6a7 !important; /* Darker shade on hover over the header */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.green:hover {\n",
+       "    background-color: #c8e6c9 !important; /* Attribute background on hover: darker green */\n",
+       "}\n",
+       "\n",
+       "/* Align the first container to the left */\n",
+       ".generic-object-container.first-level {\n",
+       "    margin: 0;\n",
+       "    width: auto;\n",
+       "    max-width: 800px;\n",
+       "    display: block;\n",
+       "    box-sizing: border-box;\n",
+       "}\n",
+       "\n",
+       "/* Nested containers stay centered */\n",
+       ".generic-object-container .generic-object-container {\n",
+       "    margin: 5px auto;\n",
+       "    width: 100%;\n",
+       "    display: block;\n",
+       "    padding: 5px 0;\n",
+       "}\n",
+       "\n",
+       "/* Remove default background color so only themes apply it */\n",
+       ".generic-object-container {\n",
+       "    padding: 0;\n",
+       "    margin: 0 auto;\n",
+       "    border: 0px dashed;\n",
+       "    border-radius: 5px;\n",
+       "    display: block;\n",
+       "    width: auto;\n",
+       "    max-width: 800px;\n",
+       "    box-sizing: border-box;\n",
+       "    margin-bottom: 15px;\n",
+       "    transition: transform 0.2s, box-shadow 0.2s;\n",
+       "    box-shadow: 0px 2px 5px rgba(77, 182, 172, 0.3);\n",
+       "}\n",
+       "\n",
+       ".generic-object-container:hover {\n",
+       "    box-shadow: 0px 8px 20px rgba(77, 182, 172, 0.3);\n",
+       "}\n",
+       "\n",
+       ".generic-object-header {\n",
+       "    font-family: 'Montserrat', Arial, sans-serif;\n",
+       "    font-size: 14px;\n",
+       "    padding: 10px 20px;\n",
+       "    padding-left: 40px;\n",
+       "    text-align: center;\n",
+       "    font-weight: bold;\n",
+       "    cursor: pointer;\n",
+       "    display: flex;\n",
+       "    align-items: center;\n",
+       "    justify-content: center;\n",
+       "    position: relative;\n",
+       "    width: 100%;\n",
+       "    box-sizing: border-box;\n",
+       "    border-radius: 5px;\n",
+       "    transition: background-color 0.3s;\n",
+       "}\n",
+       "\n",
+       ".toggle-button {\n",
+       "    margin-right: 10px;\n",
+       "    background: none;\n",
+       "    border: none;\n",
+       "    font-size: 13px;\n",
+       "    cursor: pointer;\n",
+       "    position: absolute;\n",
+       "    left: 10px;\n",
+       "    color: #004d40;\n",
+       "}\n",
+       "\n",
+       ".generic-object-body {\n",
+       "    padding: 5px 10px;\n",
+       "    display: block;\n",
+       "    border-radius: 0 0 5px 5px;\n",
+       "    background-color: inherit;\n",
+       "    margin: 0 auto;\n",
+       "}\n",
+       "\n",
+       ".hidden {\n",
+       "    display: none;\n",
+       "}\n",
+       "\n",
+       ".attribute-list {\n",
+       "    margin: 2px 0;\n",
+       "    padding: 2px;\n",
+       "    transition: background-color 0.2s;\n",
+       "    display: block;\n",
+       "}\n",
+       "\n",
+       ".flex-space-filler {\n",
+       "    display: flex;\n",
+       "    justify-content: center;\n",
+       "    align-items: center;\n",
+       "}\n",
+       "\n",
+       ".generic-object-container,\n",
+       ".generic-object-header,\n",
+       ".attribute-list {\n",
+       "    color: #000000 !important; /* Establece el color del texto a negro */\n",
+       "}\n",
+       "    </style>\n",
+       "    <div style=\"display: flex;\">\n",
+       "    <div class=\"generic-object-container blue first-level\">\n",
+       "        <div class=\"generic-object-content\">\n",
+       "            <div class=\"generic-object-header blue\" onclick=\"toggleCollapse(this)\">\n",
+       "                <button class=\"toggle-button blue\">[-]</button> [Dataset]\n",
+       "            </div>\n",
+       "            <div class=\"generic-object-body\">\n",
+       "                <div class=\"attribute-list blue\"><strong>Instances</strong>: 1594</div><div class=\"attribute-list blue\"><strong>Features</strong>: X , y , p_attrs , group_a , group_b</div><div class=\"attribute-list blue\"><strong>Metadata</strong>: race: {'group_a': 'racePctWhite>0.5', 'group_b': 'racePctWhite<=0.5'}</div>\n",
+       "                \n",
+       "            </div>\n",
+       "        </div>\n",
+       "    </div>\n",
+       "</div>\n",
+       "    <script>\n",
+       "    function toggleCollapse(element) {\n",
+       "        var body = element.nextElementSibling;\n",
+       "        var button = element.querySelector(\".toggle-button\");\n",
+       "        if (body.classList.contains('hidden')) {\n",
+       "            body.classList.remove('hidden');\n",
+       "            button.textContent = \"[-]\";\n",
+       "        } else {\n",
+       "            body.classList.add('hidden');\n",
+       "            button.textContent = \"[+]\";\n",
+       "        }\n",
+       "    }\n",
+       "    </script>\n",
+       "    "
+      ],
+      "text/plain": [
+       "{\"dtype\":\"Dataset\",\"attributes\":{\"Instances\":1594,\"Features\":[\"X , y , p_attrs , group_a , group_b\"]},\"metadata\":\"race: {'group_a': 'racePctWhite>0.5', 'group_b': 'racePctWhite<=0.5'}\"}"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dataset = load_dataset('us_crime', preprocessed=True, protected_attribute='race')\n",
+    "train_test = dataset.train_test_split(test_size=0.2, random_state=0)\n",
+    "train = train_test['train']\n",
+    "test = train_test['test']\n",
+    "train"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>state</th>\n",
+       "      <th>fold</th>\n",
+       "      <th>population</th>\n",
+       "      <th>householdsize</th>\n",
+       "      <th>racepctblack</th>\n",
+       "      <th>racePctAsian</th>\n",
+       "      <th>racePctHisp</th>\n",
+       "      <th>agePct12t21</th>\n",
+       "      <th>agePct12t29</th>\n",
+       "      <th>agePct16t24</th>\n",
+       "      <th>...</th>\n",
+       "      <th>NumStreet</th>\n",
+       "      <th>PctForeignBorn</th>\n",
+       "      <th>PctBornSameState</th>\n",
+       "      <th>PctSameHouse85</th>\n",
+       "      <th>PctSameCity85</th>\n",
+       "      <th>PctSameState85</th>\n",
+       "      <th>LandArea</th>\n",
+       "      <th>PopDens</th>\n",
+       "      <th>PctUsePubTrans</th>\n",
+       "      <th>LemasPctOfficDrugUn</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>45</td>\n",
+       "      <td>8</td>\n",
+       "      <td>0.14</td>\n",
+       "      <td>0.56</td>\n",
+       "      <td>0.85</td>\n",
+       "      <td>0.09</td>\n",
+       "      <td>0.03</td>\n",
+       "      <td>0.76</td>\n",
+       "      <td>0.83</td>\n",
+       "      <td>0.77</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.09</td>\n",
+       "      <td>0.09</td>\n",
+       "      <td>0.62</td>\n",
+       "      <td>0.33</td>\n",
+       "      <td>0.36</td>\n",
+       "      <td>0.36</td>\n",
+       "      <td>0.34</td>\n",
+       "      <td>0.07</td>\n",
+       "      <td>0.27</td>\n",
+       "      <td>1.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>6</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.40</td>\n",
+       "      <td>0.02</td>\n",
+       "      <td>0.11</td>\n",
+       "      <td>0.22</td>\n",
+       "      <td>0.39</td>\n",
+       "      <td>0.42</td>\n",
+       "      <td>0.25</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.19</td>\n",
+       "      <td>0.66</td>\n",
+       "      <td>0.30</td>\n",
+       "      <td>0.57</td>\n",
+       "      <td>0.78</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.26</td>\n",
+       "      <td>0.02</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>55</td>\n",
+       "      <td>5</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.33</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.36</td>\n",
+       "      <td>0.40</td>\n",
+       "      <td>0.24</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.03</td>\n",
+       "      <td>0.67</td>\n",
+       "      <td>0.76</td>\n",
+       "      <td>0.77</td>\n",
+       "      <td>0.71</td>\n",
+       "      <td>0.02</td>\n",
+       "      <td>0.15</td>\n",
+       "      <td>0.02</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>34</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.71</td>\n",
+       "      <td>0.36</td>\n",
+       "      <td>0.21</td>\n",
+       "      <td>0.06</td>\n",
+       "      <td>0.77</td>\n",
+       "      <td>0.65</td>\n",
+       "      <td>0.66</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.35</td>\n",
+       "      <td>0.48</td>\n",
+       "      <td>0.66</td>\n",
+       "      <td>0.53</td>\n",
+       "      <td>0.57</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.48</td>\n",
+       "      <td>0.82</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>13</td>\n",
+       "      <td>8</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.65</td>\n",
+       "      <td>0.08</td>\n",
+       "      <td>0.20</td>\n",
+       "      <td>0.04</td>\n",
+       "      <td>0.48</td>\n",
+       "      <td>0.36</td>\n",
+       "      <td>0.20</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.13</td>\n",
+       "      <td>0.22</td>\n",
+       "      <td>0.20</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.07</td>\n",
+       "      <td>0.07</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>5 rows × 101 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   state  fold  population  householdsize  racepctblack  racePctAsian  \\\n",
+       "0     45     8        0.14           0.56          0.85          0.09   \n",
+       "1      6     2        0.01           0.40          0.02          0.11   \n",
+       "2     55     5        0.00           0.33          0.00          0.01   \n",
+       "3     34     3        0.01           0.71          0.36          0.21   \n",
+       "4     13     8        0.01           0.65          0.08          0.20   \n",
+       "\n",
+       "   racePctHisp  agePct12t21  agePct12t29  agePct16t24  ...  NumStreet  \\\n",
+       "0         0.03         0.76         0.83         0.77  ...       0.09   \n",
+       "1         0.22         0.39         0.42         0.25  ...       0.01   \n",
+       "2         0.01         0.36         0.40         0.24  ...       0.00   \n",
+       "3         0.06         0.77         0.65         0.66  ...       0.00   \n",
+       "4         0.04         0.48         0.36         0.20  ...       0.00   \n",
+       "\n",
+       "   PctForeignBorn  PctBornSameState  PctSameHouse85  PctSameCity85  \\\n",
+       "0            0.09              0.62            0.33           0.36   \n",
+       "1            0.19              0.66            0.30           0.57   \n",
+       "2            0.03              0.67            0.76           0.77   \n",
+       "3            0.35              0.48            0.66           0.53   \n",
+       "4            0.13              0.22            0.20           0.00   \n",
+       "\n",
+       "   PctSameState85  LandArea  PopDens  PctUsePubTrans  LemasPctOfficDrugUn  \n",
+       "0            0.36      0.34     0.07            0.27                  1.0  \n",
+       "1            0.78      0.01     0.26            0.02                  0.0  \n",
+       "2            0.71      0.02     0.15            0.02                  0.0  \n",
+       "3            0.57      0.01     0.48            0.82                  0.0  \n",
+       "4            0.00      0.07     0.07            0.01                  0.0  \n",
+       "\n",
+       "[5 rows x 101 columns]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "train['X'].head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Dataset preprocessing**\n",
+    "\n",
+    "The 'us_crime' dataset that we will use in this notebook is a processed version that contains 1594 records and 102 attributes, including the protected attribute that we will use in the attack. This protected attribute is a binary attribute that indicates whether the individual is white or non-white."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_data = train['X'].copy()\n",
+    "train_data['group_a'] = train['group_a'].astype(int)\n",
+    "\n",
+    "test_data = test['X'].copy()\n",
+    "test_data['group_a'] = test['group_a'].astype(int)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_train = train_data.values\n",
+    "x_test = test_data.values\n",
+    "\n",
+    "y_train = train['y'].values\n",
+    "y_test = test['y'].values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "attack_feature = 101 # last column represents the sensitive attribute"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Attribute inference attack - baseline**\n",
+    "\n",
+    "Now, we will perform a baseline attack to infer the selected attribute using the `AttributeInferenceBaseline` class from the `holisticai` library. This class, creates an object that uses an internal model to perform the attack. The internal model is trained on the same dataset used to train the target model to learn the attacked feature from the remaining features. The attack is performed by querying the internal model with the target model's predictions and the target model's input data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "attack = AttributeInferenceBaseline(attack_feature=attack_feature)\n",
+    "\n",
+    "attack.fit(x_train)\n",
+    "\n",
+    "attack_x_test = np.delete(x_test, attack_feature, axis=1)\n",
+    "feat_true = x_test[:, attack_feature]\n",
+    "\n",
+    "values = [0, 1]\n",
+    "feat_pred = attack.infer(attack_x_test, values=values)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Measuring the attack success**\n",
+    "\n",
+    "The success of the attack is measured by the accuracy of the inferred attribute. The accuracy is calculated as the ratio of the correctly inferred attributes to the total number of data records. This can be done by using traditional classification metrics such as accuracy, precision, recall, and F1-score. For our case, we will use the `classification_efficacy_metrics` function from the `holisticai` library to calculate these metrics."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Value</th>\n",
+       "      <th>Reference</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Metric</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Accuracy</th>\n",
+       "      <td>0.977444</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Balanced Accuracy</th>\n",
+       "      <td>0.945575</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Precision</th>\n",
+       "      <td>0.982456</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Recall</th>\n",
+       "      <td>0.991150</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>F1-Score</th>\n",
+       "      <td>0.986784</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                      Value  Reference\n",
+       "Metric                                \n",
+       "Accuracy           0.977444          1\n",
+       "Balanced Accuracy  0.945575          1\n",
+       "Precision          0.982456          1\n",
+       "Recall             0.991150          1\n",
+       "F1-Score           0.986784          1"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from holisticai.efficacy.metrics import classification_efficacy_metrics\n",
+    "\n",
+    "classification_efficacy_metrics(feat_true, feat_pred)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As we can see, our attack achieved an accuracy of 0.977, which means that the attack was able to infer the 'group_a' attribute with an accuracy of 97.7%. This high accuracy indicates that the target model is leaking information about the 'group_a' attribute, which can be a privacy concern."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "testing",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/tutorials/security/attribute_inference_attacks/regression/black_box.ipynb b/tutorials/security/attribute_inference_attacks/regression/black_box.ipynb
new file mode 100644
index 00000000..1511c581
--- /dev/null
+++ b/tutorials/security/attribute_inference_attacks/regression/black_box.ipynb
@@ -0,0 +1,668 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# **Attribute inference attack with the BlackBox module**\n",
+    "\n",
+    "In this notebook, we will demonstrate how to perform an attribute inference attack with the BlackBox module. The goal of an attribute inference attack is to infer the value of a sensitive attribute of a data record by querying a model trained on the data. In this case, we will work with the 'us_crime' dataset, which contains information about crime rates in the United States, and we will consider the 'race' attribute to perform the attack.\n",
+    "\n",
+    "### **Importing the necessary libraries and loading the data** "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from holisticai.security.attackers.attribute_inference.dataset_utils import AttackDataset\n",
+    "from holisticai.security.attackers.attribute_inference.wrappers.regression.scikitlearn import ScikitlearnRegressor\n",
+    "from holisticai.datasets import load_dataset\n",
+    "from holisticai.security.attackers.attribute_inference.black_box import AttributeInferenceBlackBox"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "    <style>\n",
+       "        @import url('https://fonts.googleapis.com/css2?family=Montserrat:ital,wght@0,100..900;1,100..900&display=swap');\n",
+       "\n",
+       "/* Light blue theme (default) */\n",
+       ".generic-object-container.blue {\n",
+       "    background-color: rgba(242, 248, 253, 0.9) !important; /* Light blue with 70% opacity */\n",
+       "    border-color: #4db6ac !important; /* Soft blue border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.blue {\n",
+       "    background-color: rgba(152, 171, 202, 0.4) !important; /* Darker blue with 60% opacity */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.blue:hover {\n",
+       "    background-color: rgba(139, 177, 192, 0.8) !important; /* Darker blue on hover with 60% opacity */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.blue:hover {\n",
+       "    background-color: rgba(178, 223, 219, 0.8) !important; /* Attribute hover background with 60% opacity */\n",
+       "}\n",
+       "\n",
+       "/* Orange theme */\n",
+       ".generic-object-container.orange {\n",
+       "    background-color: #fff9ef !important; /* Container background: light orange */\n",
+       "    border-color: #ffb74d !important; /* Soft orange border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.orange {\n",
+       "    background-color: #ffe0b2 !important; /* Header background: darker orange */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.orange:hover {\n",
+       "    background-color: #ffcc80 !important; /* Darker shade on hover over the header */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.orange:hover {\n",
+       "    background-color: #ffe0b2 !important; /* Attribute background on hover: darker orange */\n",
+       "}\n",
+       "\n",
+       "/* Green theme */\n",
+       ".generic-object-container.green {\n",
+       "    background-color: #f6fff6 !important; /* Container background: light green */\n",
+       "    border-color: #81c784 !important; /* Soft green border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.green {\n",
+       "    background-color: #c8e6c9 !important; /* Header background: darker green */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.green:hover {\n",
+       "    background-color: #a5d6a7 !important; /* Darker shade on hover over the header */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.green:hover {\n",
+       "    background-color: #c8e6c9 !important; /* Attribute background on hover: darker green */\n",
+       "}\n",
+       "\n",
+       "/* Align the first container to the left */\n",
+       ".generic-object-container.first-level {\n",
+       "    margin: 0;\n",
+       "    width: auto;\n",
+       "    max-width: 800px;\n",
+       "    display: block;\n",
+       "    box-sizing: border-box;\n",
+       "}\n",
+       "\n",
+       "/* Nested containers stay centered */\n",
+       ".generic-object-container .generic-object-container {\n",
+       "    margin: 5px auto;\n",
+       "    width: 100%;\n",
+       "    display: block;\n",
+       "    padding: 5px 0;\n",
+       "}\n",
+       "\n",
+       "/* Remove default background color so only themes apply it */\n",
+       ".generic-object-container {\n",
+       "    padding: 0;\n",
+       "    margin: 0 auto;\n",
+       "    border: 0px dashed;\n",
+       "    border-radius: 5px;\n",
+       "    display: block;\n",
+       "    width: auto;\n",
+       "    max-width: 800px;\n",
+       "    box-sizing: border-box;\n",
+       "    margin-bottom: 15px;\n",
+       "    transition: transform 0.2s, box-shadow 0.2s;\n",
+       "    box-shadow: 0px 2px 5px rgba(77, 182, 172, 0.3);\n",
+       "}\n",
+       "\n",
+       ".generic-object-container:hover {\n",
+       "    box-shadow: 0px 8px 20px rgba(77, 182, 172, 0.3);\n",
+       "}\n",
+       "\n",
+       ".generic-object-header {\n",
+       "    font-family: 'Montserrat', Arial, sans-serif;\n",
+       "    font-size: 14px;\n",
+       "    padding: 10px 20px;\n",
+       "    padding-left: 40px;\n",
+       "    text-align: center;\n",
+       "    font-weight: bold;\n",
+       "    cursor: pointer;\n",
+       "    display: flex;\n",
+       "    align-items: center;\n",
+       "    justify-content: center;\n",
+       "    position: relative;\n",
+       "    width: 100%;\n",
+       "    box-sizing: border-box;\n",
+       "    border-radius: 5px;\n",
+       "    transition: background-color 0.3s;\n",
+       "}\n",
+       "\n",
+       ".toggle-button {\n",
+       "    margin-right: 10px;\n",
+       "    background: none;\n",
+       "    border: none;\n",
+       "    font-size: 13px;\n",
+       "    cursor: pointer;\n",
+       "    position: absolute;\n",
+       "    left: 10px;\n",
+       "    color: #004d40;\n",
+       "}\n",
+       "\n",
+       ".generic-object-body {\n",
+       "    padding: 5px 10px;\n",
+       "    display: block;\n",
+       "    border-radius: 0 0 5px 5px;\n",
+       "    background-color: inherit;\n",
+       "    margin: 0 auto;\n",
+       "}\n",
+       "\n",
+       ".hidden {\n",
+       "    display: none;\n",
+       "}\n",
+       "\n",
+       ".attribute-list {\n",
+       "    margin: 2px 0;\n",
+       "    padding: 2px;\n",
+       "    transition: background-color 0.2s;\n",
+       "    display: block;\n",
+       "}\n",
+       "\n",
+       ".flex-space-filler {\n",
+       "    display: flex;\n",
+       "    justify-content: center;\n",
+       "    align-items: center;\n",
+       "}\n",
+       "\n",
+       ".generic-object-container,\n",
+       ".generic-object-header,\n",
+       ".attribute-list {\n",
+       "    color: #000000 !important; /* Establece el color del texto a negro */\n",
+       "}\n",
+       "    </style>\n",
+       "    <div style=\"display: flex;\">\n",
+       "    <div class=\"generic-object-container blue first-level\">\n",
+       "        <div class=\"generic-object-content\">\n",
+       "            <div class=\"generic-object-header blue\" onclick=\"toggleCollapse(this)\">\n",
+       "                <button class=\"toggle-button blue\">[-]</button> [Dataset]\n",
+       "            </div>\n",
+       "            <div class=\"generic-object-body\">\n",
+       "                <div class=\"attribute-list blue\"><strong>Instances</strong>: 1594</div><div class=\"attribute-list blue\"><strong>Features</strong>: X , y , p_attrs , group_a , group_b</div><div class=\"attribute-list blue\"><strong>Metadata</strong>: race: {'group_a': 'racePctWhite>0.5', 'group_b': 'racePctWhite<=0.5'}</div>\n",
+       "                \n",
+       "            </div>\n",
+       "        </div>\n",
+       "    </div>\n",
+       "</div>\n",
+       "    <script>\n",
+       "    function toggleCollapse(element) {\n",
+       "        var body = element.nextElementSibling;\n",
+       "        var button = element.querySelector(\".toggle-button\");\n",
+       "        if (body.classList.contains('hidden')) {\n",
+       "            body.classList.remove('hidden');\n",
+       "            button.textContent = \"[-]\";\n",
+       "        } else {\n",
+       "            body.classList.add('hidden');\n",
+       "            button.textContent = \"[+]\";\n",
+       "        }\n",
+       "    }\n",
+       "    </script>\n",
+       "    "
+      ],
+      "text/plain": [
+       "{\"dtype\":\"Dataset\",\"attributes\":{\"Instances\":1594,\"Features\":[\"X , y , p_attrs , group_a , group_b\"]},\"metadata\":\"race: {'group_a': 'racePctWhite>0.5', 'group_b': 'racePctWhite<=0.5'}\"}"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dataset = load_dataset('us_crime', preprocessed=True, protected_attribute='race')\n",
+    "train_test = dataset.train_test_split(test_size=0.2, random_state=0)\n",
+    "train = train_test['train']\n",
+    "test = train_test['test']\n",
+    "train"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>state</th>\n",
+       "      <th>fold</th>\n",
+       "      <th>population</th>\n",
+       "      <th>householdsize</th>\n",
+       "      <th>racepctblack</th>\n",
+       "      <th>racePctAsian</th>\n",
+       "      <th>racePctHisp</th>\n",
+       "      <th>agePct12t21</th>\n",
+       "      <th>agePct12t29</th>\n",
+       "      <th>agePct16t24</th>\n",
+       "      <th>...</th>\n",
+       "      <th>NumStreet</th>\n",
+       "      <th>PctForeignBorn</th>\n",
+       "      <th>PctBornSameState</th>\n",
+       "      <th>PctSameHouse85</th>\n",
+       "      <th>PctSameCity85</th>\n",
+       "      <th>PctSameState85</th>\n",
+       "      <th>LandArea</th>\n",
+       "      <th>PopDens</th>\n",
+       "      <th>PctUsePubTrans</th>\n",
+       "      <th>LemasPctOfficDrugUn</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>45</td>\n",
+       "      <td>8</td>\n",
+       "      <td>0.14</td>\n",
+       "      <td>0.56</td>\n",
+       "      <td>0.85</td>\n",
+       "      <td>0.09</td>\n",
+       "      <td>0.03</td>\n",
+       "      <td>0.76</td>\n",
+       "      <td>0.83</td>\n",
+       "      <td>0.77</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.09</td>\n",
+       "      <td>0.09</td>\n",
+       "      <td>0.62</td>\n",
+       "      <td>0.33</td>\n",
+       "      <td>0.36</td>\n",
+       "      <td>0.36</td>\n",
+       "      <td>0.34</td>\n",
+       "      <td>0.07</td>\n",
+       "      <td>0.27</td>\n",
+       "      <td>1.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>6</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.40</td>\n",
+       "      <td>0.02</td>\n",
+       "      <td>0.11</td>\n",
+       "      <td>0.22</td>\n",
+       "      <td>0.39</td>\n",
+       "      <td>0.42</td>\n",
+       "      <td>0.25</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.19</td>\n",
+       "      <td>0.66</td>\n",
+       "      <td>0.30</td>\n",
+       "      <td>0.57</td>\n",
+       "      <td>0.78</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.26</td>\n",
+       "      <td>0.02</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>55</td>\n",
+       "      <td>5</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.33</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.36</td>\n",
+       "      <td>0.40</td>\n",
+       "      <td>0.24</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.03</td>\n",
+       "      <td>0.67</td>\n",
+       "      <td>0.76</td>\n",
+       "      <td>0.77</td>\n",
+       "      <td>0.71</td>\n",
+       "      <td>0.02</td>\n",
+       "      <td>0.15</td>\n",
+       "      <td>0.02</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>34</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.71</td>\n",
+       "      <td>0.36</td>\n",
+       "      <td>0.21</td>\n",
+       "      <td>0.06</td>\n",
+       "      <td>0.77</td>\n",
+       "      <td>0.65</td>\n",
+       "      <td>0.66</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.35</td>\n",
+       "      <td>0.48</td>\n",
+       "      <td>0.66</td>\n",
+       "      <td>0.53</td>\n",
+       "      <td>0.57</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.48</td>\n",
+       "      <td>0.82</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>13</td>\n",
+       "      <td>8</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.65</td>\n",
+       "      <td>0.08</td>\n",
+       "      <td>0.20</td>\n",
+       "      <td>0.04</td>\n",
+       "      <td>0.48</td>\n",
+       "      <td>0.36</td>\n",
+       "      <td>0.20</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.13</td>\n",
+       "      <td>0.22</td>\n",
+       "      <td>0.20</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.07</td>\n",
+       "      <td>0.07</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>5 rows × 101 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   state  fold  population  householdsize  racepctblack  racePctAsian  \\\n",
+       "0     45     8        0.14           0.56          0.85          0.09   \n",
+       "1      6     2        0.01           0.40          0.02          0.11   \n",
+       "2     55     5        0.00           0.33          0.00          0.01   \n",
+       "3     34     3        0.01           0.71          0.36          0.21   \n",
+       "4     13     8        0.01           0.65          0.08          0.20   \n",
+       "\n",
+       "   racePctHisp  agePct12t21  agePct12t29  agePct16t24  ...  NumStreet  \\\n",
+       "0         0.03         0.76         0.83         0.77  ...       0.09   \n",
+       "1         0.22         0.39         0.42         0.25  ...       0.01   \n",
+       "2         0.01         0.36         0.40         0.24  ...       0.00   \n",
+       "3         0.06         0.77         0.65         0.66  ...       0.00   \n",
+       "4         0.04         0.48         0.36         0.20  ...       0.00   \n",
+       "\n",
+       "   PctForeignBorn  PctBornSameState  PctSameHouse85  PctSameCity85  \\\n",
+       "0            0.09              0.62            0.33           0.36   \n",
+       "1            0.19              0.66            0.30           0.57   \n",
+       "2            0.03              0.67            0.76           0.77   \n",
+       "3            0.35              0.48            0.66           0.53   \n",
+       "4            0.13              0.22            0.20           0.00   \n",
+       "\n",
+       "   PctSameState85  LandArea  PopDens  PctUsePubTrans  LemasPctOfficDrugUn  \n",
+       "0            0.36      0.34     0.07            0.27                  1.0  \n",
+       "1            0.78      0.01     0.26            0.02                  0.0  \n",
+       "2            0.71      0.02     0.15            0.02                  0.0  \n",
+       "3            0.57      0.01     0.48            0.82                  0.0  \n",
+       "4            0.00      0.07     0.07            0.01                  0.0  \n",
+       "\n",
+       "[5 rows x 101 columns]"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "train['X'].head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Dataset preprocessing**\n",
+    "\n",
+    "The 'us_crime' dataset that we will use in this notebook is a processed version that contains 1594 records and 102 attributes, including the protected attribute that we will use in the attack. This protected attribute is a binary attribute that indicates whether the individual is white or non-white."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_data = train['X'].copy()\n",
+    "train_data['group_a'] = train['group_a'].astype(int)\n",
+    "\n",
+    "test_data = test['X'].copy()\n",
+    "test_data['group_a'] = test['group_a'].astype(int)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_train = train_data.values\n",
+    "x_test = test_data.values\n",
+    "\n",
+    "y_train = train['y'].values\n",
+    "y_test = test['y'].values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "attack_feature = 101 # last column represents the sensitive attribute"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Attribute inference attack - blackbox**\n",
+    "\n",
+    "Now, we will perform a attack to infer the selected attribute using the `AttributeInferenceBlackBox` class from the `holisticai` library. This class, creates an object that uses an internal model to perform the attack. The internal model is trained on the same dataset used to train the target model to learn the attacked feature from the remaining features. This module assumes the availability of the attacked model's predictions for the samples under attack, in addition to the rest of the feature values. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from holisticai.pipeline import Pipeline\n",
+    "from sklearn.tree import DecisionTreeRegressor\n",
+    "\n",
+    "regressor = Pipeline(steps=[\n",
+    "    ('model', DecisionTreeRegressor())\n",
+    "])\n",
+    "\n",
+    "regressor.fit(x_train, y_train)\n",
+    "\n",
+    "# regressor = train_holisticai_regressor(x_train, y_train)\n",
+    "regressor = ScikitlearnRegressor(regressor)\n",
+    "\n",
+    "attack = AttributeInferenceBlackBox(estimator=regressor, attack_feature=attack_feature, scale_range=(0,1))\n",
+    "\n",
+    "pred = regressor.predict(x_train)\n",
+    "\n",
+    "attack.fit(x_train, y_train, pred)\n",
+    "\n",
+    "attack_x_test = np.delete(x_test, attack_feature, axis=1)\n",
+    "\n",
+    "pred = regressor.predict(x_test)\n",
+    "\n",
+    "feat_true = x_test[:, attack_feature]\n",
+    "\n",
+    "values = [False, True]\n",
+    "feat_pred = attack.infer(attack_x_test, y_test, pred, values=values)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Measuring the attack success**\n",
+    "\n",
+    "The success of the attack is measured by the accuracy of the inferred attribute. The accuracy is calculated as the ratio of the correctly inferred attributes to the total number of data records. This can be done by using traditional classification metrics such as accuracy, precision, recall, and F1-score. For our case, we will use the `classification_efficacy_metrics` function from the `holisticai` library to calculate these metrics."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Value</th>\n",
+       "      <th>Reference</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Metric</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Accuracy</th>\n",
+       "      <td>0.969925</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Balanced Accuracy</th>\n",
+       "      <td>0.927434</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Precision</th>\n",
+       "      <td>0.976676</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Recall</th>\n",
+       "      <td>0.988201</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>F1-Score</th>\n",
+       "      <td>0.982405</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                      Value  Reference\n",
+       "Metric                                \n",
+       "Accuracy           0.969925          1\n",
+       "Balanced Accuracy  0.927434          1\n",
+       "Precision          0.976676          1\n",
+       "Recall             0.988201          1\n",
+       "F1-Score           0.982405          1"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from holisticai.efficacy.metrics import classification_efficacy_metrics\n",
+    "\n",
+    "classification_efficacy_metrics(feat_true, feat_pred)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As we can see, our attack achieved an accuracy of 0.969, which means that the attack was able to infer the 'group_a' attribute with an accuracy of 96.9%, which is a high accuracy. This demonstrates the vulnerability of the model to attribute inference attacks and the importance of protecting sensitive attributes in the data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "testing",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/tutorials/security/attribute_inference_attacks/regression/true_label.ipynb b/tutorials/security/attribute_inference_attacks/regression/true_label.ipynb
new file mode 100644
index 00000000..0869d352
--- /dev/null
+++ b/tutorials/security/attribute_inference_attacks/regression/true_label.ipynb
@@ -0,0 +1,652 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# **Attribute inference attack with the TrueLabel module**\n",
+    "\n",
+    "In this notebook, we will demonstrate how to perform an attribute inference attack with the TrueLabel module. The goal of an attribute inference attack is to infer the value of a sensitive attribute of a data record by querying a model trained on the data. In this case, we will work with the 'us_crime' dataset, which contains information about crime rates in the United States, and we will consider the 'race' attribute to perform the attack.\n",
+    "\n",
+    "### **Importing the necessary libraries and loading the data** "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from holisticai.security.attackers.attribute_inference.dataset_utils import AttackDataset\n",
+    "from holisticai.security.attackers.attribute_inference.wrappers.regression.scikitlearn import ScikitlearnRegressor\n",
+    "from holisticai.datasets import load_dataset\n",
+    "from holisticai.security.attackers.attribute_inference.true_label_baseline import AttributeInferenceBaselineTrueLabel"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "    <style>\n",
+       "        @import url('https://fonts.googleapis.com/css2?family=Montserrat:ital,wght@0,100..900;1,100..900&display=swap');\n",
+       "\n",
+       "/* Light blue theme (default) */\n",
+       ".generic-object-container.blue {\n",
+       "    background-color: rgba(242, 248, 253, 0.9) !important; /* Light blue with 70% opacity */\n",
+       "    border-color: #4db6ac !important; /* Soft blue border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.blue {\n",
+       "    background-color: rgba(152, 171, 202, 0.4) !important; /* Darker blue with 60% opacity */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.blue:hover {\n",
+       "    background-color: rgba(139, 177, 192, 0.8) !important; /* Darker blue on hover with 60% opacity */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.blue:hover {\n",
+       "    background-color: rgba(178, 223, 219, 0.8) !important; /* Attribute hover background with 60% opacity */\n",
+       "}\n",
+       "\n",
+       "/* Orange theme */\n",
+       ".generic-object-container.orange {\n",
+       "    background-color: #fff9ef !important; /* Container background: light orange */\n",
+       "    border-color: #ffb74d !important; /* Soft orange border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.orange {\n",
+       "    background-color: #ffe0b2 !important; /* Header background: darker orange */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.orange:hover {\n",
+       "    background-color: #ffcc80 !important; /* Darker shade on hover over the header */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.orange:hover {\n",
+       "    background-color: #ffe0b2 !important; /* Attribute background on hover: darker orange */\n",
+       "}\n",
+       "\n",
+       "/* Green theme */\n",
+       ".generic-object-container.green {\n",
+       "    background-color: #f6fff6 !important; /* Container background: light green */\n",
+       "    border-color: #81c784 !important; /* Soft green border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.green {\n",
+       "    background-color: #c8e6c9 !important; /* Header background: darker green */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.green:hover {\n",
+       "    background-color: #a5d6a7 !important; /* Darker shade on hover over the header */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.green:hover {\n",
+       "    background-color: #c8e6c9 !important; /* Attribute background on hover: darker green */\n",
+       "}\n",
+       "\n",
+       "/* Align the first container to the left */\n",
+       ".generic-object-container.first-level {\n",
+       "    margin: 0;\n",
+       "    width: auto;\n",
+       "    max-width: 800px;\n",
+       "    display: block;\n",
+       "    box-sizing: border-box;\n",
+       "}\n",
+       "\n",
+       "/* Nested containers stay centered */\n",
+       ".generic-object-container .generic-object-container {\n",
+       "    margin: 5px auto;\n",
+       "    width: 100%;\n",
+       "    display: block;\n",
+       "    padding: 5px 0;\n",
+       "}\n",
+       "\n",
+       "/* Remove default background color so only themes apply it */\n",
+       ".generic-object-container {\n",
+       "    padding: 0;\n",
+       "    margin: 0 auto;\n",
+       "    border: 0px dashed;\n",
+       "    border-radius: 5px;\n",
+       "    display: block;\n",
+       "    width: auto;\n",
+       "    max-width: 800px;\n",
+       "    box-sizing: border-box;\n",
+       "    margin-bottom: 15px;\n",
+       "    transition: transform 0.2s, box-shadow 0.2s;\n",
+       "    box-shadow: 0px 2px 5px rgba(77, 182, 172, 0.3);\n",
+       "}\n",
+       "\n",
+       ".generic-object-container:hover {\n",
+       "    box-shadow: 0px 8px 20px rgba(77, 182, 172, 0.3);\n",
+       "}\n",
+       "\n",
+       ".generic-object-header {\n",
+       "    font-family: 'Montserrat', Arial, sans-serif;\n",
+       "    font-size: 14px;\n",
+       "    padding: 10px 20px;\n",
+       "    padding-left: 40px;\n",
+       "    text-align: center;\n",
+       "    font-weight: bold;\n",
+       "    cursor: pointer;\n",
+       "    display: flex;\n",
+       "    align-items: center;\n",
+       "    justify-content: center;\n",
+       "    position: relative;\n",
+       "    width: 100%;\n",
+       "    box-sizing: border-box;\n",
+       "    border-radius: 5px;\n",
+       "    transition: background-color 0.3s;\n",
+       "}\n",
+       "\n",
+       ".toggle-button {\n",
+       "    margin-right: 10px;\n",
+       "    background: none;\n",
+       "    border: none;\n",
+       "    font-size: 13px;\n",
+       "    cursor: pointer;\n",
+       "    position: absolute;\n",
+       "    left: 10px;\n",
+       "    color: #004d40;\n",
+       "}\n",
+       "\n",
+       ".generic-object-body {\n",
+       "    padding: 5px 10px;\n",
+       "    display: block;\n",
+       "    border-radius: 0 0 5px 5px;\n",
+       "    background-color: inherit;\n",
+       "    margin: 0 auto;\n",
+       "}\n",
+       "\n",
+       ".hidden {\n",
+       "    display: none;\n",
+       "}\n",
+       "\n",
+       ".attribute-list {\n",
+       "    margin: 2px 0;\n",
+       "    padding: 2px;\n",
+       "    transition: background-color 0.2s;\n",
+       "    display: block;\n",
+       "}\n",
+       "\n",
+       ".flex-space-filler {\n",
+       "    display: flex;\n",
+       "    justify-content: center;\n",
+       "    align-items: center;\n",
+       "}\n",
+       "\n",
+       ".generic-object-container,\n",
+       ".generic-object-header,\n",
+       ".attribute-list {\n",
+       "    color: #000000 !important; /* Establece el color del texto a negro */\n",
+       "}\n",
+       "    </style>\n",
+       "    <div style=\"display: flex;\">\n",
+       "    <div class=\"generic-object-container blue first-level\">\n",
+       "        <div class=\"generic-object-content\">\n",
+       "            <div class=\"generic-object-header blue\" onclick=\"toggleCollapse(this)\">\n",
+       "                <button class=\"toggle-button blue\">[-]</button> [Dataset]\n",
+       "            </div>\n",
+       "            <div class=\"generic-object-body\">\n",
+       "                <div class=\"attribute-list blue\"><strong>Instances</strong>: 1594</div><div class=\"attribute-list blue\"><strong>Features</strong>: X , y , p_attrs , group_a , group_b</div><div class=\"attribute-list blue\"><strong>Metadata</strong>: race: {'group_a': 'racePctWhite>0.5', 'group_b': 'racePctWhite<=0.5'}</div>\n",
+       "                \n",
+       "            </div>\n",
+       "        </div>\n",
+       "    </div>\n",
+       "</div>\n",
+       "    <script>\n",
+       "    function toggleCollapse(element) {\n",
+       "        var body = element.nextElementSibling;\n",
+       "        var button = element.querySelector(\".toggle-button\");\n",
+       "        if (body.classList.contains('hidden')) {\n",
+       "            body.classList.remove('hidden');\n",
+       "            button.textContent = \"[-]\";\n",
+       "        } else {\n",
+       "            body.classList.add('hidden');\n",
+       "            button.textContent = \"[+]\";\n",
+       "        }\n",
+       "    }\n",
+       "    </script>\n",
+       "    "
+      ],
+      "text/plain": [
+       "{\"dtype\":\"Dataset\",\"attributes\":{\"Instances\":1594,\"Features\":[\"X , y , p_attrs , group_a , group_b\"]},\"metadata\":\"race: {'group_a': 'racePctWhite>0.5', 'group_b': 'racePctWhite<=0.5'}\"}"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dataset = load_dataset('us_crime', preprocessed=True, protected_attribute='race')\n",
+    "train_test = dataset.train_test_split(test_size=0.2, random_state=0)\n",
+    "train = train_test['train']\n",
+    "test = train_test['test']\n",
+    "train"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>state</th>\n",
+       "      <th>fold</th>\n",
+       "      <th>population</th>\n",
+       "      <th>householdsize</th>\n",
+       "      <th>racepctblack</th>\n",
+       "      <th>racePctAsian</th>\n",
+       "      <th>racePctHisp</th>\n",
+       "      <th>agePct12t21</th>\n",
+       "      <th>agePct12t29</th>\n",
+       "      <th>agePct16t24</th>\n",
+       "      <th>...</th>\n",
+       "      <th>NumStreet</th>\n",
+       "      <th>PctForeignBorn</th>\n",
+       "      <th>PctBornSameState</th>\n",
+       "      <th>PctSameHouse85</th>\n",
+       "      <th>PctSameCity85</th>\n",
+       "      <th>PctSameState85</th>\n",
+       "      <th>LandArea</th>\n",
+       "      <th>PopDens</th>\n",
+       "      <th>PctUsePubTrans</th>\n",
+       "      <th>LemasPctOfficDrugUn</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>45</td>\n",
+       "      <td>8</td>\n",
+       "      <td>0.14</td>\n",
+       "      <td>0.56</td>\n",
+       "      <td>0.85</td>\n",
+       "      <td>0.09</td>\n",
+       "      <td>0.03</td>\n",
+       "      <td>0.76</td>\n",
+       "      <td>0.83</td>\n",
+       "      <td>0.77</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.09</td>\n",
+       "      <td>0.09</td>\n",
+       "      <td>0.62</td>\n",
+       "      <td>0.33</td>\n",
+       "      <td>0.36</td>\n",
+       "      <td>0.36</td>\n",
+       "      <td>0.34</td>\n",
+       "      <td>0.07</td>\n",
+       "      <td>0.27</td>\n",
+       "      <td>1.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>6</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.40</td>\n",
+       "      <td>0.02</td>\n",
+       "      <td>0.11</td>\n",
+       "      <td>0.22</td>\n",
+       "      <td>0.39</td>\n",
+       "      <td>0.42</td>\n",
+       "      <td>0.25</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.19</td>\n",
+       "      <td>0.66</td>\n",
+       "      <td>0.30</td>\n",
+       "      <td>0.57</td>\n",
+       "      <td>0.78</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.26</td>\n",
+       "      <td>0.02</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>55</td>\n",
+       "      <td>5</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.33</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.36</td>\n",
+       "      <td>0.40</td>\n",
+       "      <td>0.24</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.03</td>\n",
+       "      <td>0.67</td>\n",
+       "      <td>0.76</td>\n",
+       "      <td>0.77</td>\n",
+       "      <td>0.71</td>\n",
+       "      <td>0.02</td>\n",
+       "      <td>0.15</td>\n",
+       "      <td>0.02</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>34</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.71</td>\n",
+       "      <td>0.36</td>\n",
+       "      <td>0.21</td>\n",
+       "      <td>0.06</td>\n",
+       "      <td>0.77</td>\n",
+       "      <td>0.65</td>\n",
+       "      <td>0.66</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.35</td>\n",
+       "      <td>0.48</td>\n",
+       "      <td>0.66</td>\n",
+       "      <td>0.53</td>\n",
+       "      <td>0.57</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.48</td>\n",
+       "      <td>0.82</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>13</td>\n",
+       "      <td>8</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.65</td>\n",
+       "      <td>0.08</td>\n",
+       "      <td>0.20</td>\n",
+       "      <td>0.04</td>\n",
+       "      <td>0.48</td>\n",
+       "      <td>0.36</td>\n",
+       "      <td>0.20</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.13</td>\n",
+       "      <td>0.22</td>\n",
+       "      <td>0.20</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.07</td>\n",
+       "      <td>0.07</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>5 rows × 101 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   state  fold  population  householdsize  racepctblack  racePctAsian  \\\n",
+       "0     45     8        0.14           0.56          0.85          0.09   \n",
+       "1      6     2        0.01           0.40          0.02          0.11   \n",
+       "2     55     5        0.00           0.33          0.00          0.01   \n",
+       "3     34     3        0.01           0.71          0.36          0.21   \n",
+       "4     13     8        0.01           0.65          0.08          0.20   \n",
+       "\n",
+       "   racePctHisp  agePct12t21  agePct12t29  agePct16t24  ...  NumStreet  \\\n",
+       "0         0.03         0.76         0.83         0.77  ...       0.09   \n",
+       "1         0.22         0.39         0.42         0.25  ...       0.01   \n",
+       "2         0.01         0.36         0.40         0.24  ...       0.00   \n",
+       "3         0.06         0.77         0.65         0.66  ...       0.00   \n",
+       "4         0.04         0.48         0.36         0.20  ...       0.00   \n",
+       "\n",
+       "   PctForeignBorn  PctBornSameState  PctSameHouse85  PctSameCity85  \\\n",
+       "0            0.09              0.62            0.33           0.36   \n",
+       "1            0.19              0.66            0.30           0.57   \n",
+       "2            0.03              0.67            0.76           0.77   \n",
+       "3            0.35              0.48            0.66           0.53   \n",
+       "4            0.13              0.22            0.20           0.00   \n",
+       "\n",
+       "   PctSameState85  LandArea  PopDens  PctUsePubTrans  LemasPctOfficDrugUn  \n",
+       "0            0.36      0.34     0.07            0.27                  1.0  \n",
+       "1            0.78      0.01     0.26            0.02                  0.0  \n",
+       "2            0.71      0.02     0.15            0.02                  0.0  \n",
+       "3            0.57      0.01     0.48            0.82                  0.0  \n",
+       "4            0.00      0.07     0.07            0.01                  0.0  \n",
+       "\n",
+       "[5 rows x 101 columns]"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "train['X'].head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Dataset preprocessing**\n",
+    "\n",
+    "The 'us_crime' dataset that we will use in this notebook is a processed version that contains 1594 records and 102 attributes, including the protected attribute that we will use in the attack. This protected attribute is a binary attribute that indicates whether the individual is white or non-white."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_data = train['X'].copy()\n",
+    "train_data['group_a'] = train['group_a'].astype(int)\n",
+    "\n",
+    "test_data = test['X'].copy()\n",
+    "test_data['group_a'] = test['group_a'].astype(int)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_train = train_data.values\n",
+    "x_test = test_data.values\n",
+    "\n",
+    "y_train = train['y'].values\n",
+    "y_test = test['y'].values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "attack_feature = 101 # last column represents the sensitive attribute"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Attribute inference attack - TrueLabel**\n",
+    "\n",
+    "Now, we will perform an attack to infer the selected attribute using the `AttributeInferenceBaselineTrueLabel` class from the `holisticai` library. This class, creates an object that uses an internal model to perform the attack. The internal model is trained on the same dataset used to train the target model to learn the attacked feature from the remaining features. The attack is performed by querying the internal model with the target model's predictions and the target model's input data. This module works similar to the baseline module, but requires the target model's input data to be provided."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "attack = AttributeInferenceBaselineTrueLabel(attack_feature=attack_feature, is_regression=True)\n",
+    "\n",
+    "attack.fit(x_train, y_train)\n",
+    "\n",
+    "attack_x_test = np.delete(x_test, attack_feature, axis=1)\n",
+    "\n",
+    "feat_true = x_test[:, attack_feature]\n",
+    "\n",
+    "values = [0, 1]\n",
+    "feat_pred = attack.infer(attack_x_test, y_test, values=values)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Measuring the attack success**\n",
+    "\n",
+    "The success of the attack is measured by the accuracy of the inferred attribute. The accuracy is calculated as the ratio of the correctly inferred attributes to the total number of data records. This can be done by using traditional classification metrics such as accuracy, precision, recall, and F1-score. For our case, we will use the `classification_efficacy_metrics` function from the `holisticai` library to calculate these metrics."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Value</th>\n",
+       "      <th>Reference</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Metric</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Accuracy</th>\n",
+       "      <td>0.977444</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Balanced Accuracy</th>\n",
+       "      <td>0.952434</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Precision</th>\n",
+       "      <td>0.985294</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Recall</th>\n",
+       "      <td>0.988201</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>F1-Score</th>\n",
+       "      <td>0.986745</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                      Value  Reference\n",
+       "Metric                                \n",
+       "Accuracy           0.977444          1\n",
+       "Balanced Accuracy  0.952434          1\n",
+       "Precision          0.985294          1\n",
+       "Recall             0.988201          1\n",
+       "F1-Score           0.986745          1"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from holisticai.efficacy.metrics import classification_efficacy_metrics\n",
+    "\n",
+    "classification_efficacy_metrics(feat_true, feat_pred)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As we can see, our attack achieved an accuracy of 0.977, which means that the attack was able to infer the 'group_a' attribute with an accuracy of 97.7%. This high accuracy indicates that the target model is leaking information about the 'group_a' attribute, which can be a privacy concern."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "testing",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/tutorials/security/attribute_inference_attacks/regression/white_box.ipynb b/tutorials/security/attribute_inference_attacks/regression/white_box.ipynb
new file mode 100644
index 00000000..a257285f
--- /dev/null
+++ b/tutorials/security/attribute_inference_attacks/regression/white_box.ipynb
@@ -0,0 +1,681 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# **Attribute inference attack with the WhiteBox module**\n",
+    "\n",
+    "In this notebook, we will demonstrate how to perform an attribute inference attack with the WhiteBox module. The goal of an attribute inference attack is to infer the value of a sensitive attribute of a data record by querying a model trained on the data. In this case, we will work with the 'us_crime' dataset, which contains information about crime rates in the United States, and we will consider the 'race' attribute to perform the attack.\n",
+    "\n",
+    "### **Importing the necessary libraries and loading the data** "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from holisticai.datasets import load_dataset\n",
+    "from holisticai.security.attackers.attribute_inference.wrappers.regression.scikitlearn import ScikitlearnDecisionTreeRegressor\n",
+    "from holisticai.security.attackers.attribute_inference.mitigation.attacks.white_box_lifestyle_decision_tree import (\n",
+    "    AttributeInferenceWhiteBoxLifestyleDecisionTree\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "    <style>\n",
+       "        @import url('https://fonts.googleapis.com/css2?family=Montserrat:ital,wght@0,100..900;1,100..900&display=swap');\n",
+       "\n",
+       "/* Light blue theme (default) */\n",
+       ".generic-object-container.blue {\n",
+       "    background-color: rgba(242, 248, 253, 0.9) !important; /* Light blue with 70% opacity */\n",
+       "    border-color: #4db6ac !important; /* Soft blue border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.blue {\n",
+       "    background-color: rgba(152, 171, 202, 0.4) !important; /* Darker blue with 60% opacity */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.blue:hover {\n",
+       "    background-color: rgba(139, 177, 192, 0.8) !important; /* Darker blue on hover with 60% opacity */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.blue:hover {\n",
+       "    background-color: rgba(178, 223, 219, 0.8) !important; /* Attribute hover background with 60% opacity */\n",
+       "}\n",
+       "\n",
+       "/* Orange theme */\n",
+       ".generic-object-container.orange {\n",
+       "    background-color: #fff9ef !important; /* Container background: light orange */\n",
+       "    border-color: #ffb74d !important; /* Soft orange border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.orange {\n",
+       "    background-color: #ffe0b2 !important; /* Header background: darker orange */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.orange:hover {\n",
+       "    background-color: #ffcc80 !important; /* Darker shade on hover over the header */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.orange:hover {\n",
+       "    background-color: #ffe0b2 !important; /* Attribute background on hover: darker orange */\n",
+       "}\n",
+       "\n",
+       "/* Green theme */\n",
+       ".generic-object-container.green {\n",
+       "    background-color: #f6fff6 !important; /* Container background: light green */\n",
+       "    border-color: #81c784 !important; /* Soft green border */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.green {\n",
+       "    background-color: #c8e6c9 !important; /* Header background: darker green */\n",
+       "}\n",
+       "\n",
+       ".generic-object-header.green:hover {\n",
+       "    background-color: #a5d6a7 !important; /* Darker shade on hover over the header */\n",
+       "}\n",
+       "\n",
+       ".attribute-list.green:hover {\n",
+       "    background-color: #c8e6c9 !important; /* Attribute background on hover: darker green */\n",
+       "}\n",
+       "\n",
+       "/* Align the first container to the left */\n",
+       ".generic-object-container.first-level {\n",
+       "    margin: 0;\n",
+       "    width: auto;\n",
+       "    max-width: 800px;\n",
+       "    display: block;\n",
+       "    box-sizing: border-box;\n",
+       "}\n",
+       "\n",
+       "/* Nested containers stay centered */\n",
+       ".generic-object-container .generic-object-container {\n",
+       "    margin: 5px auto;\n",
+       "    width: 100%;\n",
+       "    display: block;\n",
+       "    padding: 5px 0;\n",
+       "}\n",
+       "\n",
+       "/* Remove default background color so only themes apply it */\n",
+       ".generic-object-container {\n",
+       "    padding: 0;\n",
+       "    margin: 0 auto;\n",
+       "    border: 0px dashed;\n",
+       "    border-radius: 5px;\n",
+       "    display: block;\n",
+       "    width: auto;\n",
+       "    max-width: 800px;\n",
+       "    box-sizing: border-box;\n",
+       "    margin-bottom: 15px;\n",
+       "    transition: transform 0.2s, box-shadow 0.2s;\n",
+       "    box-shadow: 0px 2px 5px rgba(77, 182, 172, 0.3);\n",
+       "}\n",
+       "\n",
+       ".generic-object-container:hover {\n",
+       "    box-shadow: 0px 8px 20px rgba(77, 182, 172, 0.3);\n",
+       "}\n",
+       "\n",
+       ".generic-object-header {\n",
+       "    font-family: 'Montserrat', Arial, sans-serif;\n",
+       "    font-size: 14px;\n",
+       "    padding: 10px 20px;\n",
+       "    padding-left: 40px;\n",
+       "    text-align: center;\n",
+       "    font-weight: bold;\n",
+       "    cursor: pointer;\n",
+       "    display: flex;\n",
+       "    align-items: center;\n",
+       "    justify-content: center;\n",
+       "    position: relative;\n",
+       "    width: 100%;\n",
+       "    box-sizing: border-box;\n",
+       "    border-radius: 5px;\n",
+       "    transition: background-color 0.3s;\n",
+       "}\n",
+       "\n",
+       ".toggle-button {\n",
+       "    margin-right: 10px;\n",
+       "    background: none;\n",
+       "    border: none;\n",
+       "    font-size: 13px;\n",
+       "    cursor: pointer;\n",
+       "    position: absolute;\n",
+       "    left: 10px;\n",
+       "    color: #004d40;\n",
+       "}\n",
+       "\n",
+       ".generic-object-body {\n",
+       "    padding: 5px 10px;\n",
+       "    display: block;\n",
+       "    border-radius: 0 0 5px 5px;\n",
+       "    background-color: inherit;\n",
+       "    margin: 0 auto;\n",
+       "}\n",
+       "\n",
+       ".hidden {\n",
+       "    display: none;\n",
+       "}\n",
+       "\n",
+       ".attribute-list {\n",
+       "    margin: 2px 0;\n",
+       "    padding: 2px;\n",
+       "    transition: background-color 0.2s;\n",
+       "    display: block;\n",
+       "}\n",
+       "\n",
+       ".flex-space-filler {\n",
+       "    display: flex;\n",
+       "    justify-content: center;\n",
+       "    align-items: center;\n",
+       "}\n",
+       "\n",
+       ".generic-object-container,\n",
+       ".generic-object-header,\n",
+       ".attribute-list {\n",
+       "    color: #000000 !important; /* Establece el color del texto a negro */\n",
+       "}\n",
+       "    </style>\n",
+       "    <div style=\"display: flex;\">\n",
+       "    <div class=\"generic-object-container blue first-level\">\n",
+       "        <div class=\"generic-object-content\">\n",
+       "            <div class=\"generic-object-header blue\" onclick=\"toggleCollapse(this)\">\n",
+       "                <button class=\"toggle-button blue\">[-]</button> [Dataset]\n",
+       "            </div>\n",
+       "            <div class=\"generic-object-body\">\n",
+       "                <div class=\"attribute-list blue\"><strong>Instances</strong>: 1594</div><div class=\"attribute-list blue\"><strong>Features</strong>: X , y , p_attrs , group_a , group_b</div><div class=\"attribute-list blue\"><strong>Metadata</strong>: race: {'group_a': 'racePctWhite>0.5', 'group_b': 'racePctWhite<=0.5'}</div>\n",
+       "                \n",
+       "            </div>\n",
+       "        </div>\n",
+       "    </div>\n",
+       "</div>\n",
+       "    <script>\n",
+       "    function toggleCollapse(element) {\n",
+       "        var body = element.nextElementSibling;\n",
+       "        var button = element.querySelector(\".toggle-button\");\n",
+       "        if (body.classList.contains('hidden')) {\n",
+       "            body.classList.remove('hidden');\n",
+       "            button.textContent = \"[-]\";\n",
+       "        } else {\n",
+       "            body.classList.add('hidden');\n",
+       "            button.textContent = \"[+]\";\n",
+       "        }\n",
+       "    }\n",
+       "    </script>\n",
+       "    "
+      ],
+      "text/plain": [
+       "{\"dtype\":\"Dataset\",\"attributes\":{\"Instances\":1594,\"Features\":[\"X , y , p_attrs , group_a , group_b\"]},\"metadata\":\"race: {'group_a': 'racePctWhite>0.5', 'group_b': 'racePctWhite<=0.5'}\"}"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dataset = load_dataset('us_crime', preprocessed=True, protected_attribute='race')\n",
+    "train_test = dataset.train_test_split(test_size=0.2, random_state=0)\n",
+    "train = train_test['train']\n",
+    "test = train_test['test']\n",
+    "train"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>state</th>\n",
+       "      <th>fold</th>\n",
+       "      <th>population</th>\n",
+       "      <th>householdsize</th>\n",
+       "      <th>racepctblack</th>\n",
+       "      <th>racePctAsian</th>\n",
+       "      <th>racePctHisp</th>\n",
+       "      <th>agePct12t21</th>\n",
+       "      <th>agePct12t29</th>\n",
+       "      <th>agePct16t24</th>\n",
+       "      <th>...</th>\n",
+       "      <th>NumStreet</th>\n",
+       "      <th>PctForeignBorn</th>\n",
+       "      <th>PctBornSameState</th>\n",
+       "      <th>PctSameHouse85</th>\n",
+       "      <th>PctSameCity85</th>\n",
+       "      <th>PctSameState85</th>\n",
+       "      <th>LandArea</th>\n",
+       "      <th>PopDens</th>\n",
+       "      <th>PctUsePubTrans</th>\n",
+       "      <th>LemasPctOfficDrugUn</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>45</td>\n",
+       "      <td>8</td>\n",
+       "      <td>0.14</td>\n",
+       "      <td>0.56</td>\n",
+       "      <td>0.85</td>\n",
+       "      <td>0.09</td>\n",
+       "      <td>0.03</td>\n",
+       "      <td>0.76</td>\n",
+       "      <td>0.83</td>\n",
+       "      <td>0.77</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.09</td>\n",
+       "      <td>0.09</td>\n",
+       "      <td>0.62</td>\n",
+       "      <td>0.33</td>\n",
+       "      <td>0.36</td>\n",
+       "      <td>0.36</td>\n",
+       "      <td>0.34</td>\n",
+       "      <td>0.07</td>\n",
+       "      <td>0.27</td>\n",
+       "      <td>1.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>6</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.40</td>\n",
+       "      <td>0.02</td>\n",
+       "      <td>0.11</td>\n",
+       "      <td>0.22</td>\n",
+       "      <td>0.39</td>\n",
+       "      <td>0.42</td>\n",
+       "      <td>0.25</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.19</td>\n",
+       "      <td>0.66</td>\n",
+       "      <td>0.30</td>\n",
+       "      <td>0.57</td>\n",
+       "      <td>0.78</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.26</td>\n",
+       "      <td>0.02</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>55</td>\n",
+       "      <td>5</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.33</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.36</td>\n",
+       "      <td>0.40</td>\n",
+       "      <td>0.24</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.03</td>\n",
+       "      <td>0.67</td>\n",
+       "      <td>0.76</td>\n",
+       "      <td>0.77</td>\n",
+       "      <td>0.71</td>\n",
+       "      <td>0.02</td>\n",
+       "      <td>0.15</td>\n",
+       "      <td>0.02</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>34</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.71</td>\n",
+       "      <td>0.36</td>\n",
+       "      <td>0.21</td>\n",
+       "      <td>0.06</td>\n",
+       "      <td>0.77</td>\n",
+       "      <td>0.65</td>\n",
+       "      <td>0.66</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.35</td>\n",
+       "      <td>0.48</td>\n",
+       "      <td>0.66</td>\n",
+       "      <td>0.53</td>\n",
+       "      <td>0.57</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.48</td>\n",
+       "      <td>0.82</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>13</td>\n",
+       "      <td>8</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.65</td>\n",
+       "      <td>0.08</td>\n",
+       "      <td>0.20</td>\n",
+       "      <td>0.04</td>\n",
+       "      <td>0.48</td>\n",
+       "      <td>0.36</td>\n",
+       "      <td>0.20</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.13</td>\n",
+       "      <td>0.22</td>\n",
+       "      <td>0.20</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.07</td>\n",
+       "      <td>0.07</td>\n",
+       "      <td>0.01</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>5 rows × 101 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   state  fold  population  householdsize  racepctblack  racePctAsian  \\\n",
+       "0     45     8        0.14           0.56          0.85          0.09   \n",
+       "1      6     2        0.01           0.40          0.02          0.11   \n",
+       "2     55     5        0.00           0.33          0.00          0.01   \n",
+       "3     34     3        0.01           0.71          0.36          0.21   \n",
+       "4     13     8        0.01           0.65          0.08          0.20   \n",
+       "\n",
+       "   racePctHisp  agePct12t21  agePct12t29  agePct16t24  ...  NumStreet  \\\n",
+       "0         0.03         0.76         0.83         0.77  ...       0.09   \n",
+       "1         0.22         0.39         0.42         0.25  ...       0.01   \n",
+       "2         0.01         0.36         0.40         0.24  ...       0.00   \n",
+       "3         0.06         0.77         0.65         0.66  ...       0.00   \n",
+       "4         0.04         0.48         0.36         0.20  ...       0.00   \n",
+       "\n",
+       "   PctForeignBorn  PctBornSameState  PctSameHouse85  PctSameCity85  \\\n",
+       "0            0.09              0.62            0.33           0.36   \n",
+       "1            0.19              0.66            0.30           0.57   \n",
+       "2            0.03              0.67            0.76           0.77   \n",
+       "3            0.35              0.48            0.66           0.53   \n",
+       "4            0.13              0.22            0.20           0.00   \n",
+       "\n",
+       "   PctSameState85  LandArea  PopDens  PctUsePubTrans  LemasPctOfficDrugUn  \n",
+       "0            0.36      0.34     0.07            0.27                  1.0  \n",
+       "1            0.78      0.01     0.26            0.02                  0.0  \n",
+       "2            0.71      0.02     0.15            0.02                  0.0  \n",
+       "3            0.57      0.01     0.48            0.82                  0.0  \n",
+       "4            0.00      0.07     0.07            0.01                  0.0  \n",
+       "\n",
+       "[5 rows x 101 columns]"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "train['X'].head()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Dataset preprocessing**\n",
+    "\n",
+    "The 'us_crime' dataset that we will use in this notebook is a processed version that contains 1594 records and 102 attributes, including the protected attribute that we will use in the attack. This protected attribute is a binary attribute that indicates whether the individual is white or non-white."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_data = train['X'].copy()\n",
+    "train_data['group_a'] = train['group_a'].astype(int)\n",
+    "\n",
+    "test_data = test['X'].copy()\n",
+    "test_data['group_a'] = test['group_a'].astype(int)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(array([0, 1]), array([ 60, 339]))"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.unique(test['group_a'].astype(int), return_counts=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x_train = train_data.values\n",
+    "x_test = test_data.values\n",
+    "\n",
+    "y_train = train['y'].values\n",
+    "y_test = test['y'].values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "attack_feature = 101 # last column represents the sensitive attribute"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Attribute inference attack - WhiteBox**\n",
+    "\n",
+    "Now, we will perform an attack to infer the selected attribute using the `AttributeInferenceWhiteBoxDecisionTree` class from the `holisticai` library. This class, creates an object that uses an internal model to perform the attack. The internal model is trained on the same dataset used to train the target model to learn the attacked feature from the remaining features. The attack is performed by querying the internal model with the target model's predictions and the target model's input data. This is a variation of the method proposed by [Fredrikson et al.](https://dl.acm.org/doi/10.1145/2810103.2813677), since it assumes the availability of the attacked model's predictions for the samples under attack, in addition to access to the model itself and the rest of the feature values.  Unlike the WhiteBoxLifeStyle module, this module requires the target values to pefrom the attack.\n",
+    "\n",
+    "To do this, we will first train a decision tree regressor model on the 'us_crime' dataset and then we will pass this model to the `AttributeInferenceWhiteBoxDecisionTree` class to perform the attack."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.tree import DecisionTreeRegressor\n",
+    "\n",
+    "regressor = DecisionTreeRegressor()\n",
+    "regressor.fit(x_train, y_train)\n",
+    "\n",
+    "regressor = ScikitlearnDecisionTreeRegressor(regressor)\n",
+    "attack = AttributeInferenceWhiteBoxLifestyleDecisionTree(estimator=regressor, attack_feature=attack_feature)\n",
+    "\n",
+    "attack_x_test = np.delete(x_test, attack_feature, axis=1)\n",
+    "\n",
+    "feat_true = x_test[:, attack_feature]\n",
+    "\n",
+    "values = [0, 1]\n",
+    "priors = [60 / 399, 339 / 399]\n",
+    "\n",
+    "feat_pred = attack.infer(attack_x_test, values=values, priors=priors)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### **Measuring the attack success**\n",
+    "\n",
+    "The success of the attack is measured by the accuracy of the inferred attribute. The accuracy is calculated as the ratio of the correctly inferred attributes to the total number of data records. This can be done by using traditional classification metrics such as accuracy, precision, recall, and F1-score. For our case, we will use the `classification_efficacy_metrics` function from the `holisticai` library to calculate these metrics."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Value</th>\n",
+       "      <th>Reference</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Metric</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Accuracy</th>\n",
+       "      <td>0.849624</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Balanced Accuracy</th>\n",
+       "      <td>0.500000</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Precision</th>\n",
+       "      <td>0.849624</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Recall</th>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>F1-Score</th>\n",
+       "      <td>0.918699</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                      Value  Reference\n",
+       "Metric                                \n",
+       "Accuracy           0.849624          1\n",
+       "Balanced Accuracy  0.500000          1\n",
+       "Precision          0.849624          1\n",
+       "Recall             1.000000          1\n",
+       "F1-Score           0.918699          1"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from holisticai.efficacy.metrics import classification_efficacy_metrics\n",
+    "\n",
+    "classification_efficacy_metrics(feat_true, feat_pred)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As we can see, our attack achieved an accuracy of 0.849, which means that the attack was able to infer the 'Job' attribute with an accuracy of 84.9%. This is a high accuracy, which indicates that the attack was successful in inferring the sensitive attribute."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "testing",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

From 9ef597dfa1f3bb3740bb143202d9d35a01c8a9dc Mon Sep 17 00:00:00 2001
From: franklincf <fracarfer5@gmail.com>
Date: Fri, 20 Dec 2024 10:11:54 -0300
Subject: [PATCH 12/34] test: adding unit tests for attribute inference modules

---
 ...test_attribute_inference_classification.py | 183 ++++++++++++++++++
 .../test_attribute_inference_regression.py    | 171 ++++++++++++++++
 2 files changed, 354 insertions(+)
 create mode 100644 tests/security/test_attribute_inference_classification.py
 create mode 100644 tests/security/test_attribute_inference_regression.py

diff --git a/tests/security/test_attribute_inference_classification.py b/tests/security/test_attribute_inference_classification.py
new file mode 100644
index 00000000..fd254c9b
--- /dev/null
+++ b/tests/security/test_attribute_inference_classification.py
@@ -0,0 +1,183 @@
+import numpy as np
+from holisticai.datasets import load_dataset
+from holisticai.security.attackers.attribute_inference.baseline import AttributeInferenceBaseline
+
+from holisticai.security.attackers.attribute_inference.wrappers.classification.scikitlearn import SklearnClassifier
+from holisticai.security.attackers.attribute_inference.black_box import AttributeInferenceBlackBox
+from holisticai.security.attackers.attribute_inference.true_label_baseline import AttributeInferenceBaselineTrueLabel
+from holisticai.security.attackers.attribute_inference.wrappers.classification.scikitlearn import ScikitlearnDecisionTreeClassifier
+from holisticai.security.attackers.attribute_inference.mitigation.attacks.white_box_lifestyle_decision_tree import (
+    AttributeInferenceWhiteBoxLifestyleDecisionTree
+)
+from holisticai.security.attackers.attribute_inference.mitigation.scikitlearn import (
+    AttributeInferenceWhiteBoxDecisionTree,
+)
+from sklearn.tree import DecisionTreeClassifier
+from holisticai.efficacy.metrics import classification_efficacy_metrics
+import pytest
+
+np.random.seed(100)
+
+SHARD_SIZE=60
+
+@pytest.fixture
+def categorical_dataset():
+    dataset = load_dataset("adult", protected_attribute='race') # x,y,group_a,group_b
+    dataset = dataset.groupby(['y','group_a']).sample(SHARD_SIZE, random_state=42) # 0-ga | 0-gb  | 1-ga | 1-gb
+    train_test = dataset.train_test_split(test_size=0.5, stratify=dataset['y'], random_state=0)
+    train = train_test['train']
+    test = train_test['test']
+    correlations = train['X'].corrwith(train['y']).sort_values(ascending=False)
+    top_10_features = correlations.head(10).index.tolist()
+    train['X'] = train['X'][top_10_features]
+    test['X'] = test['X'][top_10_features]
+    return train, test
+
+
+def test_att_inf_baseline(categorical_dataset):
+
+    train, test = categorical_dataset
+
+    attack_feature = 0 # marital status
+
+    x_train = train['X'].copy().values
+    y_train = train['y'].copy().values
+    x_test = test['X'].copy().values
+    y_test = test['y'].copy().values
+
+    attack = AttributeInferenceBaseline(attack_feature=attack_feature)
+    attack.fit(x_train)
+
+    attack_x_test = np.delete(x_test, attack_feature, axis=1)
+    feat_true = x_test[:, attack_feature]
+
+    values = [0, 1]
+    feat_pred = attack.infer(attack_x_test, values=values)
+
+    assert len(feat_true) == len(feat_pred)
+
+    df = classification_efficacy_metrics(feat_true, feat_pred)
+
+    assert df.loc['Accuracy']['Value'] > 0.5
+
+
+def test_att_inf_black_box(categorical_dataset):
+    train, test = categorical_dataset
+
+    attack_feature = 0 # marital status
+
+    x_train = train['X'].copy().values
+    y_train = train['y'].copy().values
+    x_test = test['X'].copy().values
+    y_test = test['y'].copy().values
+
+    classifier = DecisionTreeClassifier()
+    classifier.fit(x_train, y_train)
+    classifier = SklearnClassifier(classifier)
+
+    attack = AttributeInferenceBlackBox(estimator=classifier, attack_feature=attack_feature)
+
+    pred = classifier.predict_proba(x_train)
+    attack.fit(x_train, y_train, pred)
+
+    attack_x_test = np.delete(x_test, attack_feature, axis=1)
+    pred = classifier.predict_proba(x_test)
+
+    feat_true = x_test[:, attack_feature]
+
+    values = [0, 1]
+    feat_pred = attack.infer(attack_x_test, y_test, pred, values=values)
+
+    assert len(feat_true) == len(feat_pred)
+
+    df = classification_efficacy_metrics(feat_true, feat_pred)
+
+    assert df.loc['Accuracy']['Value'] > 0.5
+
+
+def test_att_inf_truelabel(categorical_dataset):
+    train, test = categorical_dataset
+
+    attack_feature = 0 # marital status
+
+    x_train = train['X'].copy().values
+    y_train = train['y'].copy().values
+    x_test = test['X'].copy().values
+    y_test = test['y'].copy().values
+
+    attack = AttributeInferenceBaselineTrueLabel(attack_feature=attack_feature)
+    attack.fit(x_train, y_train)
+
+    attack_x_test = np.delete(x_test, attack_feature, axis=1)
+    feat_true = x_test[:, attack_feature]
+
+    values = [0, 1]
+    feat_pred = attack.infer(attack_x_test, y_test, values=values)
+
+    assert len(feat_true) == len(feat_pred)
+
+    df = classification_efficacy_metrics(feat_true, feat_pred)
+
+    assert df.loc['Accuracy']['Value'] > 0.5
+
+
+def test_att_inf_white_box_lifestyle(categorical_dataset):
+    train, test = categorical_dataset
+
+    attack_feature = 0 # marital status
+
+    x_train = train['X'].copy().values
+    y_train = train['y'].copy().values
+    x_test = test['X'].copy().values
+    y_test = test['y'].copy().values
+
+    classifier = DecisionTreeClassifier()
+    classifier.fit(x_train, y_train)
+    classifier = ScikitlearnDecisionTreeClassifier(classifier)
+
+    attack = AttributeInferenceWhiteBoxLifestyleDecisionTree(attack_feature=attack_feature, estimator=classifier)
+
+    attack_x_test = np.delete(x_test, attack_feature, axis=1)
+    feat_true = x_test[:, attack_feature]
+
+    values = [0, 1]
+    priors = [53/120, 67/120]
+
+    feat_pred = attack.infer(attack_x_test, values=values, priors=priors)
+
+    assert len(feat_true) == len(feat_pred)
+
+    df = classification_efficacy_metrics(feat_true, feat_pred)
+
+    assert df.loc['Accuracy']['Value'] > 0.5
+
+
+def test_att_inf_white_box(categorical_dataset):
+    train, test = categorical_dataset
+
+    attack_feature = 0 # marital status
+
+    x_train = train['X'].copy().values
+    y_train = train['y'].copy().values
+    x_test = test['X'].copy().values
+    y_test = test['y'].copy().values
+
+    classifier = DecisionTreeClassifier()
+    classifier.fit(x_train, y_train)
+    classifier = ScikitlearnDecisionTreeClassifier(classifier)
+
+    attack = AttributeInferenceWhiteBoxDecisionTree(attack_feature=attack_feature, classifier=classifier)
+
+    attack_x_test = np.delete(x_test, attack_feature, axis=1)
+    feat_true = x_test[:, attack_feature]
+
+    values = [0, 1]
+    priors = [53/120, 67/120]
+
+    feat_pred = attack.infer(attack_x_test, y_test, values=values, priors=priors)
+
+    assert len(feat_true) == len(feat_pred)
+
+    df = classification_efficacy_metrics(feat_true, feat_pred)
+
+    assert df.loc['Accuracy']['Value'] > 0.5
\ No newline at end of file
diff --git a/tests/security/test_attribute_inference_regression.py b/tests/security/test_attribute_inference_regression.py
new file mode 100644
index 00000000..104c47e4
--- /dev/null
+++ b/tests/security/test_attribute_inference_regression.py
@@ -0,0 +1,171 @@
+import numpy as np
+from holisticai.datasets import load_dataset
+from holisticai.security.attackers.attribute_inference.baseline import AttributeInferenceBaseline
+from holisticai.security.attackers.attribute_inference.wrappers.regression.scikitlearn import ScikitlearnRegressor
+from holisticai.security.attackers.attribute_inference.black_box import AttributeInferenceBlackBox
+from holisticai.security.attackers.attribute_inference.true_label_baseline import AttributeInferenceBaselineTrueLabel
+from holisticai.security.attackers.attribute_inference.wrappers.regression.scikitlearn import ScikitlearnDecisionTreeRegressor
+from holisticai.security.attackers.attribute_inference.mitigation.attacks.white_box_lifestyle_decision_tree import (
+    AttributeInferenceWhiteBoxLifestyleDecisionTree
+)
+from holisticai.efficacy.metrics import classification_efficacy_metrics
+from holisticai.pipeline import Pipeline
+from sklearn.tree import DecisionTreeRegressor
+import pytest
+
+np.random.seed(100)
+
+SHARD_SIZE = 60
+
+@pytest.fixture
+def regression_dataset():
+    dataset = load_dataset('us_crime', preprocessed=True, protected_attribute='race')
+    dataset = dataset.sample(SHARD_SIZE, random_state=42)
+    train_test = dataset.train_test_split(test_size=0.5, random_state=42)
+    train = train_test['train']
+    test = train_test['test']
+    return train, test
+
+def test_att_inf_baseline_regression(regression_dataset):
+    train, test = regression_dataset
+    train_data = train['X'].copy()
+    train_data['group_a'] = train['group_a'].astype(int)
+
+    test_data = test['X'].copy()
+    test_data['group_a'] = test['group_a'].astype(int)
+
+    x_train = train_data.values
+    x_test = test_data.values
+
+    y_train = train['y'].values
+    y_test = test['y'].values
+
+    attack_feature = 101 # last column represents the sensitive attribute
+
+    attack = AttributeInferenceBaseline(attack_feature=attack_feature)
+    attack.fit(x_train)
+
+    attack_x_test = np.delete(x_test, attack_feature, axis=1)
+    feat_true = x_test[:, attack_feature]
+
+    values = [0, 1]
+    feat_pred = attack.infer(attack_x_test, values=values)
+
+    assert len(feat_true) == len(feat_pred)
+
+    df = classification_efficacy_metrics(feat_true, feat_pred)
+
+    assert df.loc['Accuracy']['Value'] > 0.5
+
+def test_att_inf_blackbox_regression(regression_dataset):
+    train, test = regression_dataset
+    train_data = train['X'].copy()
+    train_data['group_a'] = train['group_a'].astype(int)
+
+    test_data = test['X'].copy()
+    test_data['group_a'] = test['group_a'].astype(int)
+
+    x_train = train_data.values
+    x_test = test_data.values
+
+    y_train = train['y'].values
+    y_test = test['y'].values
+
+    attack_feature = 101 # last column represents the sensitive attribute
+
+    regressor = Pipeline(steps=[
+        ('model', DecisionTreeRegressor())
+    ])
+
+    regressor.fit(x_train, y_train)
+
+    # regressor = train_holisticai_regressor(x_train, y_train)
+    regressor = ScikitlearnRegressor(regressor)
+    pred = regressor.predict(x_train)
+
+    attack = AttributeInferenceBlackBox(estimator=regressor, attack_feature=attack_feature, scale_range=(0,1))
+    attack.fit(x_train, y_train, pred)
+
+    pred = regressor.predict(x_test)
+    attack_x_test = np.delete(x_test, attack_feature, axis=1)
+
+    feat_true = x_test[:, attack_feature]
+
+    values = [False, True]
+    feat_pred = attack.infer(attack_x_test, y_test, pred, values=values)
+
+    assert len(feat_true) == len(feat_pred)
+
+    df = classification_efficacy_metrics(feat_true, feat_pred)
+
+    assert df.loc['Accuracy']['Value'] > 0.5
+
+
+def test_att_inf_baseline_true_label_regression(regression_dataset):
+    train, test = regression_dataset
+    train_data = train['X'].copy()
+    train_data['group_a'] = train['group_a'].astype(int)
+
+    test_data = test['X'].copy()
+    test_data['group_a'] = test['group_a'].astype(int)
+
+    x_train = train_data.values
+    x_test = test_data.values
+
+    y_train = train['y'].values
+    y_test = test['y'].values
+
+    attack_feature = 101 # last column represents the sensitive attribute
+
+    attack = AttributeInferenceBaselineTrueLabel(attack_feature=attack_feature, is_regression=True)
+    attack.fit(x_train, y_train)
+
+    attack_x_test = np.delete(x_test, attack_feature, axis=1)
+    feat_true = x_test[:, attack_feature]
+
+    values = [0, 1]
+    feat_pred = attack.infer(attack_x_test, y_test, values=values)
+
+    assert len(feat_true) == len(feat_pred)
+
+    df = classification_efficacy_metrics(feat_true, feat_pred)
+
+    assert df.loc['Accuracy']['Value'] > 0.5
+
+
+def test_att_inf_white_box_lifestyle_decision_tree_regression(regression_dataset):
+    train, test = regression_dataset
+    train_data = train['X'].copy()
+    train_data['group_a'] = train['group_a'].astype(int)
+
+    test_data = test['X'].copy()
+    test_data['group_a'] = test['group_a'].astype(int)
+
+    x_train = train_data.values
+    x_test = test_data.values
+
+    y_train = train['y'].values
+    y_test = test['y'].values
+
+    attack_feature = 101 # last column represents the sensitive attribute
+
+    regressor = DecisionTreeRegressor()
+    regressor.fit(x_train, y_train)
+
+    regressor = ScikitlearnDecisionTreeRegressor(regressor)
+    attack = AttributeInferenceWhiteBoxLifestyleDecisionTree(estimator=regressor, attack_feature=attack_feature)
+
+    attack_x_test = np.delete(x_test, attack_feature, axis=1)
+
+    feat_true = x_test[:, attack_feature]
+
+    values = [0, 1]
+    priors = [2 / 30, 28 / 30]
+
+    feat_pred = attack.infer(attack_x_test, values=values, priors=priors)
+
+    assert len(feat_true) == len(feat_pred)
+
+    df = classification_efficacy_metrics(feat_true, feat_pred)
+
+    assert df.loc['Accuracy']['Value'] > 0.5
\ No newline at end of file

From 847f93938d5b60de0c3b9a09b9d1ae600c1bb16d Mon Sep 17 00:00:00 2001
From: franklincf <fracarfer5@gmail.com>
Date: Fri, 20 Dec 2024 10:12:34 -0300
Subject: [PATCH 13/34] refactor: updating inits

---
 src/holisticai/security/attackers/__init__.py               | 0
 .../security/attackers/attribute_inference/__init__.py      | 6 ++++++
 2 files changed, 6 insertions(+)
 create mode 100644 src/holisticai/security/attackers/__init__.py

diff --git a/src/holisticai/security/attackers/__init__.py b/src/holisticai/security/attackers/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/src/holisticai/security/attackers/attribute_inference/__init__.py b/src/holisticai/security/attackers/attribute_inference/__init__.py
index e69de29b..5417c02c 100644
--- a/src/holisticai/security/attackers/attribute_inference/__init__.py
+++ b/src/holisticai/security/attackers/attribute_inference/__init__.py
@@ -0,0 +1,6 @@
+from holisticai.security.attackers.attribute_inference.baseline import (
+    AttributeInferenceAttack,
+    AttributeInferenceBaseline,
+)
+
+__all__ = ["AttributeInferenceAttack", "AttributeInferenceBaseline"]

From e9dd3308899cf2da1b6c5a525d7794c4fb71a630 Mon Sep 17 00:00:00 2001
From: franklincf <fracarfer5@gmail.com>
Date: Fri, 20 Dec 2024 10:40:14 -0300
Subject: [PATCH 14/34] chore: fixing lint

---
 src/holisticai/security/attackers/attribute_inference/attack.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/holisticai/security/attackers/attribute_inference/attack.py b/src/holisticai/security/attackers/attribute_inference/attack.py
index 15f15780..36d77411 100644
--- a/src/holisticai/security/attackers/attribute_inference/attack.py
+++ b/src/holisticai/security/attackers/attribute_inference/attack.py
@@ -79,7 +79,7 @@ def replacement_function(self, *args, **kwargs):
                 setattr(cls, item, new_function)
 
 
-class Attack(abc.ABC):
+class Attack(abc.ABC):  # noqa: B024
     """
     Abstract base class for all attack abstract base classes.
 

From 6ce7d6d6e6ced2a2d93098dc241e71dbb973b68e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cristian=20Mu=C3=B1oz?= <cristian.munoz@holisticai.com>
Date: Mon, 10 Feb 2025 16:35:11 +0000
Subject: [PATCH 15/34] Develop (#292)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* chore: update files for new gitflow (#227)

* chore: update files for new-release

* chore: update files for new gitflow

* chore: update readme (#229)

* docs: update tutorials

* docs: update tutorials (#230)

* feat: new datasets and docs (#231)

* feat: new datasets and docs

* fix: fmt

* docs: rename lib (#234)

* fix: datasets labels (#245)

* feature: update dataset_shift module (#248)

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* fix: update dataset_shift code and plots

* fix: update dataset_shift code and plots

* fix: update dataset_shift code and plots

* fix: percent_degradation to ADP nomenclature

* chore(deps): bump actions/checkout from 4.1.7 to 4.2.2 (#250)

Bumps [actions/checkout](https://github.com/actions/checkout) from 4.1.7 to 4.2.2.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/v4.1.7...v4.2.2)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* chore(deps): bump actions/setup-python from 5.2.0 to 5.3.0 (#251)

Bumps [actions/setup-python](https://github.com/actions/setup-python) from 5.2.0 to 5.3.0.
- [Release notes](https://github.com/actions/setup-python/releases)
- [Commits](https://github.com/actions/setup-python/compare/v5.2.0...v5.3.0)

---
updated-dependencies:
- dependency-name: actions/setup-python
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* feat: New Robustness Regression Attacker: Ridge Poissoner (#241)

* feat: adding adaptive and randflip initializers for regression poisoners

* feat: adding ridge-based regression poisoner

* test: adding unit tests for ridge-based regression poisoner

* chore: updating tutorial with ridge-based poisoner

* docs: updating regression poisoner docs with ridge regressor

* docs: adding docstrings for ridge regressor poisoner

* chore: fixing lint

* chore: updating docstrings for poisoners

* chore: updloading notebook file for regression poisoner tutorial

* docs: updating possible parameters in docstrings

* feat: new methods for measuring security privacy risk score (#254)

* feat: adding source code and tutorial for privacy risk score

* tests: adding unit test for privacy risk score metric

* docs: updating reference docstrings for privacy risk score metric

* docs: updating docs for example gallery for security module

* feat: adding tutorial for privacy risk score with different models

* chore: adding tutorial for example gallery

* chore: adding tutorial notebook files for docs section

* Update security.rst

---------

Co-authored-by: Cristian Muñoz <cristian.munoz@holisticai.com>

* feat: new xai metrics based on globa feature importance, local feature importance and surrogate  (#255)

* internal changes

* fix: pfi regression and shap

* update: shap and contrast

* chore: improved xai metrics

* fix: paper regression results

* ok

* chore:  xai-metrics updated

* chore: format files

* test: add test for new metrics

* docs: update documentation and docstring format

* chore: hatch dmt

---------

Co-authored-by: Kleyton da Costa <kleyton.vsc@gmail.com>

* chore: Improve Accuracy Degradation Profile Documentation  (#249)

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* fix: update dataset_shift code and plots

* fix: update dataset_shift code and plots

* fix: update dataset_shift code and plots

* fix: percent_degradation to ADP nomenclature

* fix: uptade documentation

* chore: clean adp tutorial

* chore: remove inccorect reference

* chore: format

* doc: fix docstring

---------

Co-authored-by: crismunoz <crisstrink@gmail.com>

* docs:update tutorials (#257)

* docs: updating docstrings for regression poissoners (#256)

* fix: load dataset (#259)

* Delete paper directory (#262)

* Delete README.rst

* Delete workflows directory (#263)

* Features/improvementes (#265)

* chore: push updates

* fix: compas and add description

* fix: format

---------

Co-authored-by: crismunoz <crisstrink@gmail.com>

* add: bias tradeoff example (#266)

* add: bank marketing description (#267)

* chore: updating hackaton notebook with privacy risk score interpretation (#271)

* docs: update documetnation (#274)

* fix: merge conflicts

* Features/update documentation (#276)

* chore: update documentation HAI

* feat: remove dataset dependence of sklearn (#277)

* feat: remove dataset dependece of sklearn

* fix: lastfm dataset name

* fix: repository name

* fix: format (#280)

* chore(deps): bump numpy from 1.26 to 2.2.0 (#281)

Bumps [numpy](https://github.com/numpy/numpy) from 1.26 to 2.2.0.
- [Release notes](https://github.com/numpy/numpy/releases)
- [Changelog](https://github.com/numpy/numpy/blob/main/doc/RELEASE_WALKTHROUGH.rst)
- [Commits](https://github.com/numpy/numpy/compare/v1.26.0...v2.2.0)

---
updated-dependencies:
- dependency-name: numpy
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* chore(deps): bump slackapi/slack-github-action from 1.27.0 to 2.0.0 (#278)

Bumps [slackapi/slack-github-action](https://github.com/slackapi/slack-github-action) from 1.27.0 to 2.0.0.
- [Release notes](https://github.com/slackapi/slack-github-action/releases)
- [Commits](https://github.com/slackapi/slack-github-action/compare/v1.27.0...v2.0.0)

---
updated-dependencies:
- dependency-name: slackapi/slack-github-action
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* Rename rs_fair_topk_fa*ir_algorithm.rst to rs_fair_topk_fair_algorithm.rst

* Hotfix (#286)

* Update Main Branch (#279)

* chore: update files for new gitflow (#227)

Bumps [actions/checkout](https://github.com/actions/checkout) from 4.1.7 to 4.2.2.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/v4.1.7...v4.2.2)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* chore(deps): bump actions/setup-python from 5.2.0 to 5.3.0 (#251)

Bumps [actions/setup-python](https://github.com/actions/setup-python) from 5.2.0 to 5.3.0.
- [Release notes](https://github.com/actions/setup-python/releases)
- [Commits](https://github.com/actions/setup-python/compare/v5.2.0...v5.3.0)

---
updated-dependencies:
- dependency-name: actions/setup-python
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* feat: New Robustness Regression Attacker: Ridge Poissoner (#241)

---------

Co-authored-by: Cristian Muñoz <cristian.munoz@holisticai.com>

* feat: new xai metrics based on globa feature importance, local feature importance and surrogate  (#255)
---------

Co-authored-by: Kleyton da Costa <kleyton.vsc@gmail.com>

* chore: Improve Accuracy Degradation Profile Documentation  (#249)

---------

Co-authored-by: crismunoz <crisstrink@gmail.com>

* docs:update tutorials (#257)

---------

Co-authored-by: crismunoz <crisstrink@gmail.com>

* add: bias tradeoff example (#266)

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: Kleyton da Costa <44351707+Kleyt0n@users.noreply.github.com>
Co-authored-by: andrelfnovaes <40208986+andrelfnovaes@users.noreply.github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Franklin Cardenoso <44931423+fracarfer5@users.noreply.github.com>
Co-authored-by: Kleyton da Costa <kleyton.vsc@gmail.com>

* Update version and changelog

* chore: update release workflows  (#282)

* chore: update files for new gitflow (#227)

* chore: update files for new-release

* chore: update readme (#229)

* docs: update tutorials (#230)

* feat: new datasets and docs (#231)

* docs: rename lib (#234)

* fix: datasets labels (#245)

* feature: update dataset_shift module (#248)

* feature: update dataset_shift module

* fix: update dataset_shift code and plots

* fix: percent_degradation to ADP nomenclature

* chore(deps): bump actions/checkout from 4.1.7 to 4.2.2 (#250)

Bumps [actions/checkout](https://github.com/actions/checkout) from 4.1.7 to 4.2.2.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/v4.1.7...v4.2.2)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* chore(deps): bump actions/setup-python from 5.2.0 to 5.3.0 (#251)

Bumps [actions/setup-python](https://github.com/actions/setup-python) from 5.2.0 to 5.3.0.
- [Release notes](https://github.com/actions/setup-python/releases)
- [Commits](https://github.com/actions/setup-python/compare/v5.2.0...v5.3.0)

---
updated-dependencies:
- dependency-name: actions/setup-python
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* feat: New Robustness Regression Attacker: Ridge Poissoner (#241)

* feat: adding adaptive and randflip initializers for regression poisoners

* feat: adding ridge-based regression poisoner

* test: adding unit tests for ridge-based regression poisoner

* chore: updating tutorial with ridge-based poisoner

* docs: updating regression poisoner docs with ridge regressor

* docs: adding docstrings for ridge regressor poisoner

* chore: fixing lint

* chore: updating docstrings for poisoners

* chore: updloading notebook file for regression poisoner tutorial

* docs: updating possible parameters in docstrings

* feat: new methods for measuring security privacy risk score (#254)

* feat: adding source code and tutorial for privacy risk score

* tests: adding unit test for privacy risk score metric

* docs: updating reference docstrings for privacy risk score metric

* docs: updating docs for example gallery for security module

* feat: adding tutorial for privacy risk score with different models

* chore: adding tutorial for example gallery

* chore: adding tutorial notebook files for docs section

* Update security.rst

---------

Co-authored-by: Cristian Muñoz <cristian.munoz@holisticai.com>

* feat: new xai metrics based on globa feature importance, local feature importance and surrogate  (#255)

* internal changes

* fix: pfi regression and shap

* update: shap and contrast

* chore: improved xai metrics

* fix: paper regression results

* ok

* chore:  xai-metrics updated

* chore: format files

* test: add test for new metrics

* docs: update documentation and docstring format

* chore: hatch dmt

---------

Co-authored-by: Kleyton da Costa <kleyton.vsc@gmail.com>

* chore: Improve Accuracy Degradation Profile Documentation  (#249)

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* fix: update dataset_shift code and plots

* fix: update dataset_shift code and plots

* fix: update dataset_shift code and plots

* fix: percent_degradation to ADP nomenclature

* fix: uptade documentation

* chore: clean adp tutorial

* chore: remove inccorect reference

* chore: format

* doc: fix docstring

---------

Co-authored-by: crismunoz <crisstrink@gmail.com>

* docs:update tutorials (#257)

* docs: updating docstrings for regression poissoners (#256)

* fix: load dataset (#259)

* Delete paper directory (#262)

* Delete README.rst

* Delete workflows directory (#263)

* Features/improvementes (#265)

* chore: push updates

* fix: compas and add description

* fix: format

---------

Co-authored-by: crismunoz <crisstrink@gmail.com>

* add: bias tradeoff example (#266)

* add: bank marketing description (#267)

* chore: updating hackaton notebook with privacy risk score interpretation (#271)

* docs: update documetnation (#274)

* fix: merge conflicts

* Features/update documentation (#276)

* chore: update documentation HAI

* feat: remove dataset dependence of sklearn (#277)

* feat: remove dataset dependece of sklearn

* fix: lastfm dataset name

* fix: repository name

* fix: format (#280)

* chore(deps): bump numpy from 1.26 to 2.2.0 (#281)

Bumps [numpy](https://github.com/numpy/numpy) from 1.26 to 2.2.0.
- [Release notes](https://github.com/numpy/numpy/releases)
- [Changelog](https://github.com/numpy/numpy/blob/main/doc/RELEASE_WALKTHROUGH.rst)
- [Commits](https://github.com/numpy/numpy/compare/v1.26.0...v2.2.0)

---
updated-dependencies:
- dependency-name: numpy
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* chore(deps): bump slackapi/slack-github-action from 1.27.0 to 2.0.0 (#278)

Bumps [slackapi/slack-github-action](https://github.com/slackapi/slack-github-action) from 1.27.0 to 2.0.0.
- [Release notes](https://github.com/slackapi/slack-github-action/releases)
- [Commits](https://github.com/slackapi/slack-github-action/compare/v1.27.0...v2.0.0)

---
updated-dependencies:
- dependency-name: slackapi/slack-github-action
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: Kleyton da Costa <44351707+Kleyt0n@users.noreply.github.com>
Co-authored-by: andrelfnovaes <40208986+andrelfnovaes@users.noreply.github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Franklin Cardenoso <44931423+fracarfer5@users.noreply.github.com>
Co-authored-by: Kleyton da Costa <kleyton.vsc@gmail.com>

* Update version and changelog

* fix: Update publish-workflow.yml (#283)

* Update publish-workflow.yml

* Create publish-slack-workflow.yml

* Update publish-workflow.yml

* Rename publish-workflow.yml to publish-pypi-workflow.yml

* chore: Update Workflow Names (#284)

* Update publish-pypi-workflow.yml

* Update publish-slack-workflow.yml

* Update publish-slack-workflow.yml (#285)

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: Kleyton da Costa <44351707+Kleyt0n@users.noreply.github.com>
Co-authored-by: andrelfnovaes <40208986+andrelfnovaes@users.noreply.github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Franklin Cardenoso <44931423+fracarfer5@users.noreply.github.com>
Co-authored-by: Kleyton da Costa <kleyton.vsc@gmail.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: Kleyton da Costa <44351707+Kleyt0n@users.noreply.github.com>
Co-authored-by: andrelfnovaes <40208986+andrelfnovaes@users.noreply.github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Franklin Cardenoso <44931423+fracarfer5@users.noreply.github.com>
Co-authored-by: Kleyton da Costa <kleyton.vsc@gmail.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
---
 ...r_topk_fa*ir_algorithm.rst => rs_fair_topk_fair_algorithm.rst} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename docs/source/getting_started/bias/mitigation/postprocessing/{rs_fair_topk_fa*ir_algorithm.rst => rs_fair_topk_fair_algorithm.rst} (100%)

diff --git a/docs/source/getting_started/bias/mitigation/postprocessing/rs_fair_topk_fa*ir_algorithm.rst b/docs/source/getting_started/bias/mitigation/postprocessing/rs_fair_topk_fair_algorithm.rst
similarity index 100%
rename from docs/source/getting_started/bias/mitigation/postprocessing/rs_fair_topk_fa*ir_algorithm.rst
rename to docs/source/getting_started/bias/mitigation/postprocessing/rs_fair_topk_fair_algorithm.rst

From 893c94944c3d0d0001319a8097e7228e7795fb4e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cristian=20Mu=C3=B1oz?= <cristian.munoz@holisticai.com>
Date: Wed, 12 Feb 2025 17:58:03 -0300
Subject: [PATCH 16/34] Develop (#294)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* chore: update files for new gitflow (#227)

* chore: update files for new-release

* chore: update files for new gitflow

* chore: update readme (#229)

* docs: update tutorials

* docs: update tutorials (#230)

* feat: new datasets and docs (#231)

* feat: new datasets and docs

* fix: fmt

* docs: rename lib (#234)

* fix: datasets labels (#245)

* feature: update dataset_shift module (#248)

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* fix: update dataset_shift code and plots

* fix: update dataset_shift code and plots

* fix: update dataset_shift code and plots

* fix: percent_degradation to ADP nomenclature

* chore(deps): bump actions/checkout from 4.1.7 to 4.2.2 (#250)

Bumps [actions/checkout](https://github.com/actions/checkout) from 4.1.7 to 4.2.2.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/v4.1.7...v4.2.2)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* chore(deps): bump actions/setup-python from 5.2.0 to 5.3.0 (#251)

Bumps [actions/setup-python](https://github.com/actions/setup-python) from 5.2.0 to 5.3.0.
- [Release notes](https://github.com/actions/setup-python/releases)
- [Commits](https://github.com/actions/setup-python/compare/v5.2.0...v5.3.0)

---
updated-dependencies:
- dependency-name: actions/setup-python
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* feat: New Robustness Regression Attacker: Ridge Poissoner (#241)

* feat: adding adaptive and randflip initializers for regression poisoners

* feat: adding ridge-based regression poisoner

* test: adding unit tests for ridge-based regression poisoner

* chore: updating tutorial with ridge-based poisoner

* docs: updating regression poisoner docs with ridge regressor

* docs: adding docstrings for ridge regressor poisoner

* chore: fixing lint

* chore: updating docstrings for poisoners

* chore: updloading notebook file for regression poisoner tutorial

* docs: updating possible parameters in docstrings

* feat: new methods for measuring security privacy risk score (#254)

* feat: adding source code and tutorial for privacy risk score

* tests: adding unit test for privacy risk score metric

* docs: updating reference docstrings for privacy risk score metric

* docs: updating docs for example gallery for security module

* feat: adding tutorial for privacy risk score with different models

* chore: adding tutorial for example gallery

* chore: adding tutorial notebook files for docs section

* Update security.rst

---------

Co-authored-by: Cristian Muñoz <cristian.munoz@holisticai.com>

* feat: new xai metrics based on globa feature importance, local feature importance and surrogate  (#255)

* internal changes

* fix: pfi regression and shap

* update: shap and contrast

* chore: improved xai metrics

* fix: paper regression results

* ok

* chore:  xai-metrics updated

* chore: format files

* test: add test for new metrics

* docs: update documentation and docstring format

* chore: hatch dmt

---------

Co-authored-by: Kleyton da Costa <kleyton.vsc@gmail.com>

* chore: Improve Accuracy Degradation Profile Documentation  (#249)

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* fix: update dataset_shift code and plots

* fix: update dataset_shift code and plots

* fix: update dataset_shift code and plots

* fix: percent_degradation to ADP nomenclature

* fix: uptade documentation

* chore: clean adp tutorial

* chore: remove inccorect reference

* chore: format

* doc: fix docstring

---------

Co-authored-by: crismunoz <crisstrink@gmail.com>

* docs:update tutorials (#257)

* docs: updating docstrings for regression poissoners (#256)

* fix: load dataset (#259)

* Delete paper directory (#262)

* Delete README.rst

* Delete workflows directory (#263)

* Features/improvementes (#265)

* chore: push updates

* fix: compas and add description

* fix: format

---------

Co-authored-by: crismunoz <crisstrink@gmail.com>

* add: bias tradeoff example (#266)

* add: bank marketing description (#267)

* chore: updating hackaton notebook with privacy risk score interpretation (#271)

* docs: update documetnation (#274)

* fix: merge conflicts

* Features/update documentation (#276)

* chore: update documentation HAI

* feat: remove dataset dependence of sklearn (#277)

* feat: remove dataset dependece of sklearn

* fix: lastfm dataset name

* fix: repository name

* fix: format (#280)

* chore(deps): bump numpy from 1.26 to 2.2.0 (#281)

Bumps [numpy](https://github.com/numpy/numpy) from 1.26 to 2.2.0.
- [Release notes](https://github.com/numpy/numpy/releases)
- [Changelog](https://github.com/numpy/numpy/blob/main/doc/RELEASE_WALKTHROUGH.rst)
- [Commits](https://github.com/numpy/numpy/compare/v1.26.0...v2.2.0)

---
updated-dependencies:
- dependency-name: numpy
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* chore(deps): bump slackapi/slack-github-action from 1.27.0 to 2.0.0 (#278)

Bumps [slackapi/slack-github-action](https://github.com/slackapi/slack-github-action) from 1.27.0 to 2.0.0.
- [Release notes](https://github.com/slackapi/slack-github-action/releases)
- [Commits](https://github.com/slackapi/slack-github-action/compare/v1.27.0...v2.0.0)

---
updated-dependencies:
- dependency-name: slackapi/slack-github-action
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* Rename rs_fair_topk_fa*ir_algorithm.rst to rs_fair_topk_fair_algorithm.rst

* Hotfix (#286)

* Update Main Branch (#279)

* chore: update files for new gitflow (#227)

Bumps [actions/checkout](https://github.com/actions/checkout) from 4.1.7 to 4.2.2.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/v4.1.7...v4.2.2)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* chore(deps): bump actions/setup-python from 5.2.0 to 5.3.0 (#251)

Bumps [actions/setup-python](https://github.com/actions/setup-python) from 5.2.0 to 5.3.0.
- [Release notes](https://github.com/actions/setup-python/releases)
- [Commits](https://github.com/actions/setup-python/compare/v5.2.0...v5.3.0)

---
updated-dependencies:
- dependency-name: actions/setup-python
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* feat: New Robustness Regression Attacker: Ridge Poissoner (#241)

---------

Co-authored-by: Cristian Muñoz <cristian.munoz@holisticai.com>

* feat: new xai metrics based on globa feature importance, local feature importance and surrogate  (#255)
---------

Co-authored-by: Kleyton da Costa <kleyton.vsc@gmail.com>

* chore: Improve Accuracy Degradation Profile Documentation  (#249)

---------

Co-authored-by: crismunoz <crisstrink@gmail.com>

* docs:update tutorials (#257)

---------

Co-authored-by: crismunoz <crisstrink@gmail.com>

* add: bias tradeoff example (#266)

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: Kleyton da Costa <44351707+Kleyt0n@users.noreply.github.com>
Co-authored-by: andrelfnovaes <40208986+andrelfnovaes@users.noreply.github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Franklin Cardenoso <44931423+fracarfer5@users.noreply.github.com>
Co-authored-by: Kleyton da Costa <kleyton.vsc@gmail.com>

* Update version and changelog

* chore: update release workflows  (#282)

* chore: update files for new gitflow (#227)

* chore: update files for new-release

* chore: update readme (#229)

* docs: update tutorials (#230)

* feat: new datasets and docs (#231)

* docs: rename lib (#234)

* fix: datasets labels (#245)

* feature: update dataset_shift module (#248)

* feature: update dataset_shift module

* fix: update dataset_shift code and plots

* fix: percent_degradation to ADP nomenclature

* chore(deps): bump actions/checkout from 4.1.7 to 4.2.2 (#250)

Bumps [actions/checkout](https://github.com/actions/checkout) from 4.1.7 to 4.2.2.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/v4.1.7...v4.2.2)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* chore(deps): bump actions/setup-python from 5.2.0 to 5.3.0 (#251)

Bumps [actions/setup-python](https://github.com/actions/setup-python) from 5.2.0 to 5.3.0.
- [Release notes](https://github.com/actions/setup-python/releases)
- [Commits](https://github.com/actions/setup-python/compare/v5.2.0...v5.3.0)

---
updated-dependencies:
- dependency-name: actions/setup-python
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* feat: New Robustness Regression Attacker: Ridge Poissoner (#241)

* feat: adding adaptive and randflip initializers for regression poisoners

* feat: adding ridge-based regression poisoner

* test: adding unit tests for ridge-based regression poisoner

* chore: updating tutorial with ridge-based poisoner

* docs: updating regression poisoner docs with ridge regressor

* docs: adding docstrings for ridge regressor poisoner

* chore: fixing lint

* chore: updating docstrings for poisoners

* chore: updloading notebook file for regression poisoner tutorial

* docs: updating possible parameters in docstrings

* feat: new methods for measuring security privacy risk score (#254)

* feat: adding source code and tutorial for privacy risk score

* tests: adding unit test for privacy risk score metric

* docs: updating reference docstrings for privacy risk score metric

* docs: updating docs for example gallery for security module

* feat: adding tutorial for privacy risk score with different models

* chore: adding tutorial for example gallery

* chore: adding tutorial notebook files for docs section

* Update security.rst

---------

Co-authored-by: Cristian Muñoz <cristian.munoz@holisticai.com>

* feat: new xai metrics based on globa feature importance, local feature importance and surrogate  (#255)

* internal changes

* fix: pfi regression and shap

* update: shap and contrast

* chore: improved xai metrics

* fix: paper regression results

* ok

* chore:  xai-metrics updated

* chore: format files

* test: add test for new metrics

* docs: update documentation and docstring format

* chore: hatch dmt

---------

Co-authored-by: Kleyton da Costa <kleyton.vsc@gmail.com>

* chore: Improve Accuracy Degradation Profile Documentation  (#249)

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* fix: update dataset_shift code and plots

* fix: update dataset_shift code and plots

* fix: update dataset_shift code and plots

* fix: percent_degradation to ADP nomenclature

* fix: uptade documentation

* chore: clean adp tutorial

* chore: remove inccorect reference

* chore: format

* doc: fix docstring

---------

Co-authored-by: crismunoz <crisstrink@gmail.com>

* docs:update tutorials (#257)

* docs: updating docstrings for regression poissoners (#256)

* fix: load dataset (#259)

* Delete paper directory (#262)

* Delete README.rst

* Delete workflows directory (#263)

* Features/improvementes (#265)

* chore: push updates

* fix: compas and add description

* fix: format

---------

Co-authored-by: crismunoz <crisstrink@gmail.com>

* add: bias tradeoff example (#266)

* add: bank marketing description (#267)

* chore: updating hackaton notebook with privacy risk score interpretation (#271)

* docs: update documetnation (#274)

* fix: merge conflicts

* Features/update documentation (#276)

* chore: update documentation HAI

* feat: remove dataset dependence of sklearn (#277)

* feat: remove dataset dependece of sklearn

* fix: lastfm dataset name

* fix: repository name

* fix: format (#280)

* chore(deps): bump numpy from 1.26 to 2.2.0 (#281)

Bumps [numpy](https://github.com/numpy/numpy) from 1.26 to 2.2.0.
- [Release notes](https://github.com/numpy/numpy/releases)
- [Changelog](https://github.com/numpy/numpy/blob/main/doc/RELEASE_WALKTHROUGH.rst)
- [Commits](https://github.com/numpy/numpy/compare/v1.26.0...v2.2.0)

---
updated-dependencies:
- dependency-name: numpy
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* chore(deps): bump slackapi/slack-github-action from 1.27.0 to 2.0.0 (#278)

Bumps [slackapi/slack-github-action](https://github.com/slackapi/slack-github-action) from 1.27.0 to 2.0.0.
- [Release notes](https://github.com/slackapi/slack-github-action/releases)
- [Commits](https://github.com/slackapi/slack-github-action/compare/v1.27.0...v2.0.0)

---
updated-dependencies:
- dependency-name: slackapi/slack-github-action
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: Kleyton da Costa <44351707+Kleyt0n@users.noreply.github.com>
Co-authored-by: andrelfnovaes <40208986+andrelfnovaes@users.noreply.github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Franklin Cardenoso <44931423+fracarfer5@users.noreply.github.com>
Co-authored-by: Kleyton da Costa <kleyton.vsc@gmail.com>

* Update version and changelog

* fix: Update publish-workflow.yml (#283)

* Update publish-workflow.yml

* Create publish-slack-workflow.yml

* Update publish-workflow.yml

* Rename publish-workflow.yml to publish-pypi-workflow.yml

* chore: Update Workflow Names (#284)

* Update publish-pypi-workflow.yml

* Update publish-slack-workflow.yml

* Update publish-slack-workflow.yml (#285)

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: Kleyton da Costa <44351707+Kleyt0n@users.noreply.github.com>
Co-authored-by: andrelfnovaes <40208986+andrelfnovaes@users.noreply.github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Franklin Cardenoso <44931423+fracarfer5@users.noreply.github.com>
Co-authored-by: Kleyton da Costa <kleyton.vsc@gmail.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

* chore: Split dependencies (#293)

* fix: desintangle dependencies

* fix: organize jax pedendence

* chore: organize dependencies:

* chore: update dependencies

* chore: fix comments

* chore: fix jax dependencie

* chore: adding pyproject

* doc: update pip install option

* Update install.rst

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: Kleyton da Costa <44351707+Kleyt0n@users.noreply.github.com>
Co-authored-by: andrelfnovaes <40208986+andrelfnovaes@users.noreply.github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Franklin Cardenoso <44931423+fracarfer5@users.noreply.github.com>
Co-authored-by: Kleyton da Costa <kleyton.vsc@gmail.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
---
 README.md                                     |   1 +
 docs/source/getting_started/install.rst       |   5 +-
 pyproject.toml                                |  10 +-
 src/holisticai/security/metrics/_shapr.py     |  19 +-
 .../utils/feature_importances/__init__.py     |  35 ---
 .../_permutation_feature_importance.py        | 188 ------------
 .../utils/models/neighbors/_classification.py |  12 +-
 .../test_feature_importance_strategies.py     |   2 +-
 .../dataset_shift/test_plot_neighborhood.py   | 270 ------------------
 9 files changed, 36 insertions(+), 506 deletions(-)
 delete mode 100644 src/holisticai/utils/feature_importances/__init__.py
 delete mode 100644 src/holisticai/utils/feature_importances/_permutation_feature_importance.py
 delete mode 100644 tests/robustness/dataset_shift/test_plot_neighborhood.py

diff --git a/README.md b/README.md
index 2b769b5a..f1a1a685 100644
--- a/README.md
+++ b/README.md
@@ -30,6 +30,7 @@ Holistic AI currently focuses on five verticals of AI trustworthiness:
 
 ```bash
 pip install holisticai  # Basic installation
+pip install holisticai[datasets]  # add datasets and plot dependencies
 pip install holisticai[bias]  # Bias mitigation support
 pip install holisticai[explainability]  # For explainability metrics and plots
 pip install holisticai[all]  # Install all packages for bias and explainability
diff --git a/docs/source/getting_started/install.rst b/docs/source/getting_started/install.rst
index c5bcfafb..ae99a605 100644
--- a/docs/source/getting_started/install.rst
+++ b/docs/source/getting_started/install.rst
@@ -9,7 +9,10 @@ You can install the library with `pip` using the following command:
 
   # Basic installation of the library 
   pip install holisticai
-  
+
+  # Additional packages for handle datasets and visualization 
+  pip install holisticai[datasets]
+
   # bias mitigation support
   pip install holisticai[bias] 
 
diff --git a/pyproject.toml b/pyproject.toml
index ddcad07e..a7d59efa 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -25,19 +25,17 @@ classifiers = [
 dependencies = [
   "scikit-learn>=1.0.2",
   "pandas",
-  "matplotlib",
-  "networkx>=3.1",
-  "seaborn",
   "numpy>=1.25",
   "pybind11>=2.12",
   "pyarrow"
   ]
 
 [project.optional-dependencies]
+datasets = ["networkx>=3.1", "matplotlib", "seaborn",   "pybind11>=2.12",  "pyarrow", "fastparquet"]
 bias = ["networkx>=3.1", "pygad==3.3.1", "jax>=0.4.30", "jaxopt>=0.8.3", "optax>=0.2.3", "flax>=0.8.5"]
 explainability = ["lime>=0.2.0.1", "shap>=0.42.1"]
 security = ["jax>=0.4.30", "jaxopt>=0.8.3"]
-all = ["networkx>=3.1", "pygad==3.3.1", "lime>=0.2.0.1", "shap>=0.42.1",  "jax>=0.4.30", "jaxopt>=0.8.3", "optax>=0.2.3", "flax>=0.8.5"]
+all = ["networkx>=3.1", "pygad==3.3.1", "lime>=0.2.0.1", "shap>=0.42.1",  "jax>=0.4.30", "jaxopt>=0.8.3", "optax>=0.2.3", "flax>=0.8.5", "networkx>=3.1", "matplotlib", "seaborn",   "pybind11>=2.12",  "pyarrow", "fastparquet"]
 
 [project.urls]
 Documentation = "https://github.com/holistic-ai/holisticai#readme"
@@ -118,7 +116,9 @@ dependencies = [
   "jax",
   "jaxopt",
   "optax",
-  "flax"
+  "flax",
+  "pyarrow==19.0.0", 
+  "fastparquet"
 ]
 env-vars = { PYTHONPATH = "src" }
 
diff --git a/src/holisticai/security/metrics/_shapr.py b/src/holisticai/security/metrics/_shapr.py
index 42a07277..669264da 100644
--- a/src/holisticai/security/metrics/_shapr.py
+++ b/src/holisticai/security/metrics/_shapr.py
@@ -2,14 +2,20 @@
 
 from typing import TYPE_CHECKING, Union
 
-import jax.numpy as jnp
 import numpy as np
 import pandas as pd
 from holisticai.typing import ArrayLike
 from holisticai.utils.models.neighbors import KNeighborsClassifier
-from jax.nn import one_hot
 from sklearn.preprocessing import LabelEncoder
 
+try:
+    import jax.numpy as jnp
+    from jax.nn import one_hot
+except ImportError:
+    jnp = None
+    one_hot = None
+
+
 if TYPE_CHECKING:
     from numpy.typing import ArrayLike
 
@@ -48,13 +54,15 @@ def transform_label_to_numerical_label(labels: np.ndarray, le: LabelEncoder = No
     return np.array(labels)
 
 
-def check_and_transform_label_format(labels: np.ndarray) -> jnp.ndarray:
+def check_and_transform_label_format(labels: np.ndarray):
     """
     Check label format and transform to one-hot-encoded labels if necessary
 
     :param labels: An array of integer or string labels of shape `(nb_samples,)`, `(nb_samples, 1)` or `(nb_samples, nb_classes)`.
     :return: Labels with shape `(nb_samples, nb_classes)` (one-hot) or `(nb_samples,)` (index).
     """
+    if one_hot is None or jnp is None:
+        raise ImportError("jax or jax.nn is not installed. Please install it with `pip install jax jaxlib`.")
 
     labels = jnp.array(labels)
     return_one_hot = True
@@ -103,6 +111,9 @@ def __call__(
         train_size=1.0,
         aggregated=True,
     ) -> Union[np.ndarray, float]:
+        if one_hot is None or jnp is None:
+            raise ImportError("jax or jax.nn is not installed. Please install it with `pip install jax jaxlib`.")
+
         y_train, le = transform_label_to_numerical_label(y_train)
         y_test = transform_label_to_numerical_label(y_test, le)
         y_pred_train = transform_label_to_numerical_label(y_pred_train, le)
@@ -152,7 +163,7 @@ def shapr_score(
     y_pred_test: pd.Series,
     batch_size=500,
     train_size=1.0,
-) -> jnp.ndarray:
+):
     """
     Compute the SHAPr membership privacy risk metric [1]_ for the given classifier and training set.
 
diff --git a/src/holisticai/utils/feature_importances/__init__.py b/src/holisticai/utils/feature_importances/__init__.py
deleted file mode 100644
index 5d7f1ef1..00000000
--- a/src/holisticai/utils/feature_importances/__init__.py
+++ /dev/null
@@ -1,35 +0,0 @@
-from holisticai.utils.feature_importances._conditional import (
-    group_index_samples_by_learning_task,
-    group_mask_samples_by_learning_task,
-)
-from holisticai.utils.feature_importances._lime import (
-    LIMEImportanceCalculator,
-    compute_lime_feature_importance,
-)
-from holisticai.utils.feature_importances._permutation_feature_importance import (
-    PermutationFeatureImportanceCalculator,
-    compute_conditional_permutation_feature_importance,
-    compute_permutation_feature_importance,
-)
-from holisticai.utils.feature_importances._shap import (
-    SHAPImportanceCalculator,
-    compute_shap_feature_importance,
-)
-from holisticai.utils.feature_importances._surrogate_feature_importance import (
-    SurrogateFeatureImportanceCalculator,
-    compute_surrogate_feature_importance,
-)
-
-__all__ = [
-    "PermutationFeatureImportanceCalculator",
-    "compute_permutation_feature_importance",
-    "group_index_samples_by_learning_task",
-    "group_mask_samples_by_learning_task",
-    "SurrogateFeatureImportanceCalculator",
-    "compute_surrogate_feature_importance",
-    "LIMEImportanceCalculator",
-    "compute_lime_feature_importance",
-    "SHAPImportanceCalculator",
-    "compute_shap_feature_importance",
-    "compute_conditional_permutation_feature_importance",
-]
diff --git a/src/holisticai/utils/feature_importances/_permutation_feature_importance.py b/src/holisticai/utils/feature_importances/_permutation_feature_importance.py
deleted file mode 100644
index 7632c556..00000000
--- a/src/holisticai/utils/feature_importances/_permutation_feature_importance.py
+++ /dev/null
@@ -1,188 +0,0 @@
-from __future__ import annotations
-
-import os
-from typing import Any, Literal, Union, overload
-
-import numpy as np
-import pandas as pd
-from joblib import Parallel, delayed
-from numpy.random import RandomState
-from sklearn.metrics import accuracy_score, mean_squared_error
-
-from holisticai.datasets import Dataset
-from holisticai.utils._commons import get_columns, get_item
-from holisticai.utils._definitions import (
-    ConditionalImportances,
-    Importances,
-    ModelProxy,
-)
-from holisticai.utils.feature_importances import group_index_samples_by_learning_task
-
-metric_scores = {
-    "binary_classification": accuracy_score,
-    "regression": mean_squared_error,
-    "multi_classification": accuracy_score,
-}
-
-
-@overload
-def compute_permutation_feature_importance(
-    proxy: ModelProxy,
-    X: pd.DataFrame,
-    y: pd.Series,
-    n_repeats: int = 5,
-    n_jobs: int = -1,
-    random_state: Union[RandomState, int, None] = None,
-    importance_type: Literal["conditional"] = "conditional",
-) -> ConditionalImportances: ...
-
-
-@overload
-def compute_permutation_feature_importance(
-    proxy: ModelProxy,
-    X: pd.DataFrame,
-    y: pd.Series,
-    n_repeats: int = 5,
-    n_jobs: int = -1,
-    random_state: Union[RandomState, int, None] = None,
-) -> Importances: ...
-
-
-def compute_permutation_feature_importance(
-    proxy: ModelProxy,
-    X: pd.DataFrame,
-    y: pd.Series,
-    n_repeats: int = 5,
-    n_jobs: int = -1,
-    random_state: Union[RandomState, int, None] = None,
-    importance_type: Literal["standard", "conditional"] = "standard",
-) -> Union[Importances, ConditionalImportances]:
-    pfi = PermutationFeatureImportanceCalculator(n_repeats=n_repeats, n_jobs=n_jobs, random_state=random_state)
-    if importance_type == "conditional":
-        return compute_conditional_permutation_feature_importance(
-            proxy=proxy, X=X, y=y, n_repeats=n_repeats, n_jobs=n_jobs, random_state=random_state
-        )
-    return pfi.compute_importances(X=X, y=y, proxy=proxy)
-
-
-def compute_conditional_permutation_feature_importance(
-    proxy: ModelProxy,
-    X: pd.DataFrame,
-    y: pd.Series,
-    n_repeats: int = 5,
-    n_jobs: int = -1,
-    random_state: Union[RandomState, int, None] = None,
-) -> Union[Importances, ConditionalImportances]:
-    pfi = PermutationFeatureImportanceCalculator(n_repeats=n_repeats, n_jobs=n_jobs, random_state=random_state)
-    sample_groups = group_index_samples_by_learning_task(y, proxy.learning_task)
-    values = {}
-    for group_name, indexes in sample_groups.items():
-        values[group_name] = pfi.compute_importances(X=get_item(X, indexes), y=get_item(y, indexes), proxy=proxy)
-
-    return ConditionalImportances(values=values)
-
-
-class SklearnClassifier:
-    @staticmethod
-    def from_proxy(proxy):
-        class Wrapper:
-            predict = proxy.predict
-            predict_proba = proxy.predict_proba
-            classes = proxy.classes
-            fit = lambda x, y: None  # noqa: ARG005, E731
-            score = lambda x, y: accuracy_score(y, proxy.predict(x))  # noqa: E731
-
-        return Wrapper
-
-
-class SklearnRegressor:
-    @staticmethod
-    def from_proxy(proxy):
-        class Wrapper:
-            predict = proxy.predict
-            fit = lambda x, y: None  # noqa: ARG005, E731
-            score = lambda x, y: mean_squared_error(y, proxy.predict(x))  # noqa: E731
-
-        return Wrapper
-
-
-class PermutationFeatureImportanceCalculator:
-    def __init__(
-        self,
-        n_repeats: int = 5,
-        n_jobs: int = -1,
-        random_state: Union[RandomState, int, None] = None,
-        importance_type: str = "global",
-    ):
-        if random_state is None:
-            random_state = RandomState(42)
-        if isinstance(random_state, int):
-            random_state = RandomState(random_state)
-        self.n_repeats = n_repeats
-        self.n_jobs = n_jobs
-        self.random_state = random_state
-        self.importance_type = importance_type
-
-    def compute_importances(self, X: Any, y: Any, proxy: ModelProxy) -> Importances:
-        if proxy.learning_task == "regression":
-            sklearn_model = SklearnRegressor.from_proxy(proxy)
-
-        elif proxy.learning_task in ("binary_classification", "multi_classification"):
-            sklearn_model = SklearnClassifier.from_proxy(proxy)
-
-        from sklearn.inspection import permutation_importance
-
-        r = permutation_importance(sklearn_model, X, y, n_repeats=self.n_repeats, random_state=0, n_jobs=self.n_jobs)
-        feature_importance_values = np.abs(r["importances_mean"])
-
-        features = list(get_columns(X))
-        feature_importances = pd.DataFrame.from_dict(
-            {"Variable": features, "Importance": feature_importance_values}
-        ).sort_values("Importance", ascending=False)
-        feature_importances["Importance"] = feature_importances["Importance"] / feature_importances["Importance"].sum()
-        feature_names = list(feature_importances["Variable"].values)
-        importances = np.array(feature_importances["Importance"].values)
-        return Importances(values=importances, feature_names=feature_names)
-
-    def compute_importances_(self, dataset: Dataset, proxy: ModelProxy) -> Importances:
-        X = dataset["X"]
-        y = dataset["y"]
-        metric = metric_scores[proxy.learning_task]
-        baseline_score = metric(y, proxy.predict(X))
-        n_features = X.shape[1]
-
-        def _calculate_permutation_scores(predictor, X, y, col_idx, n_repeats):
-            scores = []
-            X_permuted = X.copy()
-            shuffling_idx = np.arange(X_permuted.shape[0])
-            for _ in range(n_repeats):
-                self.random_state.shuffle(shuffling_idx)
-                col = X_permuted.iloc[shuffling_idx, col_idx]
-                col.index = X_permuted.index
-                X_permuted[X_permuted.columns[col_idx]] = col
-                scores.append(metric(y, predictor(X_permuted)))
-            return np.array(scores)
-
-        n_jobs = os.cpu_count() if self.n_jobs == -1 else self.n_jobs
-
-        scores = list(
-            Parallel(n_jobs=n_jobs)(
-                delayed(_calculate_permutation_scores)(
-                    proxy.predict,
-                    X,
-                    y,
-                    col_idx,
-                    self.n_repeats,
-                )
-                for col_idx in range(n_features)
-            )
-        )
-        feature_importances = [np.mean(np.abs(baseline_score - scores[col])) for col in range(n_features)]
-        features = list(X.columns)
-        feature_importances = pd.DataFrame.from_dict(
-            {"Variable": features, "Importance": feature_importances}
-        ).sort_values("Importance", ascending=False)
-        feature_importances["Importance"] = feature_importances["Importance"] / feature_importances["Importance"].sum()
-        feature_names = list(feature_importances["Variable"].values)
-        importances = np.array(feature_importances["Importance"].values)
-        return Importances(values=importances, feature_names=feature_names)
diff --git a/src/holisticai/utils/models/neighbors/_classification.py b/src/holisticai/utils/models/neighbors/_classification.py
index d663ed9f..be4a7052 100644
--- a/src/holisticai/utils/models/neighbors/_classification.py
+++ b/src/holisticai/utils/models/neighbors/_classification.py
@@ -1,8 +1,16 @@
-import jax.numpy as jnp
-from jax import vmap
+try:
+    import jax.numpy as jnp
+    from jax import vmap
+except ImportError:
+    jnp = None
+    vmap = None
 
 
 class KNeighborsClassifier:
+    def __init__(self):
+        if jnp is None or vmap is None:
+            raise ImportError("jax or jax.nn is not installed. Please install it with `pip install jax jaxlib`.")
+
     def fit(self, X_train, y_train):
         self.X_train = jnp.array(X_train)
         self.y_train = jnp.array(y_train)
diff --git a/tests/commons/test_feature_importance_strategies.py b/tests/commons/test_feature_importance_strategies.py
index 95b1384b..0c5ad193 100644
--- a/tests/commons/test_feature_importance_strategies.py
+++ b/tests/commons/test_feature_importance_strategies.py
@@ -32,5 +32,5 @@ def test_permutation_feature_importance_call(input_data):
     fi_strategy = PermutationFeatureImportanceCalculator(random_state=RandomState(42))
     importance = fi_strategy.compute_importances(test['X'], test['y'], proxy=proxy)
     assert isinstance(importance, Importances)
-    assert np.isclose(importance['capital-gain'], 0.38461538461538486, atol=5e-2)
+    assert np.isclose(importance['capital-gain'], 0.44444444444444453, atol=5e-2)
     
\ No newline at end of file
diff --git a/tests/robustness/dataset_shift/test_plot_neighborhood.py b/tests/robustness/dataset_shift/test_plot_neighborhood.py
deleted file mode 100644
index 4a090028..00000000
--- a/tests/robustness/dataset_shift/test_plot_neighborhood.py
+++ /dev/null
@@ -1,270 +0,0 @@
-import pytest
-import numpy as np
-from unittest import mock
-from matplotlib import pyplot as plt
-
-# Import the functions to be tested
-from holisticai.robustness.plots._dataset_shift import (
-    plot_neighborhood,
-)
-
-@pytest.fixture
-def sample_data():
-    """
-    Fixture to generate sample data for testing.
-    Returns:
-        X (np.ndarray): Feature matrix of shape (100, 2).
-        y (np.ndarray): True labels of shape (100,).
-        y_pred (np.ndarray): Predicted labels of shape (100,).
-    """
-    np.random.seed(42)  # For reproducibility
-    X = np.random.rand(100, 2)
-    y = np.random.randint(0, 2, size=100)
-    y_pred = np.random.randint(0, 2, size=100)
-    return X, y, y_pred
-
-@pytest.fixture
-def indices_show_full():
-    """
-    Fixture to provide full indices for display.
-    Returns:
-        indices_show (np.ndarray): Indices from 0 to 99.
-    """
-    return np.arange(100)
-
-@pytest.mark.parametrize(
-    "n_neighbors, points_of_interest, vertical_offset, features_to_plot, indices_show",
-    [
-        (3, [0], 0.1, None, None),
-        (5, [10, 20], 0.2, ['Feature1', 'Feature2'], np.arange(100)),
-        (7, [50, 60, 70], 0.05, None, np.arange(100)),
-    ]
-)
-def test_plot_neighborhood_various_inputs(
-    sample_data,
-    n_neighbors,
-    points_of_interest,
-    vertical_offset,
-    features_to_plot,
-    indices_show
-):
-    """
-    Test plot_neighborhood with various input parameters.
-    """
-    X, y, y_pred = sample_data
-    if indices_show is None:
-        indices_show = np.arange(len(X))
-    else:
-        # Ensure indices_show is valid
-        assert np.all(np.isin(points_of_interest, indices_show)), \
-            "All points_of_interest must be in indices_show."
-
-    # Mock plt.show to prevent actual plotting during tests
-    with mock.patch("matplotlib.pyplot.show"):
-        plot_neighborhood(
-            X,
-            y,
-            y_pred,
-            n_neighbors,
-            points_of_interest,
-            vertical_offset=vertical_offset,
-            features_to_plot=features_to_plot,
-            indices_show=indices_show
-        )
-    # If no exceptions occur, test passes
-
-def test_plot_neighborhood_with_invalid_points(sample_data, indices_show_full):
-    """
-    Test plot_neighborhood raises ValueError when points_of_interest not in indices_show.
-    """
-    X, y, y_pred = sample_data
-    n_neighbors = 5
-    points_of_interest = [1000]  # Invalid index
-    indices_show = indices_show_full
-
-    with pytest.raises(ValueError, match=r"The point \d+ is not a point in 'indices_show'\."):
-        plot_neighborhood(
-            X,
-            y,
-            y_pred,
-            n_neighbors,
-            points_of_interest,
-            indices_show=indices_show
-        )
-
-def test_plot_neighborhood_with_insufficient_neighbors(sample_data, indices_show_full):
-    """
-    Test plot_neighborhood handles cases with insufficient neighbors gracefully.
-    """
-    X, y, y_pred = sample_data
-    n_neighbors = 150  # More neighbors than available points
-    points_of_interest = [0, 1]
-    indices_show = indices_show_full
-
-    with pytest.raises(ValueError):
-        plot_neighborhood(
-            X,
-            y,
-            y_pred,
-            n_neighbors,
-            points_of_interest,
-            indices_show=indices_show
-        )
-
-@pytest.mark.parametrize(
-    "features_to_plot",
-    [
-        None,
-        ['Feature1', 'Feature2']
-    ]
-)
-def test_plot_neighborhood_with_features(sample_data, features_to_plot):
-    """
-    Test plot_neighborhood with and without custom feature names.
-    """
-    X, y, y_pred = sample_data
-    n_neighbors = 3
-    points_of_interest = [0, 1]
-    indices_show = np.arange(len(X))
-
-    # Mock plt.show to prevent actual plotting during tests
-    with mock.patch("matplotlib.pyplot.show"):
-        plot_neighborhood(
-            X,
-            y,
-            y_pred,
-            n_neighbors,
-            points_of_interest,
-            features_to_plot=features_to_plot,
-            indices_show=indices_show
-        )
-
-@pytest.mark.skip(reason="no call to this test at the moment")
-def test_plot_neighborhood_plotting(sample_data, indices_show_full):
-    """
-    Test that plot_neighborhood calls the plotting functions correctly.
-    """
-    X, y, y_pred = sample_data
-    n_neighbors = 3
-    points_of_interest = [0, 1]
-    indices_show = indices_show_full
-
-    with mock.patch.object(plt, 'show') as mock_show, \
-         mock.patch.object(plt.Axes, 'scatter') as mock_scatter, \
-         mock.patch.object(plt.Axes, 'plot') as mock_plot, \
-         mock.patch.object(plt.Axes, 'set_xlabel') as mock_set_xlabel, \
-         mock.patch.object(plt.Axes, 'set_ylabel') as mock_set_ylabel, \
-         mock.patch('matplotlib.pyplot.title') as mock_title:
-        plot_neighborhood(
-            X,
-            y,
-            y_pred,
-            n_neighbors,
-            points_of_interest,
-            indices_show=indices_show
-        )
-
-        # Check that plotting functions were called
-        assert mock_scatter.call_count >= 1
-        assert mock_plot.call_count >= 1
-        mock_set_xlabel.assert_called()
-        mock_set_ylabel.assert_called()
-        mock_title.assert_called()
-        mock_show.assert_called_once()
-
-def test_plot_neighborhood_accuracy_calculation(sample_data, indices_show_full):
-    """
-    Test that accuracy is calculated correctly and text is added to the plot.
-    """
-    X, y, y_pred = sample_data
-    n_neighbors = 3
-    points_of_interest = [0]
-    indices_show = indices_show_full
-
-    with mock.patch("matplotlib.pyplot.show"), \
-         mock.patch("matplotlib.pyplot.text") as mock_text:
-        plot_neighborhood(
-            X,
-            y,
-            y_pred,
-            n_neighbors,
-            points_of_interest,
-            indices_show=indices_show
-        )
-
-        # Check that text was added to the plot
-        mock_text.assert_called()
-        # Extract the accuracy value from the call arguments
-        args, kwargs = mock_text.call_args
-        acc_text = args[2]
-        assert "Acc = " in acc_text
-
-def test_plot_neighborhood_with_custom_axes(sample_data):
-    """
-    Test plot_neighborhood when a custom matplotlib axis is provided.
-    """
-    X, y, y_pred = sample_data
-    n_neighbors = 3
-    points_of_interest = [0]
-    indices_show = np.arange(len(X))
-    fig, ax = plt.subplots()
-
-    with mock.patch("matplotlib.pyplot.show"):
-        plot_neighborhood(
-            X,
-            y,
-            y_pred,
-            n_neighbors,
-            points_of_interest,
-            ax=ax,
-            indices_show=indices_show
-        )
-        # Verify that the plot was drawn on the provided axis
-        assert ax.has_data()
-
-def test_plot_neighborhood_with_vertical_offset(sample_data):
-    """
-    Test plot_neighborhood with different vertical offsets.
-    """
-    X, y, y_pred = sample_data
-    n_neighbors = 3
-    points_of_interest = [0]
-    indices_show = np.arange(len(X))
-
-    vertical_offsets = [0, 0.1, 0.5]
-
-    for offset in vertical_offsets:
-        with mock.patch("matplotlib.pyplot.show"):
-            plot_neighborhood(
-                X,
-                y,
-                y_pred,
-                n_neighbors,
-                points_of_interest,
-                vertical_offset=offset,
-                indices_show=indices_show
-            )
-            # No exception means test passes
-
-@pytest.mark.xfail(reason="ConvexHull from scipy.spatial presents error when the hull is flat.")
-def test_plot_neighborhood_edge_cases():
-    """
-    Test plot_neighborhood with edge case inputs.
-    """
-    X = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])
-    y = np.array([0, 1, 1, 0])
-    y_pred = np.array([0, 1, 1, 1])
-    n_neighbors = 3
-    points_of_interest = [1]
-    indices_show = np.array([0, 1])
-
-    with mock.patch("matplotlib.pyplot.show"):
-        plot_neighborhood(
-            X,
-            y,
-            y_pred,
-            n_neighbors,
-            points_of_interest,
-            indices_show=indices_show
-        )
-        # No exception means test passes

From 2bc4d3b27c36b7f02491da36cc672db8eedd766b Mon Sep 17 00:00:00 2001
From: "github-actions[bot]" <github-actions[bot]@users.noreply.github.com>
Date: Wed, 12 Feb 2025 21:00:15 +0000
Subject: [PATCH 17/34] Update version and changelog

---
 CHANGELOG.md                | 10 ++++++++++
 src/holisticai/__about__.py |  2 +-
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 29384ea4..3d501f8b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,16 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.0.12] - 2025-02-12
+
+### 🐛 Bug Fixes
+
+- Update publish-workflow.yml (#283)
+
+### ⚙️ Miscellaneous Tasks
+
+- Update Workflow Names (#284)
+
 ## [1.0.11] - 2024-12-12
 
 ### ⚙️ Miscellaneous Tasks
diff --git a/src/holisticai/__about__.py b/src/holisticai/__about__.py
index 9eb1ebec..bd538f76 100644
--- a/src/holisticai/__about__.py
+++ b/src/holisticai/__about__.py
@@ -1 +1 @@
-__version__ = "1.0.11"
+__version__ = "1.0.12"

From 8c36b267bbbc539f7f1ec2b767e845febc4d1d61 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cristian=20Mu=C3=B1oz?= <cristian.munoz@holisticai.com>
Date: Mon, 3 Mar 2025 17:21:04 -0300
Subject: [PATCH 18/34] Develop (#297)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* chore: update files for new gitflow (#227)

* chore: update files for new-release

* chore: update files for new gitflow

* chore: update readme (#229)

* docs: update tutorials

* docs: update tutorials (#230)

* feat: new datasets and docs (#231)

* feat: new datasets and docs

* fix: fmt

* docs: rename lib (#234)

* fix: datasets labels (#245)

* feature: update dataset_shift module (#248)

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* fix: update dataset_shift code and plots

* fix: update dataset_shift code and plots

* fix: update dataset_shift code and plots

* fix: percent_degradation to ADP nomenclature

* chore(deps): bump actions/checkout from 4.1.7 to 4.2.2 (#250)

Bumps [actions/checkout](https://github.com/actions/checkout) from 4.1.7 to 4.2.2.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/v4.1.7...v4.2.2)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* chore(deps): bump actions/setup-python from 5.2.0 to 5.3.0 (#251)

Bumps [actions/setup-python](https://github.com/actions/setup-python) from 5.2.0 to 5.3.0.
- [Release notes](https://github.com/actions/setup-python/releases)
- [Commits](https://github.com/actions/setup-python/compare/v5.2.0...v5.3.0)

---
updated-dependencies:
- dependency-name: actions/setup-python
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* feat: New Robustness Regression Attacker: Ridge Poissoner (#241)

* feat: adding adaptive and randflip initializers for regression poisoners

* feat: adding ridge-based regression poisoner

* test: adding unit tests for ridge-based regression poisoner

* chore: updating tutorial with ridge-based poisoner

* docs: updating regression poisoner docs with ridge regressor

* docs: adding docstrings for ridge regressor poisoner

* chore: fixing lint

* chore: updating docstrings for poisoners

* chore: updloading notebook file for regression poisoner tutorial

* docs: updating possible parameters in docstrings

* feat: new methods for measuring security privacy risk score (#254)

* feat: adding source code and tutorial for privacy risk score

* tests: adding unit test for privacy risk score metric

* docs: updating reference docstrings for privacy risk score metric

* docs: updating docs for example gallery for security module

* feat: adding tutorial for privacy risk score with different models

* chore: adding tutorial for example gallery

* chore: adding tutorial notebook files for docs section

* Update security.rst

---------

Co-authored-by: Cristian Muñoz <cristian.munoz@holisticai.com>

* feat: new xai metrics based on globa feature importance, local feature importance and surrogate  (#255)

* internal changes

* fix: pfi regression and shap

* update: shap and contrast

* chore: improved xai metrics

* fix: paper regression results

* ok

* chore:  xai-metrics updated

* chore: format files

* test: add test for new metrics

* docs: update documentation and docstring format

* chore: hatch dmt

---------

Co-authored-by: Kleyton da Costa <kleyton.vsc@gmail.com>

* chore: Improve Accuracy Degradation Profile Documentation  (#249)

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* fix: update dataset_shift code and plots

* fix: update dataset_shift code and plots

* fix: update dataset_shift code and plots

* fix: percent_degradation to ADP nomenclature

* fix: uptade documentation

* chore: clean adp tutorial

* chore: remove inccorect reference

* chore: format

* doc: fix docstring

---------

Co-authored-by: crismunoz <crisstrink@gmail.com>

* docs:update tutorials (#257)

* docs: updating docstrings for regression poissoners (#256)

* fix: load dataset (#259)

* Delete paper directory (#262)

* Delete README.rst

* Delete workflows directory (#263)

* Features/improvementes (#265)

* chore: push updates

* fix: compas and add description

* fix: format

---------

Co-authored-by: crismunoz <crisstrink@gmail.com>

* add: bias tradeoff example (#266)

* add: bank marketing description (#267)

* chore: updating hackaton notebook with privacy risk score interpretation (#271)

* docs: update documetnation (#274)

* fix: merge conflicts

* Features/update documentation (#276)

* chore: update documentation HAI

* feat: remove dataset dependence of sklearn (#277)

* feat: remove dataset dependece of sklearn

* fix: lastfm dataset name

* fix: repository name

* fix: format (#280)

* chore(deps): bump numpy from 1.26 to 2.2.0 (#281)

Bumps [numpy](https://github.com/numpy/numpy) from 1.26 to 2.2.0.
- [Release notes](https://github.com/numpy/numpy/releases)
- [Changelog](https://github.com/numpy/numpy/blob/main/doc/RELEASE_WALKTHROUGH.rst)
- [Commits](https://github.com/numpy/numpy/compare/v1.26.0...v2.2.0)

---
updated-dependencies:
- dependency-name: numpy
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* chore(deps): bump slackapi/slack-github-action from 1.27.0 to 2.0.0 (#278)

Bumps [slackapi/slack-github-action](https://github.com/slackapi/slack-github-action) from 1.27.0 to 2.0.0.
- [Release notes](https://github.com/slackapi/slack-github-action/releases)
- [Commits](https://github.com/slackapi/slack-github-action/compare/v1.27.0...v2.0.0)

---
updated-dependencies:
- dependency-name: slackapi/slack-github-action
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* Rename rs_fair_topk_fa*ir_algorithm.rst to rs_fair_topk_fair_algorithm.rst

* Hotfix (#286)

* Update Main Branch (#279)

* chore: update files for new gitflow (#227)

Bumps [actions/checkout](https://github.com/actions/checkout) from 4.1.7 to 4.2.2.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/v4.1.7...v4.2.2)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* chore(deps): bump actions/setup-python from 5.2.0 to 5.3.0 (#251)

Bumps [actions/setup-python](https://github.com/actions/setup-python) from 5.2.0 to 5.3.0.
- [Release notes](https://github.com/actions/setup-python/releases)
- [Commits](https://github.com/actions/setup-python/compare/v5.2.0...v5.3.0)

---
updated-dependencies:
- dependency-name: actions/setup-python
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* feat: New Robustness Regression Attacker: Ridge Poissoner (#241)

---------

Co-authored-by: Cristian Muñoz <cristian.munoz@holisticai.com>

* feat: new xai metrics based on globa feature importance, local feature importance and surrogate  (#255)
---------

Co-authored-by: Kleyton da Costa <kleyton.vsc@gmail.com>

* chore: Improve Accuracy Degradation Profile Documentation  (#249)

---------

Co-authored-by: crismunoz <crisstrink@gmail.com>

* docs:update tutorials (#257)

---------

Co-authored-by: crismunoz <crisstrink@gmail.com>

* add: bias tradeoff example (#266)

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: Kleyton da Costa <44351707+Kleyt0n@users.noreply.github.com>
Co-authored-by: andrelfnovaes <40208986+andrelfnovaes@users.noreply.github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Franklin Cardenoso <44931423+fracarfer5@users.noreply.github.com>
Co-authored-by: Kleyton da Costa <kleyton.vsc@gmail.com>

* Update version and changelog

* chore: update release workflows  (#282)

* chore: update files for new gitflow (#227)

* chore: update files for new-release

* chore: update readme (#229)

* docs: update tutorials (#230)

* feat: new datasets and docs (#231)

* docs: rename lib (#234)

* fix: datasets labels (#245)

* feature: update dataset_shift module (#248)

* feature: update dataset_shift module

* fix: update dataset_shift code and plots

* fix: percent_degradation to ADP nomenclature

* chore(deps): bump actions/checkout from 4.1.7 to 4.2.2 (#250)

Bumps [actions/checkout](https://github.com/actions/checkout) from 4.1.7 to 4.2.2.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/v4.1.7...v4.2.2)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* chore(deps): bump actions/setup-python from 5.2.0 to 5.3.0 (#251)

Bumps [actions/setup-python](https://github.com/actions/setup-python) from 5.2.0 to 5.3.0.
- [Release notes](https://github.com/actions/setup-python/releases)
- [Commits](https://github.com/actions/setup-python/compare/v5.2.0...v5.3.0)

---
updated-dependencies:
- dependency-name: actions/setup-python
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* feat: New Robustness Regression Attacker: Ridge Poissoner (#241)

* feat: adding adaptive and randflip initializers for regression poisoners

* feat: adding ridge-based regression poisoner

* test: adding unit tests for ridge-based regression poisoner

* chore: updating tutorial with ridge-based poisoner

* docs: updating regression poisoner docs with ridge regressor

* docs: adding docstrings for ridge regressor poisoner

* chore: fixing lint

* chore: updating docstrings for poisoners

* chore: updloading notebook file for regression poisoner tutorial

* docs: updating possible parameters in docstrings

* feat: new methods for measuring security privacy risk score (#254)

* feat: adding source code and tutorial for privacy risk score

* tests: adding unit test for privacy risk score metric

* docs: updating reference docstrings for privacy risk score metric

* docs: updating docs for example gallery for security module

* feat: adding tutorial for privacy risk score with different models

* chore: adding tutorial for example gallery

* chore: adding tutorial notebook files for docs section

* Update security.rst

---------

Co-authored-by: Cristian Muñoz <cristian.munoz@holisticai.com>

* feat: new xai metrics based on globa feature importance, local feature importance and surrogate  (#255)

* internal changes

* fix: pfi regression and shap

* update: shap and contrast

* chore: improved xai metrics

* fix: paper regression results

* ok

* chore:  xai-metrics updated

* chore: format files

* test: add test for new metrics

* docs: update documentation and docstring format

* chore: hatch dmt

---------

Co-authored-by: Kleyton da Costa <kleyton.vsc@gmail.com>

* chore: Improve Accuracy Degradation Profile Documentation  (#249)

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* feature: update dataset_shift module

* fix: update dataset_shift code and plots

* fix: update dataset_shift code and plots

* fix: update dataset_shift code and plots

* fix: percent_degradation to ADP nomenclature

* fix: uptade documentation

* chore: clean adp tutorial

* chore: remove inccorect reference

* chore: format

* doc: fix docstring

---------

Co-authored-by: crismunoz <crisstrink@gmail.com>

* docs:update tutorials (#257)

* docs: updating docstrings for regression poissoners (#256)

* fix: load dataset (#259)

* Delete paper directory (#262)

* Delete README.rst

* Delete workflows directory (#263)

* Features/improvementes (#265)

* chore: push updates

* fix: compas and add description

* fix: format

---------

Co-authored-by: crismunoz <crisstrink@gmail.com>

* add: bias tradeoff example (#266)

* add: bank marketing description (#267)

* chore: updating hackaton notebook with privacy risk score interpretation (#271)

* docs: update documetnation (#274)

* fix: merge conflicts

* Features/update documentation (#276)

* chore: update documentation HAI

* feat: remove dataset dependence of sklearn (#277)

* feat: remove dataset dependece of sklearn

* fix: lastfm dataset name

* fix: repository name

* fix: format (#280)

* chore(deps): bump numpy from 1.26 to 2.2.0 (#281)

Bumps [numpy](https://github.com/numpy/numpy) from 1.26 to 2.2.0.
- [Release notes](https://github.com/numpy/numpy/releases)
- [Changelog](https://github.com/numpy/numpy/blob/main/doc/RELEASE_WALKTHROUGH.rst)
- [Commits](https://github.com/numpy/numpy/compare/v1.26.0...v2.2.0)

---
updated-dependencies:
- dependency-name: numpy
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* chore(deps): bump slackapi/slack-github-action from 1.27.0 to 2.0.0 (#278)

Bumps [slackapi/slack-github-action](https://github.com/slackapi/slack-github-action) from 1.27.0 to 2.0.0.
- [Release notes](https://github.com/slackapi/slack-github-action/releases)
- [Commits](https://github.com/slackapi/slack-github-action/compare/v1.27.0...v2.0.0)

---
updated-dependencies:
- dependency-name: slackapi/slack-github-action
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: Kleyton da Costa <44351707+Kleyt0n@users.noreply.github.com>
Co-authored-by: andrelfnovaes <40208986+andrelfnovaes@users.noreply.github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Franklin Cardenoso <44931423+fracarfer5@users.noreply.github.com>
Co-authored-by: Kleyton da Costa <kleyton.vsc@gmail.com>

* Update version and changelog

* fix: Update publish-workflow.yml (#283)

* Update publish-workflow.yml

* Create publish-slack-workflow.yml

* Update publish-workflow.yml

* Rename publish-workflow.yml to publish-pypi-workflow.yml

* chore: Update Workflow Names (#284)

* Update publish-pypi-workflow.yml

* Update publish-slack-workflow.yml

* Update publish-slack-workflow.yml (#285)

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: Kleyton da Costa <44351707+Kleyt0n@users.noreply.github.com>
Co-authored-by: andrelfnovaes <40208986+andrelfnovaes@users.noreply.github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Franklin Cardenoso <44931423+fracarfer5@users.noreply.github.com>
Co-authored-by: Kleyton da Costa <kleyton.vsc@gmail.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

* chore: Split dependencies (#293)

* fix: desintangle dependencies

* fix: organize jax pedendence

* chore: organize dependencies:

* chore: update dependencies

* chore: fix comments

* chore: fix jax dependencie

* chore: adding pyproject

* doc: update pip install option

* Update install.rst

* chore: update workflow to create namespace holisticai (#296)

* chore: update workflow to create namespace holisticai

* chore: update fmt

* chore: pyproject

* chore: fix fmt

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: Kleyton da Costa <44351707+Kleyt0n@users.noreply.github.com>
Co-authored-by: andrelfnovaes <40208986+andrelfnovaes@users.noreply.github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Franklin Cardenoso <44931423+fracarfer5@users.noreply.github.com>
Co-authored-by: Kleyton da Costa <kleyton.vsc@gmail.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
---
 .../workflows/publish-testpypi-workflow.yml   |  47 +++++++
 pyproject.toml                                |  12 +-
 ruff_default.toml                             |   2 +-
 src/holisticai/{ => bias}/__init__.py         |   0
 .../_numerical_repairer.py                    |   4 +-
 .../disparate_impact_remover/_utils.py        |  20 +--
 .../clustering/_kcenters.py                   |   4 +-
 .../clustering/_kmedoids.py                   |  10 +-
 .../decomposition/_scalable.py                |   9 +-
 .../decompositions/_scalable.py               |   6 +-
 .../adversarial_debiasing/models.py           |   3 +-
 .../adversarial_debiasing/transformer.py      |  45 ++++---
 .../inprocessing/commons/_moments_utils.py    |   3 +-
 .../commons/classification/_constraints.py    |  16 +--
 .../commons/classification/_objectives.py     |   3 +-
 .../commons/regression/_constraints.py        |   3 +-
 .../exponentiated_gradient/algorithm.py       |  16 +--
 .../exponentiated_gradient/transformer.py     |  16 +--
 .../fair_k_center_clustering/transformer.py   |  10 +-
 .../fair_k_mediam_clustering/algorithm.py     |   6 +-
 .../fair_k_mediam_clustering/transformer.py   |   8 +-
 .../fair_scoring_classifier/algorithm.py      |   3 +-
 .../fair_scoring_classifier/transformer.py    |   4 +-
 .../fair_scoring_classifier/utils.py          |  17 +--
 .../fairlet_clustering/transformer.py         |  14 +-
 .../grid_search/_grid_generator.py            |   9 +-
 .../inprocessing/grid_search/algorithm.py     |   6 +-
 .../matrix_factorization/blind_spot_aware.py  |  11 +-
 .../common_utils/propensity_utils.py          |   3 +-
 .../common_utils/utils.py                     |   3 +-
 .../debiasing_learning/algorithm.py           |   3 +-
 .../debiasing_learning/algorithm_utils.py     |   6 +-
 .../debiasing_learning/transformer.py         |  23 ++--
 .../popularity_propensity.py                  |  11 +-
 .../meta_fair_classifier/algorithm.py         |   3 +-
 .../meta_fair_classifier/constraints.py       |   3 +-
 .../prejudice_remover/algorithm_utils.py      |   3 +-
 .../inprocessing/prejudice_remover/losses.py  |  12 +-
 .../prejudice_remover/transformer.py          |  18 ++-
 .../two_sided_fairness/transformer.py         |   6 +-
 .../algorithm_utils/_bound_update.py          |  10 +-
 .../algorithm_utils/_method_utils.py          |  21 +--
 .../algorithm_utils/_methods.py               |  16 +--
 .../algorithm_utils/_utils.py                 |   6 +-
 .../transformer.py                            |  16 +--
 .../debiasing_exposure/algorithm_utils.py     |  17 +--
 .../debiasing_exposure/transformer.py         |  16 +--
 .../disparate_impact_remover_rs.py            |   9 +-
 .../algorithm_utils/mtable_generator.py       |  12 +-
 .../algorithm_utils/valitation_utils.py       |  14 +-
 .../postprocessing/fair_topk/transformer.py   |  19 ++-
 .../lp_debiaser/binary_balancer/algorithm.py  |   3 +-
 .../binary_balancer/algorithm_utils.py        |   3 +-
 .../binary_balancer/constraints.py            |   3 +-
 .../binary_balancer/transformer.py            |  16 +--
 .../multiclass_balancer/algorithm_utils.py    |   3 +-
 .../multiclass_balancer/constraints.py        |   6 +-
 .../mcmf_clustering/algorithm.py              |   9 +-
 .../randomized_threshold/algorithm.py         |   3 +-
 .../randomized_threshold/algorithm_utils.py   |   3 +-
 .../ml_debiaser/reduce2binary/algorithm.py    |  15 ++-
 .../algorithm.py                              |   3 +-
 .../algorithm_utils.py                        |   8 +-
 .../wasserstein_barycenters/algorithm.py      |   6 +-
 .../preprocessing/correlation_remover.py      |   6 +-
 .../preprocessing/disparate_impact_remover.py |   3 +-
 .../fairlet_clustering/transformer.py         |  12 +-
 .../learning_fair_representation.py           |  21 ++-
 .../mitigation/preprocessing/reweighing.py    |   6 +-
 .../bias/plots/_bias_exploratory_plots.py     |   3 +-
 .../bias/plots/_bias_regression_plots.py      |   9 +-
 src/holisticai/datasets/_dataset.py           |  13 +-
 src/holisticai/datasets/_load_dataset.py      | 122 ++++++++----------
 src/holisticai/datasets/_load_dataset.pyi     |  20 ++-
 src/holisticai/datasets/plots/_exploratory.py |   1 -
 .../efficacy/metrics/_classification.py       |   3 +-
 src/holisticai/explainability/__init__.py     |   0
 .../explainability/metrics/_classification.py |   8 +-
 .../explainability/metrics/_multiclass.py     |   8 +-
 .../explainability/metrics/_regression.py     |   8 +-
 .../_fluctuation_ratio.py                     |  10 +-
 .../global_feature_importance/_surrogate.py   |   3 +-
 .../_rank_consistency.py                      |   6 +-
 .../local_feature_importance/_stability.py    |   6 +-
 .../metrics/surrogate/_classification.py      |   6 +-
 .../metrics/surrogate/_clustering.py          |   3 +-
 .../metrics/surrogate/_regression.py          |   3 +-
 .../explainability/metrics/tree/_tree.py      |   3 +-
 src/holisticai/explainability/plots/_tree.py  |   9 +-
 src/holisticai/inspection/_lime.py            |  17 ++-
 .../inspection/_partial_dependence.py         |  11 +-
 .../inspection/_permutation_importance.py     |  21 ++-
 src/holisticai/inspection/_shap.py            |  12 +-
 .../inspection/_surrogate_importance.py       |  26 ++--
 src/holisticai/inspection/_utils.py           |   9 +-
 src/holisticai/pipeline/_pipeline.py          |   5 +-
 src/holisticai/pipeline/_pipeline_helper.py   |   3 +-
 src/holisticai/robustness/__init__.py         |   0
 .../attackers/classification/commons.py       |   4 +-
 .../attackers/classification/hop_skip_jump.py |  43 +++---
 .../zeroth_order_optimization.py              |  29 +++--
 .../attackers/regression/gb_attackers.py      |  25 ++--
 .../classification/_binary_classification.py  |   9 +-
 .../_accuracy_degradation_profile.py          |  31 +++--
 .../robustness/plots/_dataset_shift.py        |  12 +-
 src/holisticai/robustness/plots/_utils.py     |  12 +-
 src/holisticai/security/__init__.py           |   0
 .../security/commons/_black_box_attack.py     |   3 +-
 .../commons/data_minimization/_core.py        |  12 +-
 .../data_minimization/_modificators.py        |   3 +-
 .../commons/data_minimization/_selectors.py   |  17 ++-
 src/holisticai/security/metrics/__init__.py   |   6 +-
 .../security/metrics/_attribute_attack.py     |  11 +-
 .../security/metrics/_data_minimization.py    |   7 +-
 .../security/metrics/_privacy_risk_score.py   |   3 +-
 src/holisticai/security/metrics/_shapr.py     |  12 +-
 src/holisticai/security/metrics/_utils.py     |   3 +-
 .../security/mitigation/_anonymization.py     |  39 +++---
 src/holisticai/utils/_commons.py              |   6 +-
 src/holisticai/utils/_definitions.py          |  22 ++--
 src/holisticai/utils/_formatting.py           |   1 -
 src/holisticai/utils/_recommender_tools.py    |   6 +-
 src/holisticai/utils/_validation.py           |  15 ++-
 .../utils/models/cluster/_kcenters.py         |   4 +-
 .../utils/models/cluster/_kmedoids.py         |   6 +-
 .../utils/models/neighbors/_classification.py |   6 +-
 src/holisticai/utils/obj_rep/object_repr.py   |   4 +-
 .../utils/optimizers/_genetic_algorithm.py    |  18 ++-
 src/holisticai/utils/plots/_plots.py          |   9 +-
 src/holisticai/utils/plots/_utils.py          |  12 +-
 .../utils/surrogate_models/__init__.py        |  37 +++---
 .../utils/surrogate_models/_trees.py          |  19 +--
 .../utils/transformers/bias/_inprocessing.py  |   1 -
 .../transformers/bias/_postprocessing.py      |   1 -
 .../utils/transformers/bias/_preprocessing.py |   1 -
 135 files changed, 740 insertions(+), 743 deletions(-)
 create mode 100644 .github/workflows/publish-testpypi-workflow.yml
 rename src/holisticai/{ => bias}/__init__.py (100%)
 create mode 100644 src/holisticai/explainability/__init__.py
 create mode 100644 src/holisticai/robustness/__init__.py
 create mode 100644 src/holisticai/security/__init__.py

diff --git a/.github/workflows/publish-testpypi-workflow.yml b/.github/workflows/publish-testpypi-workflow.yml
new file mode 100644
index 00000000..b7665295
--- /dev/null
+++ b/.github/workflows/publish-testpypi-workflow.yml
@@ -0,0 +1,47 @@
+name: Publish PyPI
+
+on:
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/create-github-app-token@v1
+        id: app-token
+        with:
+          app-id: ${{ secrets.APPLICATION_ID }}
+          private-key: ${{ secrets.APPLICATION_PRIVATE_KEY }}
+
+      - name: Checkout code
+        uses: actions/checkout@v4.2.2
+        with:
+          fetch-tags: true
+          fetch-depth: 0
+          ref: main
+          token: ${{ steps.app-token.outputs.token }} # Needed to trigger other actions
+
+      - name: Set up Python
+        uses: actions/setup-python@v5.3.0
+        with:
+          python-version: "3.9"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install hatch
+
+      - name: Get Latest Release Version
+        id: get_release
+        run: |
+          latest_tag=$(git describe --tags `git rev-list --tags --max-count=1`)
+          echo "Latest release version: $latest_tag"
+          echo "tag=$latest_tag" >> $GITHUB_ENV # Save the tag to an environment variable
+
+      - name: Publish to PyPI
+        env:
+          HATCH_INDEX_USER: __token__
+          HATCH_INDEX_AUTH: ${{ secrets.PYPI_TOKEN }}
+        run: |
+          hatch build
+          hatch publish --repo test
diff --git a/pyproject.toml b/pyproject.toml
index a7d59efa..96d21f12 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -130,4 +130,14 @@ foo = ["which python"]
 env-vars = { PYTHONPATH = "src" }
 
 [tool.hatch.build.targets.wheel]
-packages = ["src/holisticai"]
+packages = [
+  "src/holisticai/bias",
+  "src/holisticai/explainability",
+  "src/holisticai/robustness",
+  "src/holisticai/efficacy",
+  "src/holisticai/inspection",
+  "src/holisticai/pipeline",
+  "src/holisticai/security",
+  "src/holisticai/typing",
+  "src/holisticai/utils"
+]
diff --git a/ruff_default.toml b/ruff_default.toml
index 04218b60..cd476da0 100644
--- a/ruff_default.toml
+++ b/ruff_default.toml
@@ -168,7 +168,7 @@ select = [
     "ICN001",
     "ICN002",
     "ICN003",
-    "INP001",
+    #"INP001",
     "INT001",
     "INT002",
     "INT003",
diff --git a/src/holisticai/__init__.py b/src/holisticai/bias/__init__.py
similarity index 100%
rename from src/holisticai/__init__.py
rename to src/holisticai/bias/__init__.py
diff --git a/src/holisticai/bias/mitigation/commons/disparate_impact_remover/_numerical_repairer.py b/src/holisticai/bias/mitigation/commons/disparate_impact_remover/_numerical_repairer.py
index b2f98cb3..9d78fb0b 100644
--- a/src/holisticai/bias/mitigation/commons/disparate_impact_remover/_numerical_repairer.py
+++ b/src/holisticai/bias/mitigation/commons/disparate_impact_remover/_numerical_repairer.py
@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 from holisticai.bias.mitigation.commons.disparate_impact_remover._categorical_repairer import CategoricalRepairer
 from holisticai.bias.mitigation.commons.disparate_impact_remover._utils import (
     freedman_diaconis_bin_size as bin_calculator,
@@ -46,7 +44,7 @@ def __init__(
         feature_to_repair: int,
         repair_level: float,
         kdd: bool = False,
-        features_to_ignore: Optional[list[str]] = None,
+        features_to_ignore: list[str] | None = None,
     ):
         if features_to_ignore is None:
             features_to_ignore = []
diff --git a/src/holisticai/bias/mitigation/commons/disparate_impact_remover/_utils.py b/src/holisticai/bias/mitigation/commons/disparate_impact_remover/_utils.py
index 6f6ad5ad..b42b3719 100644
--- a/src/holisticai/bias/mitigation/commons/disparate_impact_remover/_utils.py
+++ b/src/holisticai/bias/mitigation/commons/disparate_impact_remover/_utils.py
@@ -3,7 +3,6 @@
 import math
 import random
 from copy import deepcopy
-from typing import Union
 
 import numpy as np
 from holisticai.bias.mitigation.commons.disparate_impact_remover._categorical_feature import CategoricalFeature
@@ -32,7 +31,7 @@ def get_categories_count_norm(categories, all_stratified_groups, count_dict, gro
     dict
         The dictionary containing the normalized count for each category.
     """
-    norm = {
+    return {
         cat: SparseList(
             data=(
                 count_dict[cat][i] * (1.0 / len(group_features[group].data)) if group_features[group].data else 0.0
@@ -41,7 +40,6 @@ def get_categories_count_norm(categories, all_stratified_groups, count_dict, gro
         )
         for cat in categories
     }
-    return norm
 
 
 def gen_desired_dist(group_index, cat, col_id, median, repair_level, norm_counts, feature_to_remove, mode):
@@ -158,7 +156,7 @@ def get_categories_count(categories, all_stratified_groups, group_feature):
     dict
         The dictionary containing the count for each category.
     """
-    count_dict = {
+    return {
         cat: SparseList(
             data=(
                 group_feature[group].category_count[cat] if cat in group_feature[group].category_count else 0
@@ -168,8 +166,6 @@ def get_categories_count(categories, all_stratified_groups, group_feature):
         for cat in categories
     }
 
-    return count_dict
-
 
 def gen_desired_count(group_index, group, category, median, group_features, repair_level, categories_count):
     """
@@ -200,8 +196,7 @@ def gen_desired_count(group_index, group, category, median, group_features, repa
     med = median[category]
     size = len(group_features[group].data)
     count = categories_count[category][group_index]
-    des_count = math.floor(((1 - repair_level) * count) + (repair_level) * med * size)
-    return des_count
+    return math.floor(((1 - repair_level) * count) + (repair_level) * med * size)
 
 
 def flow_on_group_features(all_stratified_groups, group_features, repair_generator):
@@ -283,7 +278,7 @@ def get_count_norm(count, group_feature_data):
     return 0.0
 
 
-def get_column_type(values: Union[list, np.ndarray]):
+def get_column_type(values: list | np.ndarray):
     """
     Get the type of the column.
 
@@ -322,7 +317,8 @@ def get_median(values, kdd):
         The median of the list of values.
     """
     if not values:
-        raise ValueError("Cannot calculate median of list with no values!")
+        msg = "Cannot calculate median of list with no values!"
+        raise ValueError(msg)
 
     sorted_values = deepcopy(values)
     sorted_values.sort()  # Not calling `sorted` b/c `sorted_values` may not be list.
@@ -450,9 +446,7 @@ def make_histogram_bins(bin_size_calculator, data, col_id):
                 index_bins[bin_num].append(row_index)
                 break
 
-    index_bins = [b for b in index_bins if b]
-
-    return index_bins
+    return [b for b in index_bins if b]
 
 
 def freedman_diaconis_bin_size(feature_values):
diff --git a/src/holisticai/bias/mitigation/commons/fairlet_clustering/clustering/_kcenters.py b/src/holisticai/bias/mitigation/commons/fairlet_clustering/clustering/_kcenters.py
index b6441d10..5b20eeed 100644
--- a/src/holisticai/bias/mitigation/commons/fairlet_clustering/clustering/_kcenters.py
+++ b/src/holisticai/bias/mitigation/commons/fairlet_clustering/clustering/_kcenters.py
@@ -84,7 +84,7 @@ def assign(self):
         list
             The mapping of points to their closest centers.
         """
-        mapping = [
+        return [
             (
                 i,
                 sorted(
@@ -95,5 +95,3 @@ def assign(self):
             )
             for i in range(len(self.data))
         ]
-
-        return mapping
diff --git a/src/holisticai/bias/mitigation/commons/fairlet_clustering/clustering/_kmedoids.py b/src/holisticai/bias/mitigation/commons/fairlet_clustering/clustering/_kmedoids.py
index 6afac06e..4ca3005a 100644
--- a/src/holisticai/bias/mitigation/commons/fairlet_clustering/clustering/_kmedoids.py
+++ b/src/holisticai/bias/mitigation/commons/fairlet_clustering/clustering/_kmedoids.py
@@ -128,7 +128,8 @@ def _check_nonnegative_int(self, value, desc, strict=True):
         """
         negative = value is None or value <= 0 if strict else value is None or value < 0
         if negative or not isinstance(value, (int, np.integer)):
-            raise ValueError(f"{desc} should be a nonnegative integer. " f"{value} was given")
+            msg = f"{desc} should be a nonnegative integer. " f"{value} was given"
+            raise ValueError(msg)
 
     def _check_init_args(self):
         """
@@ -366,9 +367,7 @@ def _compute_inertia(self, distances):
 
         # Define inertia as the sum of the sample-distances
         # to closest cluster centers
-        inertia = np.sum(np.min(distances, axis=1))
-
-        return inertia
+        return np.sum(np.min(distances, axis=1))
 
     def _initialize_medoids(self, D, n_clusters, random_state_):
         """
@@ -399,7 +398,8 @@ def _initialize_medoids(self, D, n_clusters, random_state_):
             # to every other point. These are the initial medoids.
             medoids = np.argpartition(np.sum(D, axis=1), n_clusters - 1)[:n_clusters]
         else:
-            raise ValueError(f"init value '{self.init}' not recognized")
+            msg = f"init value '{self.init}' not recognized"
+            raise ValueError(msg)
 
         return medoids
 
diff --git a/src/holisticai/bias/mitigation/commons/fairlet_clustering/decomposition/_scalable.py b/src/holisticai/bias/mitigation/commons/fairlet_clustering/decomposition/_scalable.py
index 47dd0340..ea3d457f 100644
--- a/src/holisticai/bias/mitigation/commons/fairlet_clustering/decomposition/_scalable.py
+++ b/src/holisticai/bias/mitigation/commons/fairlet_clustering/decomposition/_scalable.py
@@ -165,7 +165,8 @@ def decompose(self, node, dataset, donelist, depth):
 
         if sum(R) == 0 or sum(B) == 0:
             if sum(R) == 0 and sum(B) == 0:
-                raise ValueError("One color class became empty for this node while the other did not")
+                msg = "One color class became empty for this node while the other did not"
+                raise ValueError(msg)
             return 0
 
         NR = 0
@@ -226,7 +227,8 @@ def decompose(self, node, dataset, donelist, depth):
             NB += excess_blue
 
         if self.balanced(p, q, NR, NB):
-            raise ValueError("Constructed node sets are unbalanced")
+            msg = "Constructed node sets are unbalanced"
+            raise ValueError(msg)
 
         reds = []
         blues = []
@@ -239,7 +241,8 @@ def decompose(self, node, dataset, donelist, depth):
                 donelist[j] = 1
 
         if len(reds) == NR and len(blues) == NB:
-            raise ValueError("Something went horribly wrong")
+            msg = "Something went horribly wrong"
+            raise ValueError(msg)
 
         return super().decompose(blues, reds, dataset) + sum(
             [self.decompose(child, dataset, donelist, depth + 1) for child in node.children]
diff --git a/src/holisticai/bias/mitigation/commons/fairlet_clustering/decompositions/_scalable.py b/src/holisticai/bias/mitigation/commons/fairlet_clustering/decompositions/_scalable.py
index 15c186d1..b17699ad 100644
--- a/src/holisticai/bias/mitigation/commons/fairlet_clustering/decompositions/_scalable.py
+++ b/src/holisticai/bias/mitigation/commons/fairlet_clustering/decompositions/_scalable.py
@@ -222,7 +222,8 @@ def _decompose(self, node, dataset, donelist, depth):
             NB += excess_blue
 
         if self.balanced(p, q, NR, NB):
-            raise ValueError("Constructed node sets are unbalanced")
+            msg = "Constructed node sets are unbalanced"
+            raise ValueError(msg)
 
         reds = []
         blues = []
@@ -235,7 +236,8 @@ def _decompose(self, node, dataset, donelist, depth):
                 donelist[j] = 1
 
         if len(reds) == NR and len(blues) == NB:
-            raise ValueError("Something went horribly wrong")
+            msg = "Something went horribly wrong"
+            raise ValueError(msg)
 
         return super()._decompose(blues, reds, dataset) + sum(
             [self._decompose(child, dataset, donelist, depth + 1) for child in node.children]
diff --git a/src/holisticai/bias/mitigation/inprocessing/adversarial_debiasing/models.py b/src/holisticai/bias/mitigation/inprocessing/adversarial_debiasing/models.py
index 17c5efec..7be40549 100644
--- a/src/holisticai/bias/mitigation/inprocessing/adversarial_debiasing/models.py
+++ b/src/holisticai/bias/mitigation/inprocessing/adversarial_debiasing/models.py
@@ -71,8 +71,7 @@ def adv_loss_fn(adversarial_params, classifier_params, batch, rng):
         _, y_logits = cls_state.apply_fn({"params": classifier_params}, x, trainable=True, rngs=rngs)
         _, z_logits = adv_state.apply_fn({"params": adversarial_params}, y_logits, y, trainable=True, rngs=rngs)
 
-        loss_adv = optax.sigmoid_binary_cross_entropy(z_logits, group).mean()
-        return loss_adv
+        return optax.sigmoid_binary_cross_entropy(z_logits, group).mean()
 
     (loss, (loss_cls, loss_adv)), grads = jax.value_and_grad(loss_fn, argnums=(0), has_aux=True)(
         cls_state.params, adv_state.params, batch, rng
diff --git a/src/holisticai/bias/mitigation/inprocessing/adversarial_debiasing/transformer.py b/src/holisticai/bias/mitigation/inprocessing/adversarial_debiasing/transformer.py
index bd400b3e..12c145b1 100644
--- a/src/holisticai/bias/mitigation/inprocessing/adversarial_debiasing/transformer.py
+++ b/src/holisticai/bias/mitigation/inprocessing/adversarial_debiasing/transformer.py
@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import logging
-from typing import Optional
 
 import jax
 import jax.numpy as jnp
@@ -26,7 +25,8 @@ def is_numeric(df):
         return all(pd.api.types.is_numeric_dtype(df[col]) for col in df.columns)
     if isinstance(df, np.ndarray):
         return np.issubdtype(df.dtype, np.number)
-    raise ValueError("Input must be a pandas DataFrame or numpy array.")
+    msg = "Input must be a pandas DataFrame or numpy array."
+    raise ValueError(msg)
 
 
 class AdversarialDebiasing(BMImp):
@@ -95,19 +95,19 @@ class AdversarialDebiasing(BMImp):
 
     def __init__(
         self,
-        features_dim: Optional[int] = None,
-        keep_prob: Optional[float] = 0.1,
-        hidden_size: Optional[int] = 128,
-        batch_size: Optional[int] = 32,
-        shuffle: Optional[bool] = True,
-        epochs: Optional[int] = 10,
-        learning_rate: Optional[float] = 0.01,
-        use_debias: Optional[bool] = True,
-        adversary_loss_weight: Optional[float] = 0.1,
-        verbose: Optional[int] = 1,
-        print_interval: Optional[int] = 100,
-        device: Optional[str] = "cpu",
-        seed: Optional[int] = None,
+        features_dim: int | None = None,
+        keep_prob: float | None = 0.1,
+        hidden_size: int | None = 128,
+        batch_size: int | None = 32,
+        shuffle: bool | None = True,
+        epochs: int | None = 10,
+        learning_rate: float | None = 0.01,
+        use_debias: bool | None = True,
+        adversary_loss_weight: float | None = 0.1,
+        verbose: int | None = 1,
+        print_interval: int | None = 100,
+        device: str | None = "cpu",
+        seed: int | None = None,
     ):
         # default classifier config
         self.features_dim = features_dim
@@ -179,7 +179,8 @@ def fit(
         params = self._load_data(X=X, y=y, group_a=group_a, group_b=group_b)
         x = pd.DataFrame(params["X"])
         if not is_numeric(x):
-            raise ValueError("Adversarial Debiasing only works with numeric features.")
+            msg = "Adversarial Debiasing only works with numeric features."
+            raise ValueError(msg)
 
         y = pd.Series(params["y"])
         group_a = pd.Series(params["group_a"])
@@ -245,7 +246,8 @@ def predict(self, X):
         np.ndarray: Predicted output per sample.
         """
         if not is_numeric(X):
-            raise ValueError("Adversarial Debiasing only works with numeric features.")
+            msg = "Adversarial Debiasing only works with numeric features."
+            raise ValueError(msg)
         p = self.predict_proba(X)
         return np.argmax(p, axis=1).ravel()
 
@@ -268,7 +270,8 @@ def predict_proba(self, X):
         np.ndarray: Predicted matrix probability per sample.
         """
         if not is_numeric(X):
-            raise ValueError("Adversarial Debiasing only works with numeric features.")
+            msg = "Adversarial Debiasing only works with numeric features."
+            raise ValueError(msg)
 
         proba = np.empty((X.shape[0], 2))
         proba[:, 1] = self._predict_proba(X)
@@ -294,7 +297,7 @@ def predict_score(self, X):
         np.ndarray: Predicted probability per sample.
         """
         if not is_numeric(X):
-            raise ValueError("Adversarial Debiasing only works with numeric features.")
+            msg = "Adversarial Debiasing only works with numeric features."
+            raise ValueError(msg)
 
-        p = self._predict(X).reshape([-1])
-        return p
+        return self._predict(X).reshape([-1])
diff --git a/src/holisticai/bias/mitigation/inprocessing/commons/_moments_utils.py b/src/holisticai/bias/mitigation/inprocessing/commons/_moments_utils.py
index 4fb0eb75..20bfdcb7 100644
--- a/src/holisticai/bias/mitigation/inprocessing/commons/_moments_utils.py
+++ b/src/holisticai/bias/mitigation/inprocessing/commons/_moments_utils.py
@@ -59,12 +59,11 @@ def project_lambda(self, lambda_vec):
             lambda_neg = -lambda_pos
             lambda_pos[lambda_pos < 0.0] = 0.0
             lambda_neg[lambda_neg < 0.0] = 0.0
-            lambda_projected = pd.concat(
+            return pd.concat(
                 [lambda_pos, lambda_neg],
                 keys=["+", "-"],
                 names=[_SIGNED, _EVENT, _GROUP_ID],
             )
-            return lambda_projected
         return lambda_vec
 
     def bound(self):
diff --git a/src/holisticai/bias/mitigation/inprocessing/commons/classification/_constraints.py b/src/holisticai/bias/mitigation/inprocessing/commons/classification/_constraints.py
index 8c9b3561..4e1e47c8 100644
--- a/src/holisticai/bias/mitigation/inprocessing/commons/classification/_constraints.py
+++ b/src/holisticai/bias/mitigation/inprocessing/commons/classification/_constraints.py
@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 import numpy as np
 import pandas as pd
 from holisticai.bias.mitigation.inprocessing.commons._conventions import (
@@ -43,7 +41,7 @@ def load_data(
         y,
         sensitive_features: pd.Series,
         event: pd.Series,
-        utilities: Optional[np.ndarray] = None,
+        utilities: np.ndarray | None = None,
     ):
         """
         Description
@@ -135,8 +133,7 @@ def get_signed_weight(row):
 
         signed_weights = self.tags.apply(get_signed_weight, axis=1)
         utility_diff = self.utilities[:, 1] - self.utilities[:, 0]
-        signed_weights = utility_diff.T * signed_weights
-        return signed_weights
+        return utility_diff.T * signed_weights
 
     def default_objective(self):
         return ErrorRate()
@@ -147,8 +144,7 @@ def gamma(self, predictor):
         utility_diff = self.utilities[:, 1] - self.utilities[:, 0]
         predictions = np.squeeze(predictor(self.X))
         pred = utility_diff.T * predictions + self.utilities[:, 0]
-        g_signed = -self.U.T.dot(pred) / self.total_samples
-        return g_signed  # self._gamma_signed(pred)
+        return -self.U.T.dot(pred) / self.total_samples
 
     def _gamma_signed(self, pred):
         self.tags[_PRED] = pred
@@ -157,7 +153,7 @@ def _gamma_signed(self, pred):
         expect_group_event = tags.groupby(level=[_EVENT, _GROUP_ID]).mean()
         expect_group_event[_UPPER_BOUND_DIFF] = self.ratio * expect_group_event[_PRED] - expect_event[_PRED]
         expect_group_event[_LOWER_BOUND_DIFF] = -expect_group_event[_PRED] + self.ratio * expect_event[_PRED]
-        gamma_signed = pd.concat(
+        return pd.concat(
             [
                 expect_group_event[_UPPER_BOUND_DIFF],
                 expect_group_event[_LOWER_BOUND_DIFF],
@@ -165,7 +161,6 @@ def _gamma_signed(self, pred):
             keys=["+", "-"],
             names=["signed", _EVENT, _GROUP_ID],
         )
-        return gamma_signed
 
     def _get_basis(self):
         pos_basis = pd.DataFrame()
@@ -185,7 +180,7 @@ def _get_basis(self):
         self.basis = {"+": pos_basis, "-": neg_basis}
 
     def _get_index_format(self):
-        index = (
+        return (
             pd.DataFrame(
                 [
                     {_SIGNED: signed, _EVENT: e, _GROUP_ID: g}
@@ -197,7 +192,6 @@ def _get_index_format(self):
             .set_index([_SIGNED, _EVENT, _GROUP_ID])
             .index
         )
-        return index
 
 
 class DemographicParity(ClassificationConstraint):
diff --git a/src/holisticai/bias/mitigation/inprocessing/commons/classification/_objectives.py b/src/holisticai/bias/mitigation/inprocessing/commons/classification/_objectives.py
index 8193e773..213402ab 100644
--- a/src/holisticai/bias/mitigation/inprocessing/commons/classification/_objectives.py
+++ b/src/holisticai/bias/mitigation/inprocessing/commons/classification/_objectives.py
@@ -27,5 +27,4 @@ def gamma(self, predictor):
         if isinstance(pred, np.ndarray):
             pred = np.squeeze(pred)
 
-        error = pd.Series(data=(self.tags[_LABEL] - pred).abs().mean(), index=self.index)
-        return error
+        return pd.Series(data=(self.tags[_LABEL] - pred).abs().mean(), index=self.index)
diff --git a/src/holisticai/bias/mitigation/inprocessing/commons/regression/_constraints.py b/src/holisticai/bias/mitigation/inprocessing/commons/regression/_constraints.py
index 024eca81..887b7078 100644
--- a/src/holisticai/bias/mitigation/inprocessing/commons/regression/_constraints.py
+++ b/src/holisticai/bias/mitigation/inprocessing/commons/regression/_constraints.py
@@ -97,7 +97,8 @@ def bound(self):
             A vector of bounds on group-level losses
         """
         if self.upper_bound is None:
-            raise ValueError("No Upper Bound")
+            msg = "No Upper Bound"
+            raise ValueError(msg)
         return pd.Series(self.upper_bound, index=self.index)
 
     def project_lambda(self, lambda_vec):
diff --git a/src/holisticai/bias/mitigation/inprocessing/exponentiated_gradient/algorithm.py b/src/holisticai/bias/mitigation/inprocessing/exponentiated_gradient/algorithm.py
index 02a9dcf7..c84e8cee 100644
--- a/src/holisticai/bias/mitigation/inprocessing/exponentiated_gradient/algorithm.py
+++ b/src/holisticai/bias/mitigation/inprocessing/exponentiated_gradient/algorithm.py
@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import sys
-from typing import Optional
 
 import numpy as np
 import pandas as pd
@@ -31,12 +30,12 @@ def __init__(
         self,
         estimator,
         constraints,
-        eps: Optional[float] = 0.01,
-        max_iter: Optional[int] = 50,
-        nu: Optional[float] = None,
-        eta0: Optional[float] = 2.0,
-        verbose: Optional[int] = 0,
-        seed: Optional[int] = None,
+        eps: float | None = 0.01,
+        max_iter: int | None = 50,
+        nu: float | None = None,
+        eta0: float | None = 2.0,
+        verbose: int | None = 0,
+        seed: int | None = None,
     ):
         self.estimator = estimator
         self.constraints = constraints
@@ -55,8 +54,7 @@ def fit(self, X, y, **kwargs):
 
         def compute_default_nu(h):
             absolute_error = (h(X) - self.constraints.y_as_series).abs()
-            nu = ACCURACY_MUL * absolute_error.std() / np.sqrt(self.constraints.total_samples)
-            return nu
+            return ACCURACY_MUL * absolute_error.std() / np.sqrt(self.constraints.total_samples)
 
         eta = self.eta0 / B
         gap_LP = np.inf
diff --git a/src/holisticai/bias/mitigation/inprocessing/exponentiated_gradient/transformer.py b/src/holisticai/bias/mitigation/inprocessing/exponentiated_gradient/transformer.py
index 14fbc4b2..92552ce4 100644
--- a/src/holisticai/bias/mitigation/inprocessing/exponentiated_gradient/transformer.py
+++ b/src/holisticai/bias/mitigation/inprocessing/exponentiated_gradient/transformer.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Literal, Optional
+from typing import Literal
 
 import numpy as np
 from holisticai.bias.mitigation.inprocessing.commons.classification import _constraints as cc
@@ -93,15 +93,15 @@ class ExponentiatedGradientReduction(BaseEstimator, ClassifierMixin, BMImp):
     def __init__(
         self,
         constraints: str = "EqualizedOdds",
-        eps: Optional[float] = 0.01,
-        max_iter: Optional[int] = 50,
-        nu: Optional[float] = None,
-        eta0: Optional[float] = 2.0,
+        eps: float | None = 0.01,
+        max_iter: int | None = 50,
+        nu: float | None = None,
+        eta0: float | None = 2.0,
         loss: str = "ZeroOne",
-        min_val: Optional[float] = None,
-        max_val: Optional[float] = None,
+        min_val: float | None = None,
+        max_val: float | None = None,
         upper_bound: float = 0.01,
-        verbose: Optional[int] = 0,
+        verbose: int | None = 0,
         estimator=None,
         seed: int = 0,
     ):
diff --git a/src/holisticai/bias/mitigation/inprocessing/fair_k_center_clustering/transformer.py b/src/holisticai/bias/mitigation/inprocessing/fair_k_center_clustering/transformer.py
index f0067d09..42cf9211 100644
--- a/src/holisticai/bias/mitigation/inprocessing/fair_k_center_clustering/transformer.py
+++ b/src/holisticai/bias/mitigation/inprocessing/fair_k_center_clustering/transformer.py
@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 import numpy as np
 from holisticai.bias.mitigation.inprocessing.fair_k_center_clustering.algorithms import (
     fair_k_center_approx,
@@ -63,10 +61,10 @@ class FairKCenterClustering(BaseEstimator, BMImp):
 
     def __init__(
         self,
-        req_nr_per_group: Optional[list] = None,
-        nr_initially_given: Optional[int] = 100,
-        strategy: Optional[str] = "Fair K-Center",
-        seed: Optional[int] = None,
+        req_nr_per_group: list | None = None,
+        nr_initially_given: int | None = 100,
+        strategy: str | None = "Fair K-Center",
+        seed: int | None = None,
     ):
         if req_nr_per_group is None:
             req_nr_per_group = [200, 200]
diff --git a/src/holisticai/bias/mitigation/inprocessing/fair_k_mediam_clustering/algorithm.py b/src/holisticai/bias/mitigation/inprocessing/fair_k_mediam_clustering/algorithm.py
index d609bf56..14302bb1 100644
--- a/src/holisticai/bias/mitigation/inprocessing/fair_k_mediam_clustering/algorithm.py
+++ b/src/holisticai/bias/mitigation/inprocessing/fair_k_mediam_clustering/algorithm.py
@@ -30,13 +30,11 @@ def _compute_cost(self, centers):
         for gid in self.group_ids:
             group_cost = np.mean(np.amin(self.distances[np.ix_(self.p_attr == gid, centers)], axis=1))
             group_costs.append(group_cost)
-        cost = np.max(group_costs)
-        return cost
+        return np.max(group_costs)
 
     def _compute_new_assigment(self, centers):
         centers = np.array(centers, dtype=np.int32)
-        assignment = centers[np.argmin(self.distances[np.ix_(np.arange(self.n), centers)], axis=1)]
-        return assignment
+        return centers[np.argmin(self.distances[np.ix_(np.arange(self.n), centers)], axis=1)]
 
     def fit(self, X, p_attr):
         self.n = len(X)
diff --git a/src/holisticai/bias/mitigation/inprocessing/fair_k_mediam_clustering/transformer.py b/src/holisticai/bias/mitigation/inprocessing/fair_k_mediam_clustering/transformer.py
index b28e85ac..e00fb906 100644
--- a/src/holisticai/bias/mitigation/inprocessing/fair_k_mediam_clustering/transformer.py
+++ b/src/holisticai/bias/mitigation/inprocessing/fair_k_mediam_clustering/transformer.py
@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 import numpy as np
 from holisticai.bias.mitigation.inprocessing.fair_k_mediam_clustering.algorithm import KMediamClusteringAlgorithm
 from holisticai.utils.transformers.bias import BMInprocessing as BMImp
@@ -54,9 +52,9 @@ def __init__(
         self,
         n_clusters: int = 2,
         max_iter: int = 1000,
-        seed: Optional[int] = None,
-        strategy: Optional[str] = "LS",
-        verbose: Optional[int] = 0,
+        seed: int | None = None,
+        strategy: str | None = "LS",
+        verbose: int | None = 0,
     ):
         self.n_clusters = n_clusters
         self.max_iter = max_iter
diff --git a/src/holisticai/bias/mitigation/inprocessing/fair_scoring_classifier/algorithm.py b/src/holisticai/bias/mitigation/inprocessing/fair_scoring_classifier/algorithm.py
index e64b519a..371624f7 100644
--- a/src/holisticai/bias/mitigation/inprocessing/fair_scoring_classifier/algorithm.py
+++ b/src/holisticai/bias/mitigation/inprocessing/fair_scoring_classifier/algorithm.py
@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import logging
-from typing import Optional
 
 import numpy as np
 from holisticai.bias.mitigation.inprocessing.fair_scoring_classifier.utils import get_class_count, get_class_indexes
@@ -26,7 +25,7 @@ def __init__(
         objectives: str,
         fairness_groups: list,
         fairness_labels: list,
-        constraints: Optional[dict] = None,
+        constraints: dict | None = None,
         lambda_bound: int = 9,
         time_limit: int = 100,
         verbose: int = 0,
diff --git a/src/holisticai/bias/mitigation/inprocessing/fair_scoring_classifier/transformer.py b/src/holisticai/bias/mitigation/inprocessing/fair_scoring_classifier/transformer.py
index 19722e88..cccf18c7 100644
--- a/src/holisticai/bias/mitigation/inprocessing/fair_scoring_classifier/transformer.py
+++ b/src/holisticai/bias/mitigation/inprocessing/fair_scoring_classifier/transformer.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Literal, Optional
+from typing import Literal
 
 import numpy as np
 import pandas as pd
@@ -48,7 +48,7 @@ class FairScoreClassifier(BaseEstimator, BMImp):
     def __init__(
         self,
         objectives: Literal["a", "ab"],
-        constraints: Optional[dict] = None,
+        constraints: dict | None = None,
         lambda_bound: int = 9,
         time_limit: int = 100,
         verbose: int = 0,
diff --git a/src/holisticai/bias/mitigation/inprocessing/fair_scoring_classifier/utils.py b/src/holisticai/bias/mitigation/inprocessing/fair_scoring_classifier/utils.py
index 5e89ce0c..458be911 100644
--- a/src/holisticai/bias/mitigation/inprocessing/fair_scoring_classifier/utils.py
+++ b/src/holisticai/bias/mitigation/inprocessing/fair_scoring_classifier/utils.py
@@ -17,8 +17,7 @@ def get_indexes_from_names(df, names):
     -------
     list : list of index
     """
-    indexes = [df.columns.get_loc(item) for item in names]
-    return indexes
+    return [df.columns.get_loc(item) for item in names]
 
 
 def process_y(y):
@@ -36,8 +35,7 @@ def process_y(y):
     -------
     y_processed (list of labels)
     """
-    y_processed = [i for line in y for i, val in enumerate(line) if val == 1]
-    return y_processed
+    return [i for line in y for i, val in enumerate(line) if val == 1]
 
 
 def get_majority_class(y):
@@ -210,8 +208,7 @@ def predict(x, l_lists):
 
 
 def format_labels(y):
-    y_formatted = [i for labels in y for i in range(len(labels)) if labels[i] == 1]
-    return y_formatted
+    return [i for labels in y for i in range(len(labels)) if labels[i] == 1]
 
 
 def get_accuracy(x, y, l_lists):
@@ -238,15 +235,11 @@ def get_accuracy(x, y, l_lists):
     y_pred = predict(x, l_lists)
     y = format_labels(y)
     y_pred = format_labels(y_pred)
-    accuracy = accuracy_score(y, y_pred)
-
-    return accuracy
+    return accuracy_score(y, y_pred)
 
 
 def get_balanced_accuracy(x, y, l_lists):
     y_pred = predict(x, l_lists)
     y = format_labels(y)
     y_pred = format_labels(y_pred)
-    balanced_accuracy = balanced_accuracy_score(y, y_pred)
-
-    return balanced_accuracy
+    return balanced_accuracy_score(y, y_pred)
diff --git a/src/holisticai/bias/mitigation/inprocessing/fairlet_clustering/transformer.py b/src/holisticai/bias/mitigation/inprocessing/fairlet_clustering/transformer.py
index 9c8aba40..76385b8a 100644
--- a/src/holisticai/bias/mitigation/inprocessing/fairlet_clustering/transformer.py
+++ b/src/holisticai/bias/mitigation/inprocessing/fairlet_clustering/transformer.py
@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional, Union
-
 import numpy as np
 from holisticai.bias.mitigation.commons.fairlet_clustering.decompositions import (
     DecompositionMixin,
@@ -65,12 +63,12 @@ class FairletClustering(BaseEstimator, BMImp):
 
     def __init__(
         self,
-        n_clusters: Optional[int],
-        decomposition: Union[str, DecompositionMixin] = "Vanilla",
-        clustering_model: Optional[str] = "KCenters",
-        p: Optional[str] = 1,
-        q: Optional[float] = 3,
-        seed: Optional[int] = None,
+        n_clusters: int | None,
+        decomposition: str | DecompositionMixin = "Vanilla",
+        clustering_model: str | None = "KCenters",
+        p: str | None = 1,
+        q: float | None = 3,
+        seed: int | None = None,
     ):
         if decomposition in ["Scalable", "Vanilla"]:
             self.decomposition = DECOMPOSITION_CATALOG[decomposition](p=p, q=q)
diff --git a/src/holisticai/bias/mitigation/inprocessing/grid_search/_grid_generator.py b/src/holisticai/bias/mitigation/inprocessing/grid_search/_grid_generator.py
index ce64fb55..ebb3b404 100644
--- a/src/holisticai/bias/mitigation/inprocessing/grid_search/_grid_generator.py
+++ b/src/holisticai/bias/mitigation/inprocessing/grid_search/_grid_generator.py
@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import logging
-from typing import Optional
 
 import numpy as np
 import pandas as pd
@@ -18,7 +17,7 @@ def __init__(
         self,
         grid_size: int = 5,
         grid_limit: float = 2.0,
-        neg_allowed: Optional[np.ndarray] = None,
+        neg_allowed: np.ndarray | None = None,
         force_L1_norm: bool = True,
     ):
         """
@@ -73,8 +72,7 @@ def _generate_coefs(self):
         neg_coefs = -pos_coefs.copy()
         pos_coefs[pos_coefs < 0] = 0.0
         neg_coefs[neg_coefs < 0] = 0.0
-        lambda_vector = {"+": pos_coefs, "-": neg_coefs}
-        return lambda_vector
+        return {"+": pos_coefs, "-": neg_coefs}
 
     def _build_grid(self, n_units):
         """
@@ -93,8 +91,7 @@ def _build_grid(self, n_units):
                 f"Warning: The desired grid size was not reached. {len(self.accumulator)} points were generated."
             )
 
-        xs = np.array(self.accumulator) * self.grid_limit / n_units
-        return xs
+        return np.array(self.accumulator) * self.grid_limit / n_units
 
     def _accumulate_integer_grid(self, index, max_val):
         """
diff --git a/src/holisticai/bias/mitigation/inprocessing/grid_search/algorithm.py b/src/holisticai/bias/mitigation/inprocessing/grid_search/algorithm.py
index be31c4a8..ca755c9c 100644
--- a/src/holisticai/bias/mitigation/inprocessing/grid_search/algorithm.py
+++ b/src/holisticai/bias/mitigation/inprocessing/grid_search/algorithm.py
@@ -101,7 +101,8 @@ def fit(self, X: Any, y: Any, sensitive_features: Any):
             )
         )
         if not results:
-            raise ValueError("No results were generated. This is likely due to an issue with the grid.")
+            msg = "No results were generated. This is likely due to an issue with the grid."
+            raise ValueError(msg)
 
         def loss_fct(result):
             return (1 - self.constraint_weight) * result["objective"] + self.constraint_weight * result["gamma"].max()
@@ -164,8 +165,7 @@ def _generate_grid(self) -> Any:
 
         # Generar la grid de coeficientes
         grid = generator.generate_grid(self.constraint)
-        grid = grid.loc[:, ~(grid == 0).all(axis=0)]
-        return grid
+        return grid.loc[:, ~(grid == 0).all(axis=0)]
 
     def _fit_estimator(self, X: Any, lambda_vec: Any):
         weights = self._compute_weights(lambda_vec)
diff --git a/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/blind_spot_aware.py b/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/blind_spot_aware.py
index 9b754506..2324b3f8 100644
--- a/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/blind_spot_aware.py
+++ b/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/blind_spot_aware.py
@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import logging
-from typing import Optional
 
 import numpy as np
 from holisticai.utils.models.recommender._rsbase import RecommenderSystemBase
@@ -54,11 +53,11 @@ class BlindSpotAwareMF(BMImp, RecommenderSystemBase):
     def __init__(
         self,
         K: int = 10,
-        beta: Optional[float] = 0.002,
-        steps: Optional[int] = 200,
-        alpha: Optional[float] = 0.002,
-        lamda: Optional[float] = 0.2,
-        verbose: Optional[int] = 0,
+        beta: float | None = 0.002,
+        steps: int | None = 200,
+        alpha: float | None = 0.002,
+        lamda: float | None = 0.2,
+        verbose: int | None = 0,
     ):
         self.beta = beta
         self.steps = steps
diff --git a/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/common_utils/propensity_utils.py b/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/common_utils/propensity_utils.py
index 4c7ef8a5..c5fecbc9 100644
--- a/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/common_utils/propensity_utils.py
+++ b/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/common_utils/propensity_utils.py
@@ -6,8 +6,7 @@ def constant_propensity(rmat, numItems):
     numObservations = np.ma.count(rmat)
     numUsers, numItems = np.shape(rmat)
     scale = numUsers * numItems
-    inversePropensities = np.ones((numUsers, numItems), dtype=np.longdouble) * scale / numObservations
-    return inversePropensities
+    return np.ones((numUsers, numItems), dtype=np.longdouble) * scale / numObservations
 
 
 def popularity_model_propensity(rmat):
diff --git a/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/common_utils/utils.py b/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/common_utils/utils.py
index 9c2b2573..d8bc0025 100644
--- a/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/common_utils/utils.py
+++ b/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/common_utils/utils.py
@@ -8,8 +8,7 @@
 def calculate_popularity_model(ratings):
     propensity_score = [float(np.count_nonzero(ratings[:, i])) / ratings.shape[0] for i in range(ratings.shape[1])]
     temp = np.array(propensity_score)
-    temp = temp.reshape((1, len(temp)))
-    return temp
+    return temp.reshape((1, len(temp)))
 
 
 def erros(P_s, Q_s, R_s, W_s, lamda, beta):
diff --git a/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/debiasing_learning/algorithm.py b/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/debiasing_learning/algorithm.py
index 502ea87b..0a94b378 100644
--- a/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/debiasing_learning/algorithm.py
+++ b/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/debiasing_learning/algorithm.py
@@ -33,10 +33,9 @@ def train(self, train_observations, inv_propensities, start_vector=None):
             if self.clip_val >= 0:
                 tempInvPropensities = np.clip(tempInvPropensities, a_min=0, a_max=self.clip_val)
 
-        parameters = self.optimize_debiasing_parameters(
+        return self.optimize_debiasing_parameters(
             train_observations, tempInvPropensities, self.lamda, start_vec=start_vector
         )
-        return parameters
 
     def optimize_debiasing_parameters(self, observed_ratings, inverse_propensities, l2_regularization, start_vec=None):
         metricMode = get_metric_mode(self.metric)
diff --git a/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/debiasing_learning/algorithm_utils.py b/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/debiasing_learning/algorithm_utils.py
index b45fa437..7abff910 100644
--- a/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/debiasing_learning/algorithm_utils.py
+++ b/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/debiasing_learning/algorithm_utils.py
@@ -16,7 +16,7 @@ def process_propensities(observed_ratings, inverse_propensities):
     else:
         inversePropensities = np.array(inverse_propensities, dtype=np.longdouble, copy=True)
 
-    inversePropensities = np.ma.array(
+    return np.ma.array(
         inversePropensities,
         dtype=np.longdouble,
         copy=False,
@@ -24,14 +24,12 @@ def process_propensities(observed_ratings, inverse_propensities):
         fill_value=0,
         hard_mask=True,
     )
-    return inversePropensities
 
 
 def predict_scores(user_vectors, item_vectors, user_biases, item_biases, global_bias, use_bias=True):
     rawScores = np.dot(user_vectors, item_vectors.T)
     if use_bias:
-        biasedScores = rawScores + user_biases[:, None] + item_biases[None, :] + global_bias
-        return biasedScores
+        return rawScores + user_biases[:, None] + item_biases[None, :] + global_bias
     return rawScores
 
 
diff --git a/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/debiasing_learning/transformer.py b/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/debiasing_learning/transformer.py
index 1a1847fc..eafaeddb 100644
--- a/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/debiasing_learning/transformer.py
+++ b/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/debiasing_learning/transformer.py
@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 import numpy as np
 import scipy
 from holisticai.bias.mitigation.inprocessing.matrix_factorization.debiasing_learning.algorithm import (
@@ -66,14 +64,14 @@ class DebiasingLearningMF(BMImp, RecommenderSystemBase):
 
     def __init__(
         self,
-        K: Optional[int] = 10,
-        normalization: Optional[str] = "Vanilla",
-        lamda: Optional[float] = 0.02,
-        metric: Optional[str] = "mse",
-        bias_mode: Optional[str] = None,
-        clip_val: Optional[float] = -1,
-        seed: Optional[int] = None,
-        verbose: Optional[int] = 0,
+        K: int | None = 10,
+        normalization: str | None = "Vanilla",
+        lamda: float | None = 0.02,
+        metric: str | None = "mse",
+        bias_mode: str | None = None,
+        clip_val: float | None = -1,
+        seed: int | None = None,
+        verbose: int | None = 0,
     ):
         self.seed = seed
         self.normalization = normalization
@@ -94,7 +92,7 @@ def __init__(
         )
         # self.params = [lamda, K, clipVal, bias_mode]
 
-    def fit(self, X: Optional[np.ndarray], propensities: Optional[np.ndarray] = None):
+    def fit(self, X: np.ndarray | None, propensities: np.ndarray | None = None):
         """
         Fit model
 
@@ -144,5 +142,4 @@ def _init_parameters(self, partial_observations):
         Q = np.transpose(np.multiply(vt, s[:, None]))
         userBias = np.zeros(numUsers)
         itemBias = np.zeros(numItems)
-        params0 = (P, Q, userBias, itemBias, averageObservedRating)
-        return params0
+        return (P, Q, userBias, itemBias, averageObservedRating)
diff --git a/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/popularity_propensity.py b/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/popularity_propensity.py
index fb9a238e..b3bfb72a 100644
--- a/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/popularity_propensity.py
+++ b/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/popularity_propensity.py
@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import logging
-from typing import Optional
 
 import numpy as np
 from holisticai.bias.mitigation.inprocessing.matrix_factorization.common_utils.propensity_utils import (
@@ -48,17 +47,17 @@ class PopularityPropensityMF(BMImp, RecommenderSystemBase):
 
     def __init__(
         self,
-        K: Optional[int] = 10,
-        beta: Optional[float] = 0.02,
-        steps: Optional[int] = 100,
-        verbose: Optional[int] = 0,
+        K: int | None = 10,
+        beta: float | None = 0.02,
+        steps: int | None = 100,
+        verbose: int | None = 0,
     ):
         self.K = K
         self.beta = beta
         self.steps = steps
         self.verbose = verbose
 
-    def fit(self, X: Optional[np.ndarray], **kargs):
+    def fit(self, X: np.ndarray | None, **kargs):
         """
         Fit model
 
diff --git a/src/holisticai/bias/mitigation/inprocessing/meta_fair_classifier/algorithm.py b/src/holisticai/bias/mitigation/inprocessing/meta_fair_classifier/algorithm.py
index 7b7d3de0..bbd7c84c 100644
--- a/src/holisticai/bias/mitigation/inprocessing/meta_fair_classifier/algorithm.py
+++ b/src/holisticai/bias/mitigation/inprocessing/meta_fair_classifier/algorithm.py
@@ -169,5 +169,4 @@ def predict_proba(self, X: np.ndarray):
             probability output per sample.
         """
         t = self.predictor(X)
-        scores = ((t + 1) / 2).reshape((-1, 1))
-        return scores
+        return ((t + 1) / 2).reshape((-1, 1))
diff --git a/src/holisticai/bias/mitigation/inprocessing/meta_fair_classifier/constraints.py b/src/holisticai/bias/mitigation/inprocessing/meta_fair_classifier/constraints.py
index b29fe356..4dad5b15 100644
--- a/src/holisticai/bias/mitigation/inprocessing/meta_fair_classifier/constraints.py
+++ b/src/holisticai/bias/mitigation/inprocessing/meta_fair_classifier/constraints.py
@@ -30,8 +30,7 @@ def forward(self, P, params, a=None, b=None, return_cs=False):  # noqa: ARG002
     def _gradient(self, a, b, t, c, l):
         _t = t * c / np.sqrt(t**2 + self.mu**2)
         exp = np.mean(_t)
-        dl = exp - b + (b - a) / 2 + (b - a) * l / (2 * np.sqrt(l**2 + self.mu**2))
-        return dl
+        return exp - b + (b - a) / 2 + (b - a) * l / (2 * np.sqrt(l**2 + self.mu**2))
 
     def expected_gradient(self, P, params, a, b):
         l_1, l_2 = params
diff --git a/src/holisticai/bias/mitigation/inprocessing/prejudice_remover/algorithm_utils.py b/src/holisticai/bias/mitigation/inprocessing/prejudice_remover/algorithm_utils.py
index 19da19df..54799d14 100644
--- a/src/holisticai/bias/mitigation/inprocessing/prejudice_remover/algorithm_utils.py
+++ b/src/holisticai/bias/mitigation/inprocessing/prejudice_remover/algorithm_utils.py
@@ -34,8 +34,7 @@ def loss(self, coef_, X, y, groups):
         coef = coef_.reshape(self.estimator.nb_group_values, self.estimator.nb_features).astype(np.float64)
         X = self.estimator.preprocessing_data(X)
         sigma = self.estimator.sigmoid(X=X, groups=groups, coef=coef)
-        loss = self.loss_fn(y=y, sigma=sigma, groups=groups, coef=coef)
-        return loss
+        return self.loss_fn(y=y, sigma=sigma, groups=groups, coef=coef)
 
     def grad_loss(self, coef_, X, y, groups):
         """first derivative of loss function
diff --git a/src/holisticai/bias/mitigation/inprocessing/prejudice_remover/losses.py b/src/holisticai/bias/mitigation/inprocessing/prejudice_remover/losses.py
index f05fafed..511bce0c 100644
--- a/src/holisticai/bias/mitigation/inprocessing/prejudice_remover/losses.py
+++ b/src/holisticai/bias/mitigation/inprocessing/prejudice_remover/losses.py
@@ -13,8 +13,7 @@ def __call__(self, y, sigma, groups, coef):
         f = self.freg(sigma, groups)
         # l2 regularizer
         reg = np.sum(coef * coef)
-        loss = -L + self.eta * f + 0.5 * self.C * reg
-        return loss
+        return -L + self.eta * f + 0.5 * self.C * reg
 
     def gradient(self, X, y, sigma, groups, coef):
         L = self.xent.gradient(X, y, sigma, groups)
@@ -22,8 +21,7 @@ def gradient(self, X, y, sigma, groups, coef):
         # l2 regularizer
         reg = coef
         # sum
-        loss = np.reshape(-L + self.eta * f + self.C * reg, [-1])
-        return loss
+        return np.reshape(-L + self.eta * f + self.C * reg, [-1])
 
 
 class BinaryFairnessRegularizer:
@@ -81,8 +79,7 @@ def gradient(self, X, sigma, groups):
         f3 = (sigma - pi) / (pi * (1.0 - pi))
 
         f4 = (f1[:, np.newaxis] * d_sigma + f2[:, np.newaxis] * d_rho_s) - np.outer(f3, d_pi)
-        f = op_by_group(f4, groups, reduce_op=np.sum, axis=0)
-        return f
+        return op_by_group(f4, groups, reduce_op=np.sum, axis=0)
 
 
 class BinaryCrossEntropy:
@@ -95,8 +92,7 @@ def gradient(self, X, y, sigma, groups):
         # likelihood
         # l(si) = \sum_{x,y in D st s=si} (y - sigma(x, si)) x
         loss = (y - sigma)[:, np.newaxis] * X
-        L = op_by_group(loss, groups, reduce_op=np.sum, axis=0)
-        return L
+        return op_by_group(loss, groups, reduce_op=np.sum, axis=0)
 
 
 def op_by_group(matrix, groups, reduce_op, axis=None):
diff --git a/src/holisticai/bias/mitigation/inprocessing/prejudice_remover/transformer.py b/src/holisticai/bias/mitigation/inprocessing/prejudice_remover/transformer.py
index 7fc63688..b71e5be0 100644
--- a/src/holisticai/bias/mitigation/inprocessing/prejudice_remover/transformer.py
+++ b/src/holisticai/bias/mitigation/inprocessing/prejudice_remover/transformer.py
@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 import numpy as np
 from holisticai.bias.mitigation.inprocessing.prejudice_remover.algorithm import PrejudiceRemoverAlgorithm
 from holisticai.bias.mitigation.inprocessing.prejudice_remover.algorithm_utils import ObjectiveFunction, PRLogger
@@ -63,14 +61,14 @@ class PrejudiceRemover(BaseEstimator, ClassifierMixin, BMImp):
 
     def __init__(
         self,
-        eta: Optional[float] = 1.0,
-        C: Optional[float] = 1.0,
-        fit_intercept: Optional[bool] = True,
-        penalty: Optional[str] = "l2",
-        init_type: Optional[str] = "Zero",
-        maxiter: Optional[int] = 1000,
-        verbose: Optional[int] = 0,
-        print_interval: Optional[int] = 20,
+        eta: float | None = 1.0,
+        C: float | None = 1.0,
+        fit_intercept: bool | None = True,
+        penalty: str | None = "l2",
+        init_type: str | None = "Zero",
+        maxiter: int | None = 1000,
+        verbose: int | None = 0,
+        print_interval: int | None = 20,
     ):
         # Default estimator parameters
         self.eta = eta
diff --git a/src/holisticai/bias/mitigation/inprocessing/two_sided_fairness/transformer.py b/src/holisticai/bias/mitigation/inprocessing/two_sided_fairness/transformer.py
index 62e951f5..fa1a66eb 100644
--- a/src/holisticai/bias/mitigation/inprocessing/two_sided_fairness/transformer.py
+++ b/src/holisticai/bias/mitigation/inprocessing/two_sided_fairness/transformer.py
@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 import numpy as np
 import pandas as pd
 from holisticai.bias.mitigation.inprocessing.two_sided_fairness.algorithm import FairRecAlg
@@ -33,7 +31,7 @@ class FairRec(BMImp):
         recommendations in two-sided platforms." Proceedings of The Web Conference 2020. 2020.
     """
 
-    def __init__(self, rec_size: Optional[int] = 10, MMS_fraction: Optional[float] = 0.5):
+    def __init__(self, rec_size: int | None = 10, MMS_fraction: float | None = 0.5):
         self.rec_size = rec_size
         self.MMS_fraction = MMS_fraction
 
@@ -54,7 +52,7 @@ def fit(self, X):
         self.recommendation = algorithm.rank(X)
         return self
 
-    def predict(self, X: Optional[np.ndarray], top_n: Optional[int] = None):
+    def predict(self, X: np.ndarray | None, top_n: int | None = None):
         """
         Fit model
 
diff --git a/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm_utils/_bound_update.py b/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm_utils/_bound_update.py
index 505e1de7..8f39ca17 100644
--- a/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm_utils/_bound_update.py
+++ b/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm_utils/_bound_update.py
@@ -6,20 +6,16 @@ def normalize(S_in):
     S_in = S_in - maxcol
     S_out = np.exp(S_in)
     S_out_sum = np.sum(S_out, axis=1, keepdims=True)
-    S_out = S_out / S_out_sum
-
-    return S_out
+    return S_out / S_out_sum
 
 
 def normalize_2(S_in):
     S_in_sum = np.sum(S_in, axis=1, keepdims=True)
-    S_in = S_in / S_in_sum
-    return S_in
+    return S_in / S_in_sum
 
 
 def bound_energy(S, S_in, a_term, b_term):
-    E = np.nansum(S * np.log(np.maximum(S, 1e-15)) - S * np.log(np.maximum(S_in, 1e-15)) + a_term * S + b_term * S)
-    return E
+    return np.nansum(S * np.log(np.maximum(S, 1e-15)) - S * np.log(np.maximum(S_in, 1e-15)) + a_term * S + b_term * S)
 
 
 def get_S_discrete(L, N, K):  # noqa: N802
diff --git a/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm_utils/_method_utils.py b/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm_utils/_method_utils.py
index 9c86f9c2..0cc18b28 100644
--- a/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm_utils/_method_utils.py
+++ b/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm_utils/_method_utils.py
@@ -13,8 +13,7 @@ def check_version(version_str):
 
 
 def reduce_func(D_chunk, start):  # noqa: ARG001
-    J = np.mean(D_chunk, axis=1)
-    return J
+    return np.mean(D_chunk, axis=1)
 
 
 def NormalizedCutEnergy(A, S, clustering):  # noqa: N802
@@ -38,9 +37,7 @@ def NormalizedCutEnergy(A, S, clustering):  # noqa: N802
         elif isinstance(A, sparse.csc_matrix):
             nassoc_e = nassoc_e + np.dot(np.transpose(S_k), A.dot(S_k)) / np.dot(np.transpose(d), S_k)
             nassoc_e = nassoc_e[0, 0]
-    ncut_e = num_cluster - nassoc_e
-
-    return ncut_e
+    return num_cluster - nassoc_e
 
 
 def NormalizedCutEnergy_discrete(A, clustering):  # noqa: N802
@@ -64,9 +61,7 @@ def NormalizedCutEnergy_discrete(A, clustering):  # noqa: N802
         elif isinstance(A, sparse.csc_matrix):
             nassoc_e = nassoc_e + np.dot(np.transpose(S_k), A.dot(S_k)) / np.dot(np.transpose(d), S_k)
             nassoc_e = nassoc_e[0, 0]
-    ncut_e = num_cluster - nassoc_e
-
-    return ncut_e
+    return num_cluster - nassoc_e
 
 
 def KernelBound_k(A, d, S_k, N):  # noqa: N802
@@ -86,9 +81,7 @@ def km_le(X, M):
 
     """
     e_dist = ecdist(X, M)
-    L = e_dist.argmin(axis=1)
-
-    return L
+    return e_dist.argmin(axis=1)
 
 
 # Fairness term calculation
@@ -96,8 +89,7 @@ def fairness_term_V_j(u_j, S, V_j):  # noqa: N802
     V_j = V_j.astype("float")
     S_term = np.maximum(np.dot(V_j, S), 1e-20)
     S_sum = np.maximum(S.sum(0), 1e-20)
-    S_term = u_j * (np.log(S_sum) - np.log(S_term))
-    return S_term
+    return u_j * (np.log(S_sum) - np.log(S_term))
 
 
 def km_discrete_energy(e_dist, L, k):
@@ -110,8 +102,7 @@ def compute_fairness_energy(group_prob, groups_ids, S, bound_lambda):
     compute fair clustering energy
     """
     fairness_E = [fairness_term_V_j(group_prob.loc[g], S, groups_ids[f"{g}"]) for g in group_prob.index]
-    fairness_E = (bound_lambda * sum(fairness_E)).sum()
-    return fairness_E
+    return (bound_lambda * sum(fairness_E)).sum()
 
 
 def _is_arraylike(x):
diff --git a/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm_utils/_methods.py b/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm_utils/_methods.py
index 4c4acea1..ed7f5cf2 100644
--- a/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm_utils/_methods.py
+++ b/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm_utils/_methods.py
@@ -39,8 +39,7 @@ def compute_clustering_energy(self, C, L, S):
 
 class KmeansUtils(KUtils):
     def compute_a_p(self, L, C):  # noqa: ARG002
-        a_p = ecdist(self.X, C, squared=True)
-        return a_p
+        return ecdist(self.X, C, squared=True)
 
     def step(self, L, C):
         tmp_list = [np.where(k == L)[0] for k in range(self.K)]
@@ -53,15 +52,12 @@ def step(self, L, C):
     def kmeans_update(self, tmp):
         """ """
         X_tmp = self.X[tmp, :]
-        c1 = X_tmp.mean(axis=0)
-
-        return c1
+        return X_tmp.mean(axis=0)
 
 
 class KmedianUtils(KUtils):
     def compute_a_p(self, L, C):  # noqa: ARG002
-        a_p = ecdist(self.X, C)
-        return a_p
+        return ecdist(self.X, C)
 
     def step(self, L, C):
         tmp_list = [np.where(k == L)[0] for k in range(self.K)]
@@ -77,8 +73,7 @@ def kmedian_update(self, tmp):
         D = pdist_chunk(X_tmp, reduce_func=reduce_func)
         J = next(D)
         j = np.argmin(J)
-        c1 = X_tmp[j, :]
-        return c1
+        return X_tmp[j, :]
 
 
 class NCutUtils:
@@ -101,8 +96,7 @@ def step(self, L, C):  # noqa: ARG002
         S = get_S_discrete(L, self.N, self.K)
         sqdist_list = [KernelBound_k(self.A, self.d, S[:, k], self.N) for k in range(self.K)]
         sqdist = np.asarray(np.vstack(sqdist_list).T)
-        a_p = sqdist.copy()
-        return a_p
+        return sqdist.copy()
 
     def update(self, a_p, L, C):  # noqa: ARG002
         L = a_p.argmin(axis=1)
diff --git a/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm_utils/_utils.py b/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm_utils/_utils.py
index 3a69b149..0e7076ac 100644
--- a/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm_utils/_utils.py
+++ b/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm_utils/_utils.py
@@ -26,8 +26,7 @@ def normalizefea(X):
     L2 normalize
     """
     feanorm = np.maximum(1e-14, np.sum(X**2, axis=1))
-    X_out = X / (feanorm[:, None] ** 0.5)
-    return X_out
+    return X / (feanorm[:, None] ** 0.5)
 
 
 def get_V_jl(x, L, N, K):  # noqa: N802
@@ -35,8 +34,7 @@ def get_V_jl(x, L, N, K):  # noqa: N802
     temp = np.zeros((N, K))
     index_cluster = L[x]
     temp[(x, index_cluster)] = 1
-    temp = temp.sum(0)
-    return temp
+    return temp.sum(0)
 
 
 def get_fair_accuracy(group_prob, groups_ids, L, K):
diff --git a/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/transformer.py b/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/transformer.py
index 5ef2c93f..3235f7a4 100644
--- a/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/transformer.py
+++ b/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/transformer.py
@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 import numpy as np
 from holisticai.bias.mitigation.inprocessing.variational_fair_clustering.algorithm import FairClusteringAlgorithm
 from holisticai.utils.transformers.bias import BMInprocessing as BMImp
@@ -53,13 +51,13 @@ class VariationalFairClustering(BaseEstimator, BMImp):
 
     def __init__(
         self,
-        n_clusters: Optional[int],
-        lipchitz_value: Optional[str] = 1,
-        lmbda: Optional[float] = 0.7,
-        method: Optional[str] = "kmeans",
-        normalize_input: Optional[bool] = True,
-        seed: Optional[int] = None,
-        verbose: Optional[int] = 0,
+        n_clusters: int | None,
+        lipchitz_value: str | None = 1,
+        lmbda: float | None = 0.7,
+        method: str | None = "kmeans",
+        normalize_input: bool | None = True,
+        seed: int | None = None,
+        verbose: int | None = 0,
     ):
         # Constant parameters
         self.algorithm = FairClusteringAlgorithm(
diff --git a/src/holisticai/bias/mitigation/postprocessing/debiasing_exposure/algorithm_utils.py b/src/holisticai/bias/mitigation/postprocessing/debiasing_exposure/algorithm_utils.py
index f83dd4b3..a6d34d8a 100644
--- a/src/holisticai/bias/mitigation/postprocessing/debiasing_exposure/algorithm_utils.py
+++ b/src/holisticai/bias/mitigation/postprocessing/debiasing_exposure/algorithm_utils.py
@@ -9,8 +9,7 @@ def filter_invalid_examples(rankings, query_col, group_col):
     for _, ranking in rankings.groupby(query_col):
         if (ranking[group_col].sum() > 0).any():
             new_rankings.append(ranking)
-    new_rankings = pd.concat(new_rankings, axis=0).reset_index(drop=True)
-    return new_rankings
+    return pd.concat(new_rankings, axis=0).reset_index(drop=True)
 
 
 def exposure_metric(rankings, group_col: str, query_col: str, score_col: str):
@@ -56,9 +55,7 @@ def exposure_diff(data_per_query, prot_idx_per_query):
 
     exposure_prot = normalized_exposure(protected_items_per_query, judgments_per_query)
     exposure_nprot = normalized_exposure(nonprotected_items_per_query, judgments_per_query)
-    exposure_diff = np.maximum(0, (exposure_nprot - exposure_prot))
-
-    return exposure_diff
+    return np.maximum(0, (exposure_nprot - exposure_prot))
 
 
 def exposure_ratio(data_per_query, prot_idx_per_query):
@@ -87,15 +84,14 @@ def exposure_ratio(data_per_query, prot_idx_per_query):
 
     exposure_prot = normalized_exposure(protected_items_per_query, judgments_per_query)
     exposure_nprot = normalized_exposure(nonprotected_items_per_query, judgments_per_query)
-    exposure_diff = exposure_nprot / exposure_prot
-
-    return exposure_diff
+    return exposure_nprot / exposure_prot
 
 
 def find_items_per_group_per_query(data, protected_feature):
     data_per_query = np.array(data).astype(np.float32)
     if np.any(np.isnan(data_per_query)):
-        raise ValueError("data has NaN values!!, fix your data or normalize it before training.")
+        msg = "data has NaN values!!, fix your data or normalize it before training."
+        raise ValueError(msg)
     if len(data_per_query.shape) == 1:
         data_per_query = data_per_query[:, None]
     protected_feature = np.array(protected_feature)
@@ -149,8 +145,7 @@ def normalized_topp_prot_deriv_per_group(group_features, all_features, group_pre
     numpy array of float values.
     """
     derivative = topp_prot_first_derivative(group_features, all_features, group_predictions, all_predictions)
-    result = (np.sum(derivative / np.log(2), axis=0)) / group_predictions.size
-    return result
+    return (np.sum(derivative / np.log(2), axis=0)) / group_predictions.size
 
 
 def topp_prot(group_items, all_items):
diff --git a/src/holisticai/bias/mitigation/postprocessing/debiasing_exposure/transformer.py b/src/holisticai/bias/mitigation/postprocessing/debiasing_exposure/transformer.py
index c77108c2..fbb35c15 100644
--- a/src/holisticai/bias/mitigation/postprocessing/debiasing_exposure/transformer.py
+++ b/src/holisticai/bias/mitigation/postprocessing/debiasing_exposure/transformer.py
@@ -74,9 +74,11 @@ def __init__(
 
         # check if mandatory parameters are present
         if group_col is None:
-            raise ValueError("The name of column in data `group_col` must be initialized")
+            msg = "The name of column in data `group_col` must be initialized"
+            raise ValueError(msg)
         if gamma is None:
-            raise ValueError("The `gamma` parameter must be initialized")
+            msg = "The `gamma` parameter must be initialized"
+            raise ValueError(msg)
 
         # initialize the protected_feature index to -1
 
@@ -110,8 +112,7 @@ def _filter_invalid_examples(self, rankings):
         for _, ranking in rankings.groupby(self.query_col):
             if (ranking[self.group_col].sum() > 0).any():
                 new_rankings.append(ranking)
-        new_rankings = pd.concat(new_rankings, axis=0).reset_index(drop=True)
-        return new_rankings
+        return pd.concat(new_rankings, axis=0).reset_index(drop=True)
 
     def fit(self, rankings: pd.DataFrame):
         """
@@ -164,7 +165,8 @@ def transform(self, rankings: pd.DataFrame):
         """
 
         if self._omega is None:
-            raise SystemError("You need to train a model first!")
+            msg = "You need to train a model first!"
+            raise SystemError(msg)
 
         # prepare data
         query_ids, doc_ids, protected_attributes, feature_matrix = self._prepare_data(rankings, has_judgment=False)
@@ -187,9 +189,7 @@ def transform(self, rankings: pd.DataFrame):
         )
 
         # sort by the score in descending order
-        result = result.sort_values([self.score_col], ascending=[0])
-
-        return result
+        return result.sort_values([self.score_col], ascending=[0])
 
     def _prepare_data(self, data, has_judgment=False):
         """
diff --git a/src/holisticai/bias/mitigation/postprocessing/disparate_impact_remover_rs.py b/src/holisticai/bias/mitigation/postprocessing/disparate_impact_remover_rs.py
index 03d01270..90bbdabc 100644
--- a/src/holisticai/bias/mitigation/postprocessing/disparate_impact_remover_rs.py
+++ b/src/holisticai/bias/mitigation/postprocessing/disparate_impact_remover_rs.py
@@ -61,15 +61,15 @@ def __init__(
 
     def _assert_parameters(self, repair_level):
         if not 0.0 <= repair_level <= 1.0:
-            raise ValueError("'repair_level' must be between 0.0 and 1.0.")
+            msg = "'repair_level' must be between 0.0 and 1.0."
+            raise ValueError(msg)
 
     def _filter_invalid_examples(self, rankings):
         new_rankings = []
         for _, ranking in rankings.groupby(self.query_col):
             if (ranking[self.group_col].sum() > 0).any():
                 new_rankings.append(ranking)
-        new_rankings = pd.concat(new_rankings, axis=0).reset_index(drop=True)
-        return new_rankings
+        return pd.concat(new_rankings, axis=0).reset_index(drop=True)
 
     def fit_transform(self, rankings: pd.DataFrame):
         """
@@ -142,9 +142,8 @@ def transform_features(self, ranking: pd.DataFrame):
         new_ranking = ranking.copy()
         new_ranking[self.score_col] = new_data_matrix
         new_ranking = new_ranking.reset_index(drop=True)
-        new_ranking = (
+        return (
             new_ranking.groupby(self.query_col)
             .apply(lambda df: df.sort_values(self.score_col, ascending=False))
             .reset_index(drop=True)
         )
-        return new_ranking
diff --git a/src/holisticai/bias/mitigation/postprocessing/fair_topk/algorithm_utils/mtable_generator.py b/src/holisticai/bias/mitigation/postprocessing/fair_topk/algorithm_utils/mtable_generator.py
index 713bec34..485606c1 100644
--- a/src/holisticai/bias/mitigation/postprocessing/fair_topk/algorithm_utils/mtable_generator.py
+++ b/src/holisticai/bias/mitigation/postprocessing/fair_topk/algorithm_utils/mtable_generator.py
@@ -22,10 +22,12 @@ def mtable_as_dataframe(self):
 
     def m(self, k):
         if k < 1:
-            raise ValueError("Parameter k must be at least 1")
+            msg = "Parameter k must be at least 1"
+            raise ValueError(msg)
 
         if k > self.k:
-            raise ValueError(f"Parameter k must be at most {self.k}")
+            msg = f"Parameter k must be at most {self.k}"
+            raise ValueError(msg)
 
         result = stats.binom.ppf(self.alpha, k, self.p)
         return 0 if result < 0 else result
@@ -47,7 +49,8 @@ def compute_aux_mtable(mtable):
     Stores the inverse of an mTable entry and the size of the block with respect to the inverse
     """
     if not (isinstance(mtable, pd.DataFrame)):
-        raise TypeError("Internal mtable must be a DataFrame")
+        msg = "Internal mtable must be a DataFrame"
+        raise TypeError(msg)
 
     aux_mtable = pd.DataFrame(columns=["inv", "block"])
     last_m_seen = 0
@@ -60,6 +63,7 @@ def compute_aux_mtable(mtable):
             aux_mtable.loc[position] = [position, position - last_position]
             last_position = position
         elif mtable.at[position, "m"] != last_m_seen:
-            raise RuntimeError("Inconsistent mtable")
+            msg = "Inconsistent mtable"
+            raise RuntimeError(msg)
 
     return aux_mtable
diff --git a/src/holisticai/bias/mitigation/postprocessing/fair_topk/algorithm_utils/valitation_utils.py b/src/holisticai/bias/mitigation/postprocessing/fair_topk/algorithm_utils/valitation_utils.py
index c3daf375..38cd3652 100644
--- a/src/holisticai/bias/mitigation/postprocessing/fair_topk/algorithm_utils/valitation_utils.py
+++ b/src/holisticai/bias/mitigation/postprocessing/fair_topk/algorithm_utils/valitation_utils.py
@@ -26,7 +26,8 @@ def check_ranking(protected, mtable):
     """
     # if the mtable has a different number elements than there are in the top docs return false
     if len(protected) != len(mtable):
-        raise ValueError("Number of documents in ranking and mtable length must be equal!")
+        msg = "Number of documents in ranking and mtable length must be equal!"
+        raise ValueError(msg)
 
     # check number of protected element at each rank
     return not (protected.cumsum().values < np.array(mtable)).any()
@@ -51,14 +52,14 @@ def validate_basic_parameters(k, p, alpha):
     """
     if k < 10 or k > 400:
         if k < 2:
-            raise ValueError("Total number of elements `k` should be between 10 and 400")
+            msg = "Total number of elements `k` should be between 10 and 400"
+            raise ValueError(msg)
         logger.warning("Library has not been tested with values outside this range")
 
     if p < 0.02 or p > 0.98:
         if p < 0 or p > 1:
-            raise ValueError(
-                "The proportion of protected candidates `p` in the top-k ranking should be between " "0.02 and 0.98"
-            )
+            msg = "The proportion of protected candidates `p` in the top-k ranking should be between " "0.02 and 0.98"
+            raise ValueError(msg)
         logger.warning("Library has not been tested with values outside this range")
 
     validate_alpha(alpha)
@@ -67,5 +68,6 @@ def validate_basic_parameters(k, p, alpha):
 def validate_alpha(alpha):
     if alpha < 0.01 or alpha > 0.15:
         if alpha < 0.001 or alpha > 0.5:
-            raise ValueError("The significance level `alpha` must be between 0.01 and 0.15")
+            msg = "The significance level `alpha` must be between 0.01 and 0.15"
+            raise ValueError(msg)
         logger.warning("Library has not been tested with values outside this range")
diff --git a/src/holisticai/bias/mitigation/postprocessing/fair_topk/transformer.py b/src/holisticai/bias/mitigation/postprocessing/fair_topk/transformer.py
index 163683a1..9c0d0dd6 100644
--- a/src/holisticai/bias/mitigation/postprocessing/fair_topk/transformer.py
+++ b/src/holisticai/bias/mitigation/postprocessing/fair_topk/transformer.py
@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 import pandas as pd
 from holisticai.bias.mitigation.postprocessing.fair_topk.algorithm_utils.fail_prob import (
     RecursiveNumericFailProbabilityCalculator,
@@ -57,13 +55,13 @@ class FairTopK(BMPost):
 
     def __init__(
         self,
-        top_n: Optional[int],
-        p: Optional[float],
-        alpha: Optional[float],
-        query_col: Optional[str] = "query_id",
-        doc_col: Optional[str] = "doc_id",
-        group_col: Optional[str] = "group_id",
-        score_col: Optional[str] = "score",
+        top_n: int | None,
+        p: float | None,
+        alpha: float | None,
+        query_col: str | None = "query_id",
+        doc_col: str | None = "doc_id",
+        group_col: str | None = "group_id",
+        score_col: str | None = "score",
     ):
         # check the parameters first
         validate_basic_parameters(top_n, p, alpha)
@@ -97,7 +95,8 @@ def transform(self, rankings, p_attr=None):
         """
         if p_attr is None:
             if self.group_col not in rankings.columns:
-                raise ValueError("protected groups must be provided")
+                msg = "protected groups must be provided"
+                raise ValueError(msg)
             new_rankings = rankings
         else:
             if self.group_col in rankings.columns:
diff --git a/src/holisticai/bias/mitigation/postprocessing/lp_debiaser/binary_balancer/algorithm.py b/src/holisticai/bias/mitigation/postprocessing/lp_debiaser/binary_balancer/algorithm.py
index 72a722de..dad0e6e4 100644
--- a/src/holisticai/bias/mitigation/postprocessing/lp_debiaser/binary_balancer/algorithm.py
+++ b/src/holisticai/bias/mitigation/postprocessing/lp_debiaser/binary_balancer/algorithm.py
@@ -84,5 +84,4 @@ def predict(self, p_attr, y_pred=None, y_proba=None, binom=False):
                 y_pred[group_ids[g]] = tools.threshold(probs[group_ids[g]], cut)
 
         # Returning the adjusted predictions
-        adj = tools.pred_from_pya(y_pred, p_attr, self.pya, binom)
-        return adj
+        return tools.pred_from_pya(y_pred, p_attr, self.pya, binom)
diff --git a/src/holisticai/bias/mitigation/postprocessing/lp_debiaser/binary_balancer/algorithm_utils.py b/src/holisticai/bias/mitigation/postprocessing/lp_debiaser/binary_balancer/algorithm_utils.py
index 31550c8f..5acc9fc3 100644
--- a/src/holisticai/bias/mitigation/postprocessing/lp_debiaser/binary_balancer/algorithm_utils.py
+++ b/src/holisticai/bias/mitigation/postprocessing/lp_debiaser/binary_balancer/algorithm_utils.py
@@ -19,8 +19,7 @@ def __init__(self, y_true, y_pred, round=4):  # noqa: A002
 
 
 def from_top(roc_point, round=4):  # noqa: A002, ARG001
-    d = np.sqrt(roc_point[0] ** 2 + (roc_point[1] - 1) ** 2)
-    return d
+    return np.sqrt(roc_point[0] ** 2 + (roc_point[1] - 1) ** 2)
 
 
 def loss_from_roc(y, probs, roc):
diff --git a/src/holisticai/bias/mitigation/postprocessing/lp_debiaser/binary_balancer/constraints.py b/src/holisticai/bias/mitigation/postprocessing/lp_debiaser/binary_balancer/constraints.py
index acb409ff..8f050b1c 100644
--- a/src/holisticai/bias/mitigation/postprocessing/lp_debiaser/binary_balancer/constraints.py
+++ b/src/holisticai/bias/mitigation/postprocessing/lp_debiaser/binary_balancer/constraints.py
@@ -11,8 +11,7 @@ def __call__(self, dr, overall_rates):
         e = 1 - s
 
         # Setting up the coefficients for the objective function
-        obj_coefs = np.array([[(s - e) * r[0], (e - s) * r[1]] for r in dr]).flatten()
-        return obj_coefs
+        return np.array([[(s - e) * r[0], (e - s) * r[1]] for r in dr]).flatten()
 
 
 class ConstraintBase:
diff --git a/src/holisticai/bias/mitigation/postprocessing/lp_debiaser/binary_balancer/transformer.py b/src/holisticai/bias/mitigation/postprocessing/lp_debiaser/binary_balancer/transformer.py
index 76aac3e5..60c9719c 100644
--- a/src/holisticai/bias/mitigation/postprocessing/lp_debiaser/binary_balancer/transformer.py
+++ b/src/holisticai/bias/mitigation/postprocessing/lp_debiaser/binary_balancer/transformer.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Literal, Optional
+from typing import Literal
 
 import numpy as np
 from holisticai.bias.mitigation.postprocessing.lp_debiaser.binary_balancer.algorithm import BinaryBalancerAlgorithm
@@ -35,7 +35,7 @@ class LPDebiaserBinary(BMPost):
 
     def __init__(
         self,
-        constraint: Optional[CONSTRAINT] = "EqualizedOdds",
+        constraint: CONSTRAINT | None = "EqualizedOdds",
     ):
         self.constraint = constraint
         self._sensgroups = SensitiveGroups()
@@ -45,8 +45,8 @@ def fit(
         y: np.ndarray,
         group_a: np.ndarray,
         group_b: np.ndarray,
-        y_pred: Optional[np.ndarray] = None,
-        y_proba: Optional[np.ndarray] = None,
+        y_pred: np.ndarray | None = None,
+        y_proba: np.ndarray | None = None,
     ):
         """
         Compute parameters for Linear Programming Debiaser.\
@@ -105,8 +105,8 @@ def transform(
         self,
         group_a: np.ndarray,
         group_b: np.ndarray,
-        y_pred: Optional[np.ndarray] = None,
-        y_proba: Optional[np.ndarray] = None,
+        y_pred: np.ndarray | None = None,
+        y_proba: np.ndarray | None = None,
     ):
         """
         Apply transform function to predictions and likelihoods
@@ -148,8 +148,8 @@ def fit_transform(
         y: np.ndarray,
         group_a: np.ndarray,
         group_b: np.ndarray,
-        y_pred: Optional[np.ndarray] = None,
-        y_proba: Optional[np.ndarray] = None,
+        y_pred: np.ndarray | None = None,
+        y_proba: np.ndarray | None = None,
     ):
         """
         Fit and transform
diff --git a/src/holisticai/bias/mitigation/postprocessing/lp_debiaser/multiclass_balancer/algorithm_utils.py b/src/holisticai/bias/mitigation/postprocessing/lp_debiaser/multiclass_balancer/algorithm_utils.py
index 349228f4..cc8f9712 100644
--- a/src/holisticai/bias/mitigation/postprocessing/lp_debiaser/multiclass_balancer/algorithm_utils.py
+++ b/src/holisticai/bias/mitigation/postprocessing/lp_debiaser/multiclass_balancer/algorithm_utils.py
@@ -25,5 +25,4 @@ def p_vec(y, flatten=True):
 def pars_to_cpmat(opt, n_groups=3, n_classes=3):
     """Reshapes the LP parameters as an n_group * n_class * n_class array"""
     shaped = np.reshape(opt.x, (n_groups, n_classes, n_classes))
-    flipped = np.array([m.T for m in shaped])
-    return flipped
+    return np.array([m.T for m in shaped])
diff --git a/src/holisticai/bias/mitigation/postprocessing/lp_debiaser/multiclass_balancer/constraints.py b/src/holisticai/bias/mitigation/postprocessing/lp_debiaser/multiclass_balancer/constraints.py
index 45bb532b..b07f670c 100644
--- a/src/holisticai/bias/mitigation/postprocessing/lp_debiaser/multiclass_balancer/constraints.py
+++ b/src/holisticai/bias/mitigation/postprocessing/lp_debiaser/multiclass_balancer/constraints.py
@@ -7,8 +7,7 @@
 class MacroLosses:
     def __call__(self, cp_mats):
         off_loss = [[np.delete(a, i, 0).sum(0) for i in range(self.n_classes)] for a in cp_mats]
-        obj = np.array(off_loss).flatten()
-        return obj
+        return np.array(off_loss).flatten()
 
 
 class MicroLosses:
@@ -16,8 +15,7 @@ def __call__(self, cp_mats):
         u = np.array([[np.delete(a, i, 0) for i in range(self.n_classes)] for a in cp_mats])
         p = np.array([[np.delete(a, i).reshape(-1, 1) for i in range(self.n_classes)] for a in self.p_vecs])
         w = np.array([[p[i, j] * u[i, j] for j in range(self.n_classes)] for i in range(self.n_groups)])
-        obj = w.sum(2).flatten()
-        return obj
+        return w.sum(2).flatten()
 
 
 class ConstraintBase:
diff --git a/src/holisticai/bias/mitigation/postprocessing/mcmf_clustering/algorithm.py b/src/holisticai/bias/mitigation/postprocessing/mcmf_clustering/algorithm.py
index aeb2ae0b..aa4cbd81 100644
--- a/src/holisticai/bias/mitigation/postprocessing/mcmf_clustering/algorithm.py
+++ b/src/holisticai/bias/mitigation/postprocessing/mcmf_clustering/algorithm.py
@@ -46,14 +46,12 @@ def penalty_weights(self, X=None, centroids: np.ndarray = None):
         if self.metric == "L1":
             norm_p = 1
             d = np.linalg.norm(centroids[:, None, :] - X[None, ...], ord=norm_p, axis=-1)
-            w = (-d).reshape(-1)
-            return w
+            return (-d).reshape(-1)
 
         if self.metric == "L2":
             norm_p = 2
             d = np.linalg.norm(centroids[:, None, :] - X[None, ...], ord=norm_p, axis=-1)
-            w = (-d).reshape(-1)
-            return w
+            return (-d).reshape(-1)
 
         message = f"Penalty Weights not implemented : {self.metric}"
         raise NotImplementedError(message)
@@ -74,7 +72,8 @@ def compute_cost_function(self, centroids, X, z_pred, z_mod):
             w = np.mean(d, axis=0) - np.sum(d * z_mod, axis=0)
             return np.sum(w * (1 - np.sum(z_mod * z_pred, axis=0)))
 
-        raise NotImplementedError(f"Cost Function not implemented : {self.metric}")
+        msg = f"Cost Function not implemented : {self.metric}"
+        raise NotImplementedError(msg)
 
     def transform(
         self,
diff --git a/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/randomized_threshold/algorithm.py b/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/randomized_threshold/algorithm.py
index 201a4a00..88680ff2 100644
--- a/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/randomized_threshold/algorithm.py
+++ b/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/randomized_threshold/algorithm.py
@@ -97,7 +97,8 @@ def fit(self, y_score, groups_num):
                 self.rho = self.avrg_y_score / 2.0 + 0.5
 
         if self.rho <= 0:
-            raise ValueError("rho must be either None or a strictly positive number.")
+            msg = "rho must be either None or a strictly positive number."
+            raise ValueError(msg)
 
         num_groups = len(set(groups_num))
         eps0 = self.eps / 2.0
diff --git a/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/randomized_threshold/algorithm_utils.py b/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/randomized_threshold/algorithm_utils.py
index 57f35bb2..6429ad24 100644
--- a/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/randomized_threshold/algorithm_utils.py
+++ b/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/randomized_threshold/algorithm_utils.py
@@ -28,8 +28,7 @@ def compute_gradients(self, y_batch):
 
         lambda_gradient = self.eps0 + self.rho - mean_xi
         mu_gradient = self.eps0 - self.rho + mean_xi
-        gradients = {"lambda": lambda_gradient, "mu": mu_gradient}
-        return gradients
+        return {"lambda": lambda_gradient, "mu": mu_gradient}
 
     def update_parameters(self, gradients):
         """
diff --git a/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/reduce2binary/algorithm.py b/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/reduce2binary/algorithm.py
index 93a1650d..ffe4ff0a 100644
--- a/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/reduce2binary/algorithm.py
+++ b/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/reduce2binary/algorithm.py
@@ -60,13 +60,16 @@ def __init__(
             If True, display progress.
         """
         if num_classes < 2:
-            raise ValueError("Number of classes (must be >= 2).")
+            msg = "Number of classes (must be >= 2)."
+            raise ValueError(msg)
 
         if eps < 0:
-            raise ValueError("eps must be non-negative.")
+            msg = "eps must be non-negative."
+            raise ValueError(msg)
 
         if gamma <= 0:
-            raise ValueError("gamma must be a strictly positive number.")
+            msg = "gamma must be a strictly positive number."
+            raise ValueError(msg)
 
         self.num_groups = 1
         self.gamma = gamma
@@ -127,10 +130,11 @@ def predict(self, y_prob, p_attr):
         """
 
         if len(y_prob.shape) != 2:
-            raise ValueError(
+            msg = (
                 "Original prob scores must be a 2-dimensional array."
                 "Use RandomizedThreshold for binary classification."
             )
+            raise ValueError(msg)
 
         y_prob_scores = copy.deepcopy(y_prob)
 
@@ -160,5 +164,4 @@ def predict(self, y_prob, p_attr):
             self.logger.update(iteration=iteration + 1, primal_residual=r, dual_residual=s)
 
         z_mat = np.maximum(z_mat, 0)
-        z_mat = z_mat / np.sum(z_mat, axis=1, keepdims=True)
-        return z_mat
+        return z_mat / np.sum(z_mat, axis=1, keepdims=True)
diff --git a/src/holisticai/bias/mitigation/postprocessing/plugin_estimator_and_recalibration/algorithm.py b/src/holisticai/bias/mitigation/postprocessing/plugin_estimator_and_recalibration/algorithm.py
index 34af531d..391a6b6d 100644
--- a/src/holisticai/bias/mitigation/postprocessing/plugin_estimator_and_recalibration/algorithm.py
+++ b/src/holisticai/bias/mitigation/postprocessing/plugin_estimator_and_recalibration/algorithm.py
@@ -92,5 +92,4 @@ def transform(self, y_pred: np.ndarray, sensitive_features: np.ndarray):
         )
         min_indices = np.argmin(minimizing_values, axis=1)
         output_predictions = index_range[min_indices] * self.multiplier / self.length
-        output_predictions = (output_predictions + 1) / 2
-        return output_predictions
+        return (output_predictions + 1) / 2
diff --git a/src/holisticai/bias/mitigation/postprocessing/plugin_estimator_and_recalibration/algorithm_utils.py b/src/holisticai/bias/mitigation/postprocessing/plugin_estimator_and_recalibration/algorithm_utils.py
index 97abdc9e..9e473918 100644
--- a/src/holisticai/bias/mitigation/postprocessing/plugin_estimator_and_recalibration/algorithm_utils.py
+++ b/src/holisticai/bias/mitigation/postprocessing/plugin_estimator_and_recalibration/algorithm_utils.py
@@ -27,9 +27,7 @@ def tot_fn(H, S, i):
     RISs = tmp1 * ((2 * S[None, :] - 1) * lambda_[i_values, None] + H_i - beta * np.log((2 * L + 1) * tmp1))
     RIS = np.sum(RISs, axis=0)
 
-    ris = np.mean(RIS[S == 0]) + np.mean(RIS[S == 1])
-
-    return ris
+    return np.mean(RIS[S == 0]) + np.mean(RIS[S == 1])
 
 
 def f_lambda(Y, S, M, L, beta):
@@ -39,6 +37,4 @@ def f_lambda(Y, S, M, L, beta):
 
     lambda_ = 0.99 * np.ones(shape=(2 * L + 1,))
     fun = partial(f_mincon, Y, S, M, L, beta)
-    lambda_ = minimize(fun, lambda_, bounds=[(0, 4 * M)] * len(lambda_)).x  # , method='L-BFGS-B').x
-
-    return lambda_
+    return minimize(fun, lambda_, bounds=[(0, 4 * M)] * len(lambda_)).x  # , method='L-BFGS-B').x
diff --git a/src/holisticai/bias/mitigation/postprocessing/wasserstein_barycenters/algorithm.py b/src/holisticai/bias/mitigation/postprocessing/wasserstein_barycenters/algorithm.py
index fb05f63a..f8c3e0b6 100644
--- a/src/holisticai/bias/mitigation/postprocessing/wasserstein_barycenters/algorithm.py
+++ b/src/holisticai/bias/mitigation/postprocessing/wasserstein_barycenters/algorithm.py
@@ -42,8 +42,7 @@ def _optimize_ts(self, yt, i1, i2, n1, n2):
         t_values = np.linspace(self.minY, self.maxY, 100)
         tmp1 = np.sum(yl_masked1[:, None] < t_values, axis=0) / n1
         dist = np.abs(tmp1 - tmp2)
-        ts = t_values[np.argmin(dist)]
-        return ts
+        return t_values[np.argmin(dist)]
 
     def _update_yt(self, yt, group):
         if group == self.group_values[self.im]:
@@ -59,5 +58,4 @@ def transform(self, y_pred: np.ndarray, sensitive_groups: np.ndarray):
         ST = self._sensgroups.transform(sensitive_groups, convert_numeric=True)
         noise = self.eps * np.random.randn(len(y_pred)).squeeze()
         YT = y_pred + noise
-        YF = np.array([self._update_yt(yt, st) for yt, st in zip(YT, ST)])
-        return YF
+        return np.array([self._update_yt(yt, st) for yt, st in zip(YT, ST)])
diff --git a/src/holisticai/bias/mitigation/preprocessing/correlation_remover.py b/src/holisticai/bias/mitigation/preprocessing/correlation_remover.py
index 419e2d6c..cc8489a5 100644
--- a/src/holisticai/bias/mitigation/preprocessing/correlation_remover.py
+++ b/src/holisticai/bias/mitigation/preprocessing/correlation_remover.py
@@ -6,8 +6,7 @@
 @jit
 def _fit(X, sensitive_features, sensitive_mean):
     sensitive_features_center = sensitive_features - sensitive_mean
-    beta = jnp.linalg.lstsq(sensitive_features_center, X, rcond=None)[0]
-    return beta
+    return jnp.linalg.lstsq(sensitive_features_center, X, rcond=None)[0]
 
 
 @jit
@@ -97,8 +96,7 @@ def transform(self, X: jnp.ndarray, group_a: jnp.ndarray, group_b: jnp.ndarray):
         group_b = params["group_b"]
 
         sensitive_features = jnp.stack([group_a, group_b], axis=1).astype(jnp.int32)
-        x_filtered = _transform(x, sensitive_features, self.beta_, self.alpha, self.sensitive_mean_)
-        return x_filtered
+        return _transform(x, sensitive_features, self.beta_, self.alpha, self.sensitive_mean_)
 
     def fit_transform(self, X: jnp.ndarray, group_a: jnp.ndarray, group_b: jnp.ndarray):
         """
diff --git a/src/holisticai/bias/mitigation/preprocessing/disparate_impact_remover.py b/src/holisticai/bias/mitigation/preprocessing/disparate_impact_remover.py
index 066f0837..5ce3fa1c 100644
--- a/src/holisticai/bias/mitigation/preprocessing/disparate_impact_remover.py
+++ b/src/holisticai/bias/mitigation/preprocessing/disparate_impact_remover.py
@@ -50,7 +50,8 @@ def _assert_parameters(self, repair_level):
             If repair_level is not between 0.0 and 1.0
         """
         if not 0.0 <= repair_level <= 1.0:
-            raise ValueError("'repair_level' must be between 0.0 and 1.0.")
+            msg = "'repair_level' must be between 0.0 and 1.0."
+            raise ValueError(msg)
 
     def repair_data(self, X, group_a, group_b):
         """
diff --git a/src/holisticai/bias/mitigation/preprocessing/fairlet_clustering/transformer.py b/src/holisticai/bias/mitigation/preprocessing/fairlet_clustering/transformer.py
index 2e50d91c..ad00d898 100644
--- a/src/holisticai/bias/mitigation/preprocessing/fairlet_clustering/transformer.py
+++ b/src/holisticai/bias/mitigation/preprocessing/fairlet_clustering/transformer.py
@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional, Union
-
 import numpy as np
 from holisticai.bias.mitigation.commons.fairlet_clustering.decompositions import (
     DecompositionMixin,
@@ -57,10 +55,10 @@ class FairletClusteringPreprocessing(BaseEstimator, BMPre):
 
     def __init__(
         self,
-        decomposition: Union[str, DecompositionMixin] = "Vanilla",
-        p: Optional[str] = 1,
-        q: Optional[float] = 3,
-        seed: Optional[int] = None,
+        decomposition: str | DecompositionMixin = "Vanilla",
+        p: str | None = 1,
+        q: float | None = 3,
+        seed: int | None = None,
     ):
         self.decomposition = DECOMPOSITION_CATALOG[decomposition](p=p, q=q)
         self.p = p
@@ -72,7 +70,7 @@ def fit_transform(
         X: np.ndarray,
         group_a: np.ndarray,
         group_b: np.ndarray,
-        sample_weight: Optional[np.ndarray] = None,
+        sample_weight: np.ndarray | None = None,
     ):
         """
         Fits the model by learning a fair cluster.
diff --git a/src/holisticai/bias/mitigation/preprocessing/learning_fair_representation.py b/src/holisticai/bias/mitigation/preprocessing/learning_fair_representation.py
index ce989c9e..5038e178 100644
--- a/src/holisticai/bias/mitigation/preprocessing/learning_fair_representation.py
+++ b/src/holisticai/bias/mitigation/preprocessing/learning_fair_representation.py
@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import logging
-from typing import Optional
 
 import jax
 import jax.numpy as jnp
@@ -73,9 +72,7 @@ def __call__(self, parameters):
 
         loss = jnp.array([loss_x, loss_y, loss_z])
 
-        total_loss = jnp.dot(self.A, loss)
-
-        return total_loss
+        return jnp.dot(self.A, loss)
 
 
 class LearningFairRepresentation(BMPreprocessing):
@@ -117,14 +114,14 @@ class LearningFairRepresentation(BMPreprocessing):
 
     def __init__(
         self,
-        k: Optional[int] = 5,
-        Ax: Optional[float] = 0.01,
-        Ay: Optional[float] = 1.0,
-        Az: Optional[float] = 50.0,
-        maxiter: Optional[int] = 5000,
-        maxfun: Optional[int] = 5000,
-        verbose: Optional[int] = 0,
-        seed: Optional[int] = None,
+        k: int | None = 5,
+        Ax: float | None = 0.01,
+        Ay: float | None = 1.0,
+        Az: float | None = 50.0,
+        maxiter: int | None = 5000,
+        maxfun: int | None = 5000,
+        verbose: int | None = 0,
+        seed: int | None = None,
     ):
         self.seed = seed
         self.k = k
diff --git a/src/holisticai/bias/mitigation/preprocessing/reweighing.py b/src/holisticai/bias/mitigation/preprocessing/reweighing.py
index 9034b3e5..6405c8d8 100644
--- a/src/holisticai/bias/mitigation/preprocessing/reweighing.py
+++ b/src/holisticai/bias/mitigation/preprocessing/reweighing.py
@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 import numpy as np
 import pandas as pd
 from holisticai.utils.transformers.bias import BMPreprocessing as BMPre
@@ -34,7 +32,7 @@ def fit(
         y: np.ndarray,
         group_a: np.ndarray,
         group_b: np.ndarray,
-        sample_weight: Optional[np.ndarray] = None,
+        sample_weight: np.ndarray | None = None,
     ):
         """
         Fit the Reweighing model to the data. This method calculates the sample weights to ensure that the \
@@ -110,7 +108,7 @@ def fit_transform(
         y: np.ndarray,
         group_a: np.ndarray,
         group_b: np.ndarray,
-        sample_weight: Optional[np.ndarray] = None,
+        sample_weight: np.ndarray | None = None,
     ):
         """
         Fit the Reweighing model to the data. This method calculates the sample weights to ensure that the \
diff --git a/src/holisticai/bias/plots/_bias_exploratory_plots.py b/src/holisticai/bias/plots/_bias_exploratory_plots.py
index 77616370..b0a865e5 100644
--- a/src/holisticai/bias/plots/_bias_exploratory_plots.py
+++ b/src/holisticai/bias/plots/_bias_exploratory_plots.py
@@ -40,7 +40,8 @@ def group_pie_plot(y_feat, ax=None, size=None, title=None):
         labels = value_counts.index.tolist()
 
     else:
-        raise TypeError("input is not a numpy array or pandas series")
+        msg = "input is not a numpy array or pandas series"
+        raise TypeError(msg)
 
     # calculations
     n_b = np.sum(value_counts / np.sum(value_counts) > 0.02)
diff --git a/src/holisticai/bias/plots/_bias_regression_plots.py b/src/holisticai/bias/plots/_bias_regression_plots.py
index 4c0b75f5..ee22cf55 100644
--- a/src/holisticai/bias/plots/_bias_regression_plots.py
+++ b/src/holisticai/bias/plots/_bias_regression_plots.py
@@ -154,7 +154,8 @@ def statistical_parity_curve(group_a, group_b, y_pred, x_axis="score", ax=None,
         ax.legend()
 
     else:
-        raise ValueError("x_axis is not one of : quantile, score")
+        msg = "x_axis is not one of : quantile, score"
+        raise ValueError(msg)
 
     return ax
 
@@ -239,7 +240,8 @@ def disparate_impact_curve(group_a, group_b, y_pred, x_axis="score", ax=None, si
         ax.legend()
 
     else:
-        raise ValueError("x_axis is not one of : score, quantile")
+        msg = "x_axis is not one of : score, quantile"
+        raise ValueError(msg)
 
     return ax
 
@@ -335,7 +337,8 @@ def success_rate_curves(p_attr, y_pred, groups=None, x_axis="score", ax=None, si
         ax.legend()
 
     else:
-        raise ValueError("x_axis is not one of : score, quantile")
+        msg = "x_axis is not one of : score, quantile"
+        raise ValueError(msg)
 
     return ax
 
diff --git a/src/holisticai/datasets/_dataset.py b/src/holisticai/datasets/_dataset.py
index 555c0916..0a063f08 100644
--- a/src/holisticai/datasets/_dataset.py
+++ b/src/holisticai/datasets/_dataset.py
@@ -1,18 +1,18 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Literal, Union
+from typing import TYPE_CHECKING, Literal
 
 import pandas as pd
-from sklearn.model_selection import train_test_split
-
 from holisticai.utils.obj_rep.object_repr import DatasetReprObj
+from sklearn.model_selection import train_test_split
 
 if TYPE_CHECKING:
     from collections.abc import Iterable
 
+    from numpy.random import RandomState
+
 
 import numpy as np
-from numpy.random import RandomState
 
 
 class DatasetDict(dict, DatasetReprObj):
@@ -429,7 +429,8 @@ def __getitem__(self, key: str | int | list):
 
     def __setitem__(self, key, value):
         if not isinstance(key, str):
-            raise TypeError("Key must be a string.")
+            msg = "Key must be a string."
+            raise TypeError(msg)
 
         feature_exists = key in self.data.columns.get_level_values(0)
         existing_subfeatures = self.data[key].columns if feature_exists else []
@@ -481,7 +482,7 @@ def apply_fn_to_multilevel_df(df, fn):
     return result_df
 
 
-def sample_n(group: pd.DataFrame, n: int, random_state: Union[RandomState, None] = None) -> pd.DataFrame:
+def sample_n(group: pd.DataFrame, n: int, random_state: RandomState | None = None) -> pd.DataFrame:
     if len(group) < n:
         return group
     return group.sample(n=n, replace=False, random_state=random_state)
diff --git a/src/holisticai/datasets/_load_dataset.py b/src/holisticai/datasets/_load_dataset.py
index aa0cb1f8..8220d3b5 100644
--- a/src/holisticai/datasets/_load_dataset.py
+++ b/src/holisticai/datasets/_load_dataset.py
@@ -1,10 +1,9 @@
 from __future__ import annotations
 
-from typing import Literal, Optional
+from typing import Literal
 
 import numpy as np
 import pandas as pd
-
 from holisticai.datasets._dataloaders import load_hai_datasets
 from holisticai.datasets._dataset import Dataset
 from holisticai.datasets._utils import convert_float_to_categorical, get_protected_values
@@ -32,7 +31,7 @@ def create_preprocessor(X, numerical_transform: bool = True, categorical_transfo
     return ColumnTransformer(transformers=transformers)
 
 
-def load_adult_dataset(protected_attribute: Optional[Literal["race", "sex"]] = "sex", preprocessed: bool = True):
+def load_adult_dataset(protected_attribute: Literal["race", "sex"] | None = "sex", preprocessed: bool = True):
     sensitive_attribute = ["race", "sex"]
     feature_names = [
         "age",
@@ -88,7 +87,8 @@ def load_adult_dataset(protected_attribute: Optional[Literal["race", "sex"]] = "
             group_a = pd.Series(get_protected_values(df, protected_attribute, ga_label), name="group_a")
             group_b = pd.Series(get_protected_values(df, protected_attribute, gb_label), name="group_b")
         else:
-            raise ValueError("The protected attribute must be: race or sex")
+            msg = "The protected attribute must be: race or sex"
+            raise ValueError(msg)
 
         if protected_attribute is not None:
             metadata = f"""{protected_attribute}: {{'group_a': '{ga_label}', 'group_b': '{gb_label}'}}"""
@@ -96,7 +96,7 @@ def load_adult_dataset(protected_attribute: Optional[Literal["race", "sex"]] = "
     return Dataset(X=xt, y=y, p_attrs=p_attrs)
 
 
-def load_law_school_dataset(protected_attribute: Optional[Literal["race", "sex"]] = "sex", preprocessed: bool = True):
+def load_law_school_dataset(protected_attribute: Literal["race", "sex"] | None = "sex", preprocessed: bool = True):
     data = load_hai_datasets(dataset_name="law_school")
     sensitive_attribute = ["race1", "gender", "age"]
     output_variable = "bar"
@@ -122,7 +122,8 @@ def load_law_school_dataset(protected_attribute: Optional[Literal["race", "sex"]
             group_a = pd.Series(get_protected_values(df, "gender", ga_label), name="group_a")
             group_b = pd.Series(get_protected_values(df, "gender", gb_label), name="group_b")
         else:
-            raise ValueError("The protected attribute must be one of: race or gender")
+            msg = "The protected attribute must be one of: race or gender"
+            raise ValueError(msg)
 
     if protected_attribute is not None:
         metadata = f"""{protected_attribute}: {{'group_a': '{ga_label}', 'group_b': '{gb_label}'}}"""
@@ -130,9 +131,7 @@ def load_law_school_dataset(protected_attribute: Optional[Literal["race", "sex"]
     return Dataset(X=X, y=y, p_attrs=p_attrs)
 
 
-def load_student_multiclass_dataset(
-    protected_attribute: Optional[Literal["sex", "address"]] = "sex", preprocessed=True
-):
+def load_student_multiclass_dataset(protected_attribute: Literal["sex", "address"] | None = "sex", preprocessed=True):
     sensitive_attributes = ["sex", "address", "Mjob", "Fjob"]
     output_column = "G3"
     drop_columns = ["G1", "G2", "G3", "sex", "address", "Mjob", "Fjob"]
@@ -172,7 +171,8 @@ def load_student_multiclass_dataset(
             group_a = pd.Series(df["address"] == ga_label, name="group_a")
             group_b = ~group_a
         else:
-            raise ValueError("The protected attribute must be one sex or address")
+            msg = "The protected attribute must be one sex or address"
+            raise ValueError(msg)
 
     if protected_attribute is not None:
         metadata = f"""{protected_attribute}: {{'group_a': '{ga_label}', 'group_b': '{gb_label}'}}"""
@@ -181,9 +181,9 @@ def load_student_multiclass_dataset(
 
 
 def load_student_dataset(
-    target: Optional[Literal["G1", "G2", "G3"]] = None,
+    target: Literal["G1", "G2", "G3"] | None = None,
     preprocessed: bool = True,
-    protected_attribute: Optional[Literal["sex", "address"]] = "sex",
+    protected_attribute: Literal["sex", "address"] | None = "sex",
 ):
     if target is None:
         target = "G3"
@@ -215,7 +215,8 @@ def load_student_dataset(
             group_a = pd.Series(df["address"] == "U", name="group_a")
             group_b = pd.Series(df["address"] == "R", name="group_b")
         else:
-            raise ValueError("The protected attribute doesn't exist or not implemented")
+            msg = "The protected attribute doesn't exist or not implemented"
+            raise ValueError(msg)
     df = df.drop(drop_columns, axis=1)
 
     if preprocessed:
@@ -273,7 +274,7 @@ def load_lastfm_dataset():
     return Dataset(data_pivot=df_pivot, p_attr=pd.Series(p_attr))
 
 
-def load_us_crime_dataset(preprocessed=True, protected_attribute: Optional[Literal["race"]] = "race"):
+def load_us_crime_dataset(preprocessed=True, protected_attribute: Literal["race"] | None = "race"):
     """
     Processes the US crime dataset and returns the data, output variable, protected group A and \
     protected group B as numerical arrays or as dataframe if needed
@@ -316,9 +317,8 @@ def load_us_crime_dataset(preprocessed=True, protected_attribute: Optional[Liter
             group_a = pd.Series(df[protected_attribute_column] > threshold, name="group_a")
             group_b = pd.Series(~group_a, name="group_b")
         else:
-            raise ValueError(
-                f"The protected attribute doesn't exist or not implemented. Please use: {protected_attributes}"
-            )
+            msg = f"The protected attribute doesn't exist or not implemented. Please use: {protected_attributes}"
+            raise ValueError(msg)
 
     if protected_attribute is not None:
         metadata = f"""{protected_attribute}: {{'group_a': '{ga_label}', 'group_b': '{gb_label}'}}"""
@@ -326,7 +326,7 @@ def load_us_crime_dataset(preprocessed=True, protected_attribute: Optional[Liter
     return Dataset(X=X, y=y, p_attrs=p_attrs)
 
 
-def load_us_crime_multiclass_dataset(preprocessed=True, protected_attribute: Optional[Literal["race"]] = "race"):
+def load_us_crime_multiclass_dataset(preprocessed=True, protected_attribute: Literal["race"] | None = "race"):
     """
     Processes the US crime dataset and returns the data, output variable, protected group A and protected group B as numerical arrays or as dataframe if needed
 
@@ -370,9 +370,8 @@ def load_us_crime_multiclass_dataset(preprocessed=True, protected_attribute: Opt
             group_a = pd.Series(df[protected_attribute_column] > threshold, name="group_a")
             group_b = pd.Series(~group_a, name="group_b")
         else:
-            raise ValueError(
-                f"The protected attribute doesn't exist or not implemented. Please use: {protected_attribute}"
-            )
+            msg = f"The protected attribute doesn't exist or not implemented. Please use: {protected_attribute}"
+            raise ValueError(msg)
 
     if protected_attribute is not None:
         metadata = f"""{protected_attribute}: {{'group_a': '{ga_label}', 'group_b': '{gb_label}'}}"""
@@ -380,7 +379,7 @@ def load_us_crime_multiclass_dataset(preprocessed=True, protected_attribute: Opt
     return Dataset(X=X, y=y_cat, p_attrs=p_attrs)
 
 
-def load_clinical_records_dataset(protected_attribute: Optional[Literal["sex"]] = "sex"):
+def load_clinical_records_dataset(protected_attribute: Literal["sex"] | None = "sex"):
     """
     Processes the heart dataset and returns the data, output variable, protected group A and protected group B as numerical arrays
 
@@ -410,7 +409,8 @@ def load_clinical_records_dataset(protected_attribute: Optional[Literal["sex"]]
             group_a = pd.Series(df[protected_attribute] == ga_label, name="group_a")
             group_b = pd.Series(df[protected_attribute] == gb_label, name="group_b")
         else:
-            raise ValueError("The protected attribute doesn't exist or not implemented. Please use: sex")
+            msg = "The protected attribute doesn't exist or not implemented. Please use: sex"
+            raise ValueError(msg)
 
     if protected_attribute is not None:
         metadata = f"""{protected_attribute}: {{'group_a': '{ga_label}', 'group_b': '{gb_label}'}}"""
@@ -418,7 +418,7 @@ def load_clinical_records_dataset(protected_attribute: Optional[Literal["sex"]]
     return Dataset(X=X, y=y, p_attrs=p_attrs)
 
 
-def load_german_credit_dataset(preprocessed=True, protected_attribute: Optional[Literal["sex"]] = "sex"):
+def load_german_credit_dataset(preprocessed=True, protected_attribute: Literal["sex"] | None = "sex"):
     """
     Processes the german credit dataset and returns the data, output variable, protected group A and protected group B as numerical arrays or as dataframe if needed
 
@@ -458,9 +458,8 @@ def load_german_credit_dataset(preprocessed=True, protected_attribute: Optional[
             group_a = pd.Series(df["Sex"] == "male", name="group_a")
             group_b = pd.Series(df["Sex"] == "female", name="group_b")
         else:
-            raise ValueError(
-                f"The protected attribute doesn't exist or not implemented. Please use: {protected_attribute}"
-            )
+            msg = f"The protected attribute doesn't exist or not implemented. Please use: {protected_attribute}"
+            raise ValueError(msg)
 
     if protected_attribute is not None:
         metadata = f"""{protected_attribute}: {{'group_a': '{ga_label}', 'group_b': '{gb_label}'}}"""
@@ -468,7 +467,7 @@ def load_german_credit_dataset(preprocessed=True, protected_attribute: Optional[
     return Dataset(X=X, y=y, p_attrs=p_attrs)
 
 
-def load_census_kdd_dataset(preprocessed=True, protected_attribute: Optional[Literal["sex"]] = "sex"):
+def load_census_kdd_dataset(preprocessed=True, protected_attribute: Literal["sex"] | None = "sex"):
     """
     Processes the Census KDD dataset and returns the data, output variable, protected group A and protected group B as numerical arrays or as dataframe if needed
 
@@ -516,9 +515,8 @@ def load_census_kdd_dataset(preprocessed=True, protected_attribute: Optional[Lit
             group_a = pd.Series(df["race"] == 1, name="group_a")
             group_b = pd.Series(df["race"] == 0, name="group_b")
         else:
-            raise ValueError(
-                f"The protected attribute doesn't exist or not implemented. Please use: {protected_attribute}"
-            )
+            msg = f"The protected attribute doesn't exist or not implemented. Please use: {protected_attribute}"
+            raise ValueError(msg)
 
     if protected_attribute is not None:
         metadata = f"""{protected_attribute}: {{'group_a': '{ga_label}', 'group_b': '{gb_label}'}}"""
@@ -526,7 +524,7 @@ def load_census_kdd_dataset(preprocessed=True, protected_attribute: Optional[Lit
     return Dataset(X=X, y=y, p_attrs=p_attrs)
 
 
-def load_bank_marketing_dataset(preprocessed=True, protected_attribute: Optional[Literal["marital"]] = "marital"):
+def load_bank_marketing_dataset(preprocessed=True, protected_attribute: Literal["marital"] | None = "marital"):
     """
     Processes the Banking Marketing dataset and returns the data, output variable, protected group A and protected group B as numerical arrays or as dataframe if needed
 
@@ -588,9 +586,8 @@ def load_bank_marketing_dataset(preprocessed=True, protected_attribute: Optional
             group_a = pd.Series(df["marital"] == 1, name="group_a")
             group_b = pd.Series(df["marital"] == 0, name="group_b")
         else:
-            raise ValueError(
-                f"The protected attribute doesn't exist or not implemented. Please use: {protected_attribute}"
-            )
+            msg = f"The protected attribute doesn't exist or not implemented. Please use: {protected_attribute}"
+            raise ValueError(msg)
 
     if protected_attribute is not None:
         metadata = f"""{protected_attribute}: {{'group_a': '{ga_label}', 'group_b': '{gb_label}'}}"""
@@ -598,9 +595,7 @@ def load_bank_marketing_dataset(preprocessed=True, protected_attribute: Optional
     return Dataset(X=X, y=y, p_attrs=p_attrs)
 
 
-def load_compas_two_year_recid_dataset(
-    preprocessed=True, protected_attribute: Optional[Literal["race", "sex"]] = "race"
-):
+def load_compas_two_year_recid_dataset(preprocessed=True, protected_attribute: Literal["race", "sex"] | None = "race"):
     """
     Processes the compas dataset and returns the data, output variable, protected group A and protected group B as numerical arrays or as dataframe if needed
     Target: 2-year recidivism
@@ -646,9 +641,8 @@ def load_compas_two_year_recid_dataset(
             group_a = pd.Series(df["race"] == 1, name="group_a")
             group_b = pd.Series(df["race"] == 2, name="group_b")
         else:
-            raise ValueError(
-                f"The protected attribute doesn't exist or not implemented. Please use: {protected_attribute}"
-            )
+            msg = f"The protected attribute doesn't exist or not implemented. Please use: {protected_attribute}"
+            raise ValueError(msg)
 
     if protected_attribute is not None:
         metadata = f"""{protected_attribute}: {{'group_a': '{ga_label}', 'group_b': '{gb_label}'}}"""
@@ -656,7 +650,7 @@ def load_compas_two_year_recid_dataset(
     return Dataset(X=X, y=y, p_attrs=p_attrs)
 
 
-def load_compas_is_recid_dataset(preprocessed=True, protected_attribute: Optional[Literal["race", "sex"]] = "race"):
+def load_compas_is_recid_dataset(preprocessed=True, protected_attribute: Literal["race", "sex"] | None = "race"):
     """
     Processes the compas dataset and returns the data, output variable, protected group A and protected group B as numerical arrays or as dataframe if needed
     Target: 2-year recidivism
@@ -700,9 +694,8 @@ def load_compas_is_recid_dataset(preprocessed=True, protected_attribute: Optiona
             group_a = pd.Series(df["race"] == 1, name="group_a")
             group_b = pd.Series(df["race"] == 2, name="group_b")
         else:
-            raise ValueError(
-                f"The protected attribute doesn't exist or not implemented. Please use: {protected_attribute}"
-            )
+            msg = f"The protected attribute doesn't exist or not implemented. Please use: {protected_attribute}"
+            raise ValueError(msg)
 
     if protected_attribute is not None:
         metadata = f"""{protected_attribute}: {{'group_a': '{ga_label}', 'group_b': '{gb_label}'}}"""
@@ -710,7 +703,7 @@ def load_compas_is_recid_dataset(preprocessed=True, protected_attribute: Optiona
     return Dataset(X=X, y=y, p_attrs=p_attrs)
 
 
-def load_diabetes_dataset(preprocessed=True, protected_attribute: Optional[Literal["race", "sex"]] = "sex"):
+def load_diabetes_dataset(preprocessed=True, protected_attribute: Literal["race", "sex"] | None = "sex"):
     """
     Processes the Diabetes dataset and returns the data, output variable, protected group A and protected group B as numerical arrays or as dataframe if needed
 
@@ -758,9 +751,8 @@ def load_diabetes_dataset(preprocessed=True, protected_attribute: Optional[Liter
             group_a = pd.Series(df["race"] == "Caucasian", name="group_a")
             group_b = pd.Series(df["race"] == "Non-Caucasian", name="group_b")
         else:
-            raise ValueError(
-                f"The protected attribute doesn't exist or not implemented. Please use: {protected_attribute}"
-            )
+            msg = f"The protected attribute doesn't exist or not implemented. Please use: {protected_attribute}"
+            raise ValueError(msg)
 
     if protected_attribute is not None:
         metadata = f"""{protected_attribute}: {{'group_a': '{ga_label}', 'group_b': '{gb_label}'}}"""
@@ -768,7 +760,7 @@ def load_diabetes_dataset(preprocessed=True, protected_attribute: Optional[Liter
     return Dataset(X=X, y=y, p_attrs=p_attrs)
 
 
-def load_acsincome_dataset(preprocessed=True, protected_attribute: Optional[Literal["race", "sex"]] = "sex"):
+def load_acsincome_dataset(preprocessed=True, protected_attribute: Literal["race", "sex"] | None = "sex"):
     """
     Processes the ACSIncome dataset and returns the data, output variable, protected group A and protected group B as numerical arrays or as dataframe if needed
 
@@ -814,9 +806,8 @@ def load_acsincome_dataset(preprocessed=True, protected_attribute: Optional[Lite
             group_a = pd.Series(df["RAC1P"] == "White", name="group_a")
             group_b = pd.Series(df["RAC1P"] == "Non-White", name="group_b")
         else:
-            raise ValueError(
-                f"The protected attribute doesn't exist or not implemented. Please use: {protected_attribute}"
-            )
+            msg = f"The protected attribute doesn't exist or not implemented. Please use: {protected_attribute}"
+            raise ValueError(msg)
 
     if protected_attribute is not None:
         metadata = f"""{protected_attribute}: {{'group_a': '{ga_label}', 'group_b': '{gb_label}'}}"""
@@ -824,7 +815,7 @@ def load_acsincome_dataset(preprocessed=True, protected_attribute: Optional[Lite
     return Dataset(X=X, y=y, p_attrs=p_attrs)
 
 
-def load_acspublic_dataset(preprocessed=True, protected_attribute: Optional[Literal["race", "sex"]] = "sex"):
+def load_acspublic_dataset(preprocessed=True, protected_attribute: Literal["race", "sex"] | None = "sex"):
     """
     Processes the ACSPublicCoverage dataset and returns the data, output variable, protected group A and protected group B as numerical arrays or as dataframe if needed
 
@@ -869,9 +860,8 @@ def load_acspublic_dataset(preprocessed=True, protected_attribute: Optional[Lite
             group_a = pd.Series(df["RAC1P"] == "White", name="group_a")
             group_b = pd.Series(df["RAC1P"] == "Non-White", name="group_b")
         else:
-            raise ValueError(
-                f"The protected attribute doesn't exist or not implemented. Please use: {protected_attribute}"
-            )
+            msg = f"The protected attribute doesn't exist or not implemented. Please use: {protected_attribute}"
+            raise ValueError(msg)
 
     if protected_attribute is not None:
         metadata = f"""{protected_attribute}: {{'group_a': '{ga_label}', 'group_b': '{gb_label}'}}"""
@@ -879,7 +869,7 @@ def load_acspublic_dataset(preprocessed=True, protected_attribute: Optional[Lite
     return Dataset(X=X, y=y, p_attrs=p_attrs)
 
 
-def load_mw_medium_dataset(preprocessed=True, protected_attribute: Optional[Literal["race", "sex"]] = "race"):
+def load_mw_medium_dataset(preprocessed=True, protected_attribute: Literal["race", "sex"] | None = "race"):
     """
     Processes the Minimum Wage Medium dataset and returns the data, output variable, protected group A and protected group B as numerical arrays or as dataframe if needed
     Target: contracted_hours
@@ -925,9 +915,8 @@ def load_mw_medium_dataset(preprocessed=True, protected_attribute: Optional[Lite
             group_a = pd.Series(df["race"] == ga_label, name="group_a")
             group_b = pd.Series(df["race"] == gb_label, name="group_b")
         else:
-            raise ValueError(
-                f"The protected attribute doesn't exist or not implemented. Please use: {protected_attribute}"
-            )
+            msg = f"The protected attribute doesn't exist or not implemented. Please use: {protected_attribute}"
+            raise ValueError(msg)
 
     if protected_attribute is not None:
         metadata = f"""{protected_attribute}: {{'group_a': '{ga_label}', 'group_b': '{gb_label}'}}"""
@@ -935,7 +924,7 @@ def load_mw_medium_dataset(preprocessed=True, protected_attribute: Optional[Lite
     return Dataset(X=X, y=y, p_attrs=p_attrs)
 
 
-def load_mw_small_dataset(preprocessed=True, protected_attribute: Optional[Literal["race", "sex"]] = "race"):
+def load_mw_small_dataset(preprocessed=True, protected_attribute: Literal["race", "sex"] | None = "race"):
     """
     Processes the Minimum Wage Small dataset and returns the data, output variable, protected group A and protected group B as numerical arrays or as dataframe if needed
     Target: contracted_hours
@@ -981,9 +970,8 @@ def load_mw_small_dataset(preprocessed=True, protected_attribute: Optional[Liter
             group_a = pd.Series(df["race"] == ga_label, name="group_a")
             group_b = pd.Series(df["race"] == gb_label, name="group_b")
         else:
-            raise ValueError(
-                f"The protected attribute doesn't exist or not implemented. Please use: {protected_attribute}"
-            )
+            msg = f"The protected attribute doesn't exist or not implemented. Please use: {protected_attribute}"
+            raise ValueError(msg)
 
     if protected_attribute is not None:
         metadata = f"""{protected_attribute}: {{'group_a': '{ga_label}', 'group_b': '{gb_label}'}}"""
@@ -1016,8 +1004,8 @@ def load_mw_small_dataset(preprocessed=True, protected_attribute: Optional[Liter
 def load_dataset(
     dataset_name: ProcessedDatasets,
     preprocessed: bool = True,
-    protected_attribute: Optional[str] = None,
-    target: Optional[str] = None,
+    protected_attribute: str | None = None,
+    target: str | None = None,
 ) -> Dataset:
     """
     Load a specific dataset based on the given dataset name.
diff --git a/src/holisticai/datasets/_load_dataset.pyi b/src/holisticai/datasets/_load_dataset.pyi
index 4d5fa63a..5e249f3c 100644
--- a/src/holisticai/datasets/_load_dataset.pyi
+++ b/src/holisticai/datasets/_load_dataset.pyi
@@ -1,29 +1,29 @@
-from typing import Literal, Union, overload
+from typing import Literal, overload
 
 @overload
 def load_dataset(
     dataset_name: Literal["adult"],
-    protected_attribute: Union[Literal["race", "sex"], None] = None,
+    protected_attribute: Literal["race", "sex"] | None = None,
     preprocessed: bool = True,
 ): ...
 @overload
 def load_dataset(
     dataset_name: Literal["law_school"],
-    protected_attribute: Union[Literal["race", "gender"], None] = None,
+    protected_attribute: Literal["race", "gender"] | None = None,
     preprocessed: bool = True,
 ): ...
 @overload
 def load_dataset(
     dataset_name: Literal["student_multiclass"],
-    protected_attribute: Union[Literal["sex", "address"], None] = None,
+    protected_attribute: Literal["sex", "address"] | None = None,
     preprocessed: bool = True,
 ): ...
 @overload
 def load_dataset(
     dataset_name: Literal["student"],
-    target: Union[Literal["G1", "G2", "G3"], None] = None,
+    target: Literal["G1", "G2", "G3"] | None = None,
     preprocessed: bool = True,
-    protected_attribute: Union[Literal["sex", "address"], None] = None,
+    protected_attribute: Literal["sex", "address"] | None = None,
 ): ...
 @overload
 def load_dataset(
@@ -33,15 +33,13 @@ def load_dataset(
 def load_dataset(
     dataset_name: Literal["us_crime"],
     preprocessed: bool = True,
-    protected_attribute: Union[Literal["race"], None] = None,
+    protected_attribute: Literal["race"] | None = None,
 ): ...
 @overload
 def load_dataset(
     dataset_name: Literal["us_crime_multiclass"],
     preprocessed: bool = True,
-    protected_attribute: Union[Literal["race"], None] = None,
+    protected_attribute: Literal["race"] | None = None,
 ): ...
 @overload
-def load_dataset(
-    dataset_name: Literal["clinical_records"], protected_attribute: Union[Literal["sex"], None] = None
-): ...
+def load_dataset(dataset_name: Literal["clinical_records"], protected_attribute: Literal["sex"] | None = None): ...
diff --git a/src/holisticai/datasets/plots/_exploratory.py b/src/holisticai/datasets/plots/_exploratory.py
index 5de608fc..082ce958 100644
--- a/src/holisticai/datasets/plots/_exploratory.py
+++ b/src/holisticai/datasets/plots/_exploratory.py
@@ -1,7 +1,6 @@
 import matplotlib.pyplot as plt
 import numpy as np
 import seaborn as sns
-
 from holisticai.datasets import Dataset
 
 # utils
diff --git a/src/holisticai/efficacy/metrics/_classification.py b/src/holisticai/efficacy/metrics/_classification.py
index f3286239..6080c248 100644
--- a/src/holisticai/efficacy/metrics/_classification.py
+++ b/src/holisticai/efficacy/metrics/_classification.py
@@ -73,7 +73,8 @@ def confusion_matrix(y_pred, y_true, classes=None, normalize=None):
         confmat = confmat / np.sum(confmat, axis=0).reshape(1, -1)
 
     else:
-        raise ValueError('normalize should be one of None, "pred" or "true"')
+        msg = 'normalize should be one of None, "pred" or "true"'
+        raise ValueError(msg)
 
     return pd.DataFrame(confmat, columns=classes).set_index(np.array(classes))
 
diff --git a/src/holisticai/explainability/__init__.py b/src/holisticai/explainability/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/src/holisticai/explainability/metrics/_classification.py b/src/holisticai/explainability/metrics/_classification.py
index 25a6bcc8..5e2114ad 100644
--- a/src/holisticai/explainability/metrics/_classification.py
+++ b/src/holisticai/explainability/metrics/_classification.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING
 
 import pandas as pd
 from holisticai.explainability.metrics.global_feature_importance import (
@@ -27,9 +27,9 @@ def classification_explainability_metrics(
     importances: Importances,
     partial_dependencies: PartialDependence,
     conditional_importances: ConditionalImportances,
-    X: Union[pd.DataFrame, None] = None,
-    y_pred: Union[pd.Series, None] = None,
-    local_importances: Union[LocalImportances, None] = None,
+    X: pd.DataFrame | None = None,
+    y_pred: pd.Series | None = None,
+    local_importances: LocalImportances | None = None,
 ) -> pd.DataFrame:
     ranked_importances = importances.top_alpha(0.8)
     results = []
diff --git a/src/holisticai/explainability/metrics/_multiclass.py b/src/holisticai/explainability/metrics/_multiclass.py
index 71c1408a..2efa0968 100644
--- a/src/holisticai/explainability/metrics/_multiclass.py
+++ b/src/holisticai/explainability/metrics/_multiclass.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING
 
 import pandas as pd
 from holisticai.explainability.metrics.global_feature_importance import (
@@ -27,9 +27,9 @@ def multiclass_explainability_metrics(
     importances: Importances,
     partial_dependencies: PartialDependence,
     conditional_importances: ConditionalImportances,
-    X: Union[pd.DataFrame, None] = None,
-    y_pred: Union[pd.Series, None] = None,
-    local_importances: Union[LocalImportances, None] = None,
+    X: pd.DataFrame | None = None,
+    y_pred: pd.Series | None = None,
+    local_importances: LocalImportances | None = None,
 ) -> pd.DataFrame:
     ranked_importances = importances.top_alpha(0.8)
     results = []
diff --git a/src/holisticai/explainability/metrics/_regression.py b/src/holisticai/explainability/metrics/_regression.py
index a4bb0da8..539a6842 100644
--- a/src/holisticai/explainability/metrics/_regression.py
+++ b/src/holisticai/explainability/metrics/_regression.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING
 
 import pandas as pd
 from holisticai.explainability.metrics.global_feature_importance import (
@@ -22,9 +22,9 @@ def regression_explainability_metrics(
     importances: Importances,
     partial_dependencies: PartialDependence,
     conditional_importances: ConditionalImportances,
-    X: Union[pd.DataFrame, None] = None,
-    y_pred: Union[pd.Series, None] = None,
-    local_importances: Union[LocalImportances, None] = None,
+    X: pd.DataFrame | None = None,
+    y_pred: pd.Series | None = None,
+    local_importances: LocalImportances | None = None,
 ) -> pd.DataFrame:
     ranked_importances = importances.top_alpha(0.8)
     results = []
diff --git a/src/holisticai/explainability/metrics/global_feature_importance/_fluctuation_ratio.py b/src/holisticai/explainability/metrics/global_feature_importance/_fluctuation_ratio.py
index 40a912d4..edf78cd0 100644
--- a/src/holisticai/explainability/metrics/global_feature_importance/_fluctuation_ratio.py
+++ b/src/holisticai/explainability/metrics/global_feature_importance/_fluctuation_ratio.py
@@ -1,14 +1,16 @@
 from __future__ import annotations
 
 import logging
-from typing import Optional
+from typing import TYPE_CHECKING
 
 import numpy as np
 import pandas as pd
-from holisticai.typing import ArrayLike, MatrixLike
-from holisticai.utils import Importances, PartialDependence
 from scipy.interpolate import interp1d
 
+if TYPE_CHECKING:
+    from holisticai.typing import ArrayLike, MatrixLike
+    from holisticai.utils import Importances, PartialDependence
+
 logger = logging.getLogger(__name__)
 
 
@@ -27,7 +29,7 @@ def get_fluctuations_from_individuals(grid_values: ArrayLike, individuals: Matri
 
 def fluctuation_ratio(
     partial_dependencies: PartialDependence,
-    importances: Optional[Importances] = None,
+    importances: Importances | None = None,
     top_n=-1,
     label=0,
     weighted=False,
diff --git a/src/holisticai/explainability/metrics/global_feature_importance/_surrogate.py b/src/holisticai/explainability/metrics/global_feature_importance/_surrogate.py
index 81cf1907..2d568169 100644
--- a/src/holisticai/explainability/metrics/global_feature_importance/_surrogate.py
+++ b/src/holisticai/explainability/metrics/global_feature_importance/_surrogate.py
@@ -27,8 +27,7 @@ def smape(y_true, y_pred):
     numerator = np.abs(y_true - y_pred)
     # Avoid division by zero by adding a small constant (epsilon) to the denominator
     epsilon = 1e-10
-    smape_value = np.mean(numerator / (denominator + epsilon))
-    return smape_value
+    return np.mean(numerator / (denominator + epsilon))
 
 
 def surrogate_fidelity(y_pred, y_surrogate):
diff --git a/src/holisticai/explainability/metrics/local_feature_importance/_rank_consistency.py b/src/holisticai/explainability/metrics/local_feature_importance/_rank_consistency.py
index 72eda654..5eb6808d 100644
--- a/src/holisticai/explainability/metrics/local_feature_importance/_rank_consistency.py
+++ b/src/holisticai/explainability/metrics/local_feature_importance/_rank_consistency.py
@@ -7,17 +7,15 @@
 def get_average_local_importances(local_importances_values: np.ndarray):
     local_importances_values = np.abs(local_importances_values)
     local_importances_values = local_importances_values / local_importances_values.sum(axis=1, keepdims=True)
-    average_local_importances_values = local_importances_values.mean(axis=0)
-    return average_local_importances_values
+    return local_importances_values.mean(axis=0)
 
 
 def local_normalized_desviation(local_importances_values: np.ndarray):
     ranked_features = np.argsort(np.argsort(-local_importances_values, axis=1), axis=1)
     mode_result = stats.mode(ranked_features, axis=0)
-    normalized_desviation = (np.abs(ranked_features - np.array(mode_result.mode)[None, :])) / (
+    return (np.abs(ranked_features - np.array(mode_result.mode)[None, :])) / (
         np.max(ranked_features, axis=0) - np.min(ranked_features, axis=0) + EPSILON
     )[None, :]
-    return normalized_desviation
 
 
 def rank_consistency(local_importances_values: np.ndarray, weighted=False, aggregate=True):
diff --git a/src/holisticai/explainability/metrics/local_feature_importance/_stability.py b/src/holisticai/explainability/metrics/local_feature_importance/_stability.py
index 44d89e72..5370fe42 100644
--- a/src/holisticai/explainability/metrics/local_feature_importance/_stability.py
+++ b/src/holisticai/explainability/metrics/local_feature_importance/_stability.py
@@ -47,10 +47,10 @@ def __call__(self, local_feature_importance, strategy="variance", **kargs):
         if strategy == "variance":
             jsd_std = np.std(densities)
             jsd_max = np.max(densities)
-            stability = 1 - (jsd_std / jsd_max)
-            return stability
+            return 1 - (jsd_std / jsd_max)
         if strategy == "entropy":
             num_samples = len(densities)
             feature_equal_weight = np.array([1.0 / num_samples] * num_samples)
             return 1 - jensenshannon(densities, feature_equal_weight, base=2)
-        raise ValueError(f"Invalid strategy: {strategy}")
+        msg = f"Invalid strategy: {strategy}"
+        raise ValueError(msg)
diff --git a/src/holisticai/explainability/metrics/surrogate/_classification.py b/src/holisticai/explainability/metrics/surrogate/_classification.py
index b484e235..4eb08640 100644
--- a/src/holisticai/explainability/metrics/surrogate/_classification.py
+++ b/src/holisticai/explainability/metrics/surrogate/_classification.py
@@ -30,8 +30,7 @@ class AccuracyDegradation:
     def __call__(self, y, y_pred, y_surrogate):
         Pb = accuracy_score(y, y_pred)
         Ps = accuracy_score(y, y_surrogate)
-        D = 2 * (Pb - Ps) / (Pb + Ps)  # Normalized difference between the two SMAPE values
-        return D
+        return 2 * (Pb - Ps) / (Pb + Ps)  # Normalized difference between the two SMAPE values
 
 
 def surrogate_accuracy_degradation(y: ArrayLike, y_pred: ArrayLike, y_surrogate: ArrayLike):
@@ -124,7 +123,8 @@ def classification_surrogate_explainability_metrics(
     elif len(np.unique(y_pred)) > 2:
         surrogate = MultiClassificationSurrogate(X, y_pred=y_pred, model_type=surrogate_type)
     else:
-        raise ValueError("y_pred must have at least two unique values")
+        msg = "y_pred must have at least two unique values"
+        raise ValueError(msg)
 
     y_surrogate = surrogate.predict(X)
     results = {}
diff --git a/src/holisticai/explainability/metrics/surrogate/_clustering.py b/src/holisticai/explainability/metrics/surrogate/_clustering.py
index 16838079..992a682f 100644
--- a/src/holisticai/explainability/metrics/surrogate/_clustering.py
+++ b/src/holisticai/explainability/metrics/surrogate/_clustering.py
@@ -32,8 +32,7 @@ def __call__(self, X, y, proxy, surrogate):
         Pb = accuracy_score(y, y_pred)
         y_pred_surrogate = surrogate.predict(X)
         Pt = accuracy_score(y, y_pred_surrogate)
-        D = Pb - Pt
-        return D
+        return Pb - Pt
 
 
 def accuracy_difference(X, y, proxy, surrogate):
diff --git a/src/holisticai/explainability/metrics/surrogate/_regression.py b/src/holisticai/explainability/metrics/surrogate/_regression.py
index 8beddd70..e43c5e21 100644
--- a/src/holisticai/explainability/metrics/surrogate/_regression.py
+++ b/src/holisticai/explainability/metrics/surrogate/_regression.py
@@ -31,8 +31,7 @@ class MSEDegradation:
     def __call__(self, y, y_pred, y_surrogate):
         Pb = surrogate_mean_squared_error(y, y_pred)
         Ps = surrogate_mean_squared_error(y, y_surrogate)
-        D = max(0, 2 * (Ps - Pb) / (Pb + Ps))
-        return D
+        return max(0, 2 * (Ps - Pb) / (Pb + Ps))
 
 
 def surrogate_mean_squared_error_degradation(y: ArrayLike, y_pred: ArrayLike, y_surrogate: ArrayLike):
diff --git a/src/holisticai/explainability/metrics/tree/_tree.py b/src/holisticai/explainability/metrics/tree/_tree.py
index a4eb6371..b5294386 100644
--- a/src/holisticai/explainability/metrics/tree/_tree.py
+++ b/src/holisticai/explainability/metrics/tree/_tree.py
@@ -338,8 +338,7 @@ def __call__(self, tree):
         """
         depths, _ = get_depths_counts(0, tree, [], [])
         mean_depth = np.mean(depths)
-        variance = np.mean((depths - mean_depth) ** 2)
-        return variance
+        return np.mean((depths - mean_depth) ** 2)
 
 
 def tree_depth_variance(tree):
diff --git a/src/holisticai/explainability/plots/_tree.py b/src/holisticai/explainability/plots/_tree.py
index 96f6b7ee..77e090fc 100644
--- a/src/holisticai/explainability/plots/_tree.py
+++ b/src/holisticai/explainability/plots/_tree.py
@@ -25,9 +25,11 @@ def _color_brew(n):
     for i in range(n):
         color = cmap(0.075 + 0.875 * i / n)[:3]  # Get RGB values from cmap
         if color[0] > 1 or color[1] > 1 or color[2] > 1:
-            raise ValueError("Color values must be in the range [0, 1] 1")
+            msg = "Color values must be in the range [0, 1] 1"
+            raise ValueError(msg)
         if color[0] < 0 or color[1] < 0 or color[2] < 0:
-            raise ValueError("Color values must be in the range [0, 1] 0")
+            msg = "Color values must be in the range [0, 1] 0"
+            raise ValueError(msg)
         rgb = (int(color[0] * 255), int(color[1] * 255), int(color[2] * 255))
         color_list.append(rgb)
 
@@ -119,7 +121,8 @@ def plot_surrogate(feature_importance: Importances, ax=None, **kargs):
     """
 
     if "surrogate" not in feature_importance.extra_attrs:
-        raise ValueError("Surrogate key does not exist in feature_importance.extra_attrs")
+        msg = "Surrogate key does not exist in feature_importance.extra_attrs"
+        raise ValueError(msg)
 
     if ax is None:
         _, ax = plt.subplots(1, 1, figsize=(30, 10))
diff --git a/src/holisticai/inspection/_lime.py b/src/holisticai/inspection/_lime.py
index 0792ebce..a7d17a26 100644
--- a/src/holisticai/inspection/_lime.py
+++ b/src/holisticai/inspection/_lime.py
@@ -1,15 +1,13 @@
 from __future__ import annotations
 
 import warnings
-from typing import Union
 
 import numpy as np
 import pandas as pd
-from numpy.random import RandomState
-
 from holisticai.datasets._dataset import Dataset
 from holisticai.inspection._utils import group_mask_samples_by_learning_task
 from holisticai.utils._definitions import LocalImportances, ModelProxy
+from numpy.random import RandomState
 
 warnings.filterwarnings("ignore")
 
@@ -18,8 +16,8 @@ def compute_lime_feature_importance(
     X: pd.DataFrame,
     y: pd.Series,
     proxy: ModelProxy,
-    max_samples: Union[int, None] = None,
-    random_state: Union[RandomState, None] = None,
+    max_samples: int | None = None,
+    random_state: RandomState | None = None,
 ) -> LocalImportances:
     if random_state is None:
         random_state = RandomState(42)
@@ -36,8 +34,7 @@ def compute_lime_feature_importance(
     # y_: pd.Series = pd.Series(ds["y"])
     y_ = pd.Series(proxy.predict(ds["X"]))
     condition = group_mask_samples_by_learning_task(y_, proxy.learning_task)
-    local_importances = LocalImportances(data=data, cond=condition)
-    return local_importances
+    return LocalImportances(data=data, cond=condition)
 
 
 class LIMEImportanceCalculator:
@@ -48,7 +45,8 @@ def initialize_explainer(self, X: pd.DataFrame, proxy: ModelProxy):
             import lime  # type: ignore
             import lime.lime_tabular  # type: ignore
         except ImportError:
-            raise ImportError("LIME is not installed. Please install it using 'pip install lime'") from None
+            msg = "LIME is not installed. Please install it using 'pip install lime'"
+            raise ImportError(msg) from None
 
         if proxy.learning_task == "regression":
             self.explainer = lime.lime_tabular.LimeTabularExplainer(
@@ -72,7 +70,8 @@ def initialize_explainer(self, X: pd.DataFrame, proxy: ModelProxy):
             self.predict_function = proxy.predict_proba
             self.feature_names = list(X.columns)
         else:
-            raise ValueError("Learning task must be regression or classification")
+            msg = "Learning task must be regression or classification"
+            raise ValueError(msg)
 
     def compute_importances(self, ds: Dataset, proxy: ModelProxy) -> pd.DataFrame:
         X = pd.DataFrame(ds["X"].astype(np.float64))
diff --git a/src/holisticai/inspection/_partial_dependence.py b/src/holisticai/inspection/_partial_dependence.py
index e768c058..062090fb 100644
--- a/src/holisticai/inspection/_partial_dependence.py
+++ b/src/holisticai/inspection/_partial_dependence.py
@@ -1,15 +1,17 @@
 from __future__ import annotations
 
 import numbers
+from typing import TYPE_CHECKING
 
 import numpy as np
-import pandas as pd
+from holisticai.utils._commons import get_columns
+from holisticai.utils._definitions import ModelProxy, PartialDependence
 from joblib import Parallel, delayed
 from sklearn.inspection import partial_dependence
 from sklearn.metrics import accuracy_score, r2_score
 
-from holisticai.utils._commons import get_columns
-from holisticai.utils._definitions import ModelProxy, PartialDependence
+if TYPE_CHECKING:
+    import pandas as pd
 
 
 def get_partial_dependence(
@@ -180,7 +182,8 @@ def wrap_sklearn_model(proxy: ModelProxy):
 def compute_partial_dependence(X: pd.DataFrame, features: list[str], proxy: ModelProxy) -> PartialDependence:
     supported_learning_tasks = ["binary_classification", "regression", "multi_classification"]
     if proxy.learning_task not in supported_learning_tasks:
-        raise ValueError(f"Learning task {proxy.learning_task} is not supported for partial dependence computation")
+        msg = f"Learning task {proxy.learning_task} is not supported for partial dependence computation"
+        raise ValueError(msg)
 
     model = wrap_sklearn_model(proxy)
     feature_names = np.array(get_columns(X))
diff --git a/src/holisticai/inspection/_permutation_importance.py b/src/holisticai/inspection/_permutation_importance.py
index 6a6c193c..8178e569 100644
--- a/src/holisticai/inspection/_permutation_importance.py
+++ b/src/holisticai/inspection/_permutation_importance.py
@@ -1,12 +1,9 @@
 from __future__ import annotations
 
-from typing import Any, Literal, Union, overload
+from typing import Any, Literal, overload
 
 import numpy as np
 import pandas as pd
-from numpy.random import RandomState
-from sklearn.metrics import accuracy_score, mean_squared_error
-
 from holisticai.inspection._utils import group_index_samples_by_learning_task
 from holisticai.utils._commons import get_columns, get_item
 from holisticai.utils._definitions import (
@@ -14,6 +11,8 @@
     Importances,
     ModelProxy,
 )
+from numpy.random import RandomState
+from sklearn.metrics import accuracy_score, mean_squared_error
 
 metric_scores = {
     "binary_classification": accuracy_score,
@@ -29,7 +28,7 @@ def compute_permutation_importance(
     y: pd.Series,
     n_repeats: int = 5,
     n_jobs: int = -1,
-    random_state: Union[RandomState, int, None] = None,
+    random_state: RandomState | int | None = None,
     importance_type: Literal["conditional"] = "conditional",
 ) -> ConditionalImportances: ...
 
@@ -41,7 +40,7 @@ def compute_permutation_importance(
     y: pd.Series,
     n_repeats: int = 5,
     n_jobs: int = -1,
-    random_state: Union[RandomState, int, None] = None,
+    random_state: RandomState | int | None = None,
 ) -> Importances: ...
 
 
@@ -51,9 +50,9 @@ def compute_permutation_importance(
     y: pd.Series,
     n_repeats: int = 5,
     n_jobs: int = -1,
-    random_state: Union[RandomState, int, None] = None,
+    random_state: RandomState | int | None = None,
     importance_type: Literal["standard", "conditional"] = "standard",
-) -> Union[Importances, ConditionalImportances]:
+) -> Importances | ConditionalImportances:
     pfi = PermutationFeatureImportanceCalculator(n_repeats=n_repeats, n_jobs=n_jobs, random_state=random_state)
     if importance_type == "conditional":
         return compute_conditional_permutation_importance(
@@ -68,8 +67,8 @@ def compute_conditional_permutation_importance(
     y: pd.Series,
     n_repeats: int = 5,
     n_jobs: int = -1,
-    random_state: Union[RandomState, int, None] = None,
-) -> Union[Importances, ConditionalImportances]:
+    random_state: RandomState | int | None = None,
+) -> Importances | ConditionalImportances:
     pfi = PermutationFeatureImportanceCalculator(n_repeats=n_repeats, n_jobs=n_jobs, random_state=random_state)
     sample_groups = group_index_samples_by_learning_task(y, proxy.learning_task)
     values = {}
@@ -108,7 +107,7 @@ def __init__(
         self,
         n_repeats: int = 5,
         n_jobs: int = -1,
-        random_state: Union[RandomState, int, None] = None,
+        random_state: RandomState | int | None = None,
         importance_type: str = "global",
     ):
         if random_state is None:
diff --git a/src/holisticai/inspection/_shap.py b/src/holisticai/inspection/_shap.py
index 1ee90841..4c5d5949 100644
--- a/src/holisticai/inspection/_shap.py
+++ b/src/holisticai/inspection/_shap.py
@@ -1,21 +1,18 @@
 from __future__ import annotations
 
-from typing import Union
-
 import numpy as np
 import pandas as pd
-from numpy.random import RandomState
-
 from holisticai.datasets._dataset import Dataset
 from holisticai.inspection import group_mask_samples_by_learning_task
 from holisticai.utils import LocalImportances, ModelProxy
+from numpy.random import RandomState
 
 
 def compute_shap_feature_importance(
     proxy: ModelProxy,
     X: pd.DataFrame,
-    max_samples: Union[int, None] = None,
-    random_state: Union[RandomState, None] = None,
+    max_samples: int | None = None,
+    random_state: RandomState | None = None,
 ) -> LocalImportances:
     if random_state is None:
         random_state = RandomState(42)
@@ -57,7 +54,8 @@ def initialize_explainer(self, X: pd.DataFrame, proxy: ModelProxy):
         try:
             import shap  # type: ignore
         except ImportError:
-            raise ImportError("SHAP is not installed. Please install it using 'pip install shap'") from None
+            msg = "SHAP is not installed. Please install it using 'pip install shap'"
+            raise ImportError(msg) from None
 
         self.explainer = shap.Explainer(proxy.predict, X[:100])
 
diff --git a/src/holisticai/inspection/_surrogate_importance.py b/src/holisticai/inspection/_surrogate_importance.py
index 330068b3..3699fce9 100644
--- a/src/holisticai/inspection/_surrogate_importance.py
+++ b/src/holisticai/inspection/_surrogate_importance.py
@@ -1,16 +1,15 @@
 from __future__ import annotations
 
-from typing import Literal, Optional, Union, overload
+from typing import Literal, overload
 
 import numpy as np
 import pandas as pd
+from holisticai.inspection._utils import group_index_samples_by_learning_task
+from holisticai.utils._definitions import ConditionalImportances, Importances, ModelProxy
 from numpy.random import RandomState
 from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
 from sklearn.metrics import accuracy_score, mean_squared_error
 
-from holisticai.inspection._utils import group_index_samples_by_learning_task
-from holisticai.utils._definitions import ConditionalImportances, Importances, ModelProxy
-
 metric_scores = {
     "binary_classification": accuracy_score,
     "regression": mean_squared_error,
@@ -22,8 +21,8 @@
 def compute_surrogate_feature_importance(
     proxy: ModelProxy,
     X: pd.DataFrame,
-    y: Optional[pd.Series] = None,
-    random_state: Optional[Union[RandomState, int]] = None,
+    y: pd.Series | None = None,
+    random_state: RandomState | int | None = None,
 ) -> Importances: ...
 
 
@@ -31,8 +30,8 @@ def compute_surrogate_feature_importance(
 def compute_surrogate_feature_importance(
     proxy: ModelProxy,
     X: pd.DataFrame,
-    y: Optional[pd.Series] = None,
-    random_state: Union[RandomState, int, None] = None,
+    y: pd.Series | None = None,
+    random_state: RandomState | int | None = None,
     importance_type: Literal["conditional"] = "conditional",
 ) -> Importances: ...
 
@@ -40,10 +39,10 @@ def compute_surrogate_feature_importance(
 def compute_surrogate_feature_importance(
     proxy: ModelProxy,
     X: pd.DataFrame,
-    y: Optional[pd.Series] = None,
-    random_state: Optional[Union[RandomState, int]] = None,
+    y: pd.Series | None = None,
+    random_state: RandomState | int | None = None,
     importance_type: Literal["conditional", "standard"] = "standard",
-) -> Union[Importances, ConditionalImportances]:
+) -> Importances | ConditionalImportances:
     pfi = SurrogateFeatureImportanceCalculator(random_state=random_state)
     if importance_type == "conditional":
         y = pd.Series(proxy.predict(X)) if y is None else y
@@ -59,7 +58,7 @@ def compute_surrogate_feature_importance(
 class SurrogateFeatureImportanceCalculator:
     def __init__(
         self,
-        random_state: Union[RandomState, int, None] = None,
+        random_state: RandomState | int | None = None,
         importance_type: str = "global",
     ):
         if random_state is None:
@@ -92,7 +91,8 @@ def create_surrogate_model(self, X: pd.DataFrame, y: pd.Series, learning_task: s
                     best_tree = tree
 
         if best_tree is None:
-            raise ValueError(f"Surrogate model could not be created for learning task {learning_task}")
+            msg = f"Surrogate model could not be created for learning task {learning_task}"
+            raise ValueError(msg)
 
         return best_tree
 
diff --git a/src/holisticai/inspection/_utils.py b/src/holisticai/inspection/_utils.py
index e7d1243d..6221b4bf 100644
--- a/src/holisticai/inspection/_utils.py
+++ b/src/holisticai/inspection/_utils.py
@@ -1,7 +1,11 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 import numpy as np
-import pandas as pd
+
+if TYPE_CHECKING:
+    import pandas as pd
 
 
 def quantil_classify(q1, q2, q3, labels, x):
@@ -33,4 +37,5 @@ def group_mask_samples_by_learning_task(
         v = np.array(y.quantile(labels_values)).squeeze()
         return y.map(lambda x: quantil_classify(v[1], v[2], v[3], labels, x))
 
-    raise ValueError(f"Learning task {learning_task} not supported")
+    msg = f"Learning task {learning_task} not supported"
+    raise ValueError(msg)
diff --git a/src/holisticai/pipeline/_pipeline.py b/src/holisticai/pipeline/_pipeline.py
index d0fda05e..7bc44277 100644
--- a/src/holisticai/pipeline/_pipeline.py
+++ b/src/holisticai/pipeline/_pipeline.py
@@ -1,10 +1,9 @@
 import inspect
 
-from sklearn.pipeline import Pipeline as SKLPipeline
-from sklearn.utils.metaestimators import available_if
-
 from holisticai.pipeline._pipeline_helper import PipelineHelper
 from holisticai.utils.obj_rep.object_repr import PipelineReprObj
+from sklearn.pipeline import Pipeline as SKLPipeline
+from sklearn.utils.metaestimators import available_if
 
 
 def _fulfill_conditions(fn_name: str):
diff --git a/src/holisticai/pipeline/_pipeline_helper.py b/src/holisticai/pipeline/_pipeline_helper.py
index 8937b924..31081b81 100644
--- a/src/holisticai/pipeline/_pipeline_helper.py
+++ b/src/holisticai/pipeline/_pipeline_helper.py
@@ -1,8 +1,7 @@
-from sklearn.pipeline import Pipeline as SKLPipeline
-
 from holisticai.pipeline.handlers._estimator import EstimatorHandler
 from holisticai.pipeline.handlers._pipeline_params import PipelineParametersHandler
 from holisticai.pipeline.handlers._utransformers import UTransformersHandler
+from sklearn.pipeline import Pipeline as SKLPipeline
 
 SUPPORTED_FUNCTIONS = [
     "fit",
diff --git a/src/holisticai/robustness/__init__.py b/src/holisticai/robustness/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/src/holisticai/robustness/attackers/classification/commons.py b/src/holisticai/robustness/attackers/classification/commons.py
index d9385ca0..895851f2 100644
--- a/src/holisticai/robustness/attackers/classification/commons.py
+++ b/src/holisticai/robustness/attackers/classification/commons.py
@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional, Union
-
 import numpy as np
 import pandas as pd
 
@@ -14,7 +12,7 @@ def x_to_nd_array(x: pd.DataFrame):
     return np.array(x)
 
 
-def to_categorical(labels: Union[np.ndarray, list[float]], nb_classes: Optional[int] = None) -> np.ndarray:
+def to_categorical(labels: np.ndarray | list[float], nb_classes: int | None = None) -> np.ndarray:
     """
     Convert an array of labels to binary class matrix.
 
diff --git a/src/holisticai/robustness/attackers/classification/hop_skip_jump.py b/src/holisticai/robustness/attackers/classification/hop_skip_jump.py
index 317fe971..7cb0366f 100644
--- a/src/holisticai/robustness/attackers/classification/hop_skip_jump.py
+++ b/src/holisticai/robustness/attackers/classification/hop_skip_jump.py
@@ -7,12 +7,14 @@
 
 from __future__ import annotations
 
-from typing import Optional, Union
+from typing import TYPE_CHECKING
 
 import numpy as np
-import pandas as pd
 from holisticai.robustness.attackers.classification.commons import x_array_to_df, x_to_nd_array
 
+if TYPE_CHECKING:
+    import pandas as pd
+
 
 class HopSkipJump:
     """
@@ -102,7 +104,7 @@ def predict(self, x: np.ndarray):
         return np.array(self.predictor(x_df))
 
     def generate(
-        self, x_df: pd.DataFrame, y: Optional[np.ndarray] = None, mask: Optional[np.ndarray] = None, x_adv_init=None
+        self, x_df: pd.DataFrame, y: np.ndarray | None = None, mask: np.ndarray | None = None, x_adv_init=None
     ) -> pd.DataFrame:
         """
         Generate adversarial samples and return them in an array.
@@ -137,7 +139,8 @@ def generate(
         if y is None:
             # Throw error if attack is targeted, but no targets are provided
             if self.targeted:  # pragma: no cover
-                raise ValueError("Target labels `y` need to be provided for a targeted attack.")
+                msg = "Target labels `y` need to be provided for a targeted attack."
+                raise ValueError(msg)
 
             # Use model predictions as correct outputs
             y = self.predict(x)
@@ -210,7 +213,7 @@ def _perturb(
         y_p: int,
         init_pred: int,
         adv_init: np.ndarray,
-        mask: Optional[np.ndarray],
+        mask: np.ndarray | None,
     ) -> np.ndarray:
         """
         Internal attack function for one example.
@@ -244,9 +247,7 @@ def _perturb(
             return x
 
         # If an initial adversarial example found, then go with HopSkipJump attack
-        x_adv = self._attack(initial_sample[0], x, initial_sample[1], mask)
-
-        return x_adv
+        return self._attack(initial_sample[0], x, initial_sample[1], mask)
 
     def _init_sample(
         self,
@@ -255,8 +256,8 @@ def _init_sample(
         y_p: int,
         init_pred: int,
         adv_init: np.ndarray,
-        mask: Optional[np.ndarray],
-    ) -> Optional[Union[np.ndarray, tuple[np.ndarray, int]]]:
+        mask: np.ndarray | None,
+    ) -> np.ndarray | tuple[np.ndarray, int] | None:
         """
         Find initial adversarial example for the attack.
 
@@ -349,7 +350,7 @@ def _attack(
         initial_sample: np.ndarray,
         original_sample: np.ndarray,
         target: int,
-        mask: Optional[np.ndarray],
+        mask: np.ndarray | None,
     ) -> np.ndarray:
         """
         Main function for the boundary attack.
@@ -435,8 +436,8 @@ def _binary_search(
         current_sample: np.ndarray,
         original_sample: np.ndarray,
         target: int,
-        norm: Union[int, float, str],  # noqa: PYI041
-        threshold: Optional[float] = None,
+        norm: int | float | str,  # noqa: PYI041
+        threshold: float | None = None,
     ) -> np.ndarray:
         """
         Binary search to approach the boundary.
@@ -494,15 +495,13 @@ def _binary_search(
             lower_bound = np.where(satisfied == 0, alpha, lower_bound)
             upper_bound = np.where(satisfied == 1, alpha, upper_bound)
 
-        result = self._interpolate(
+        return self._interpolate(
             current_sample=current_sample,
             original_sample=original_sample,
             alpha=float(upper_bound),
             norm=norm,
         )
 
-        return result
-
     def _compute_delta(
         self,
         current_sample: np.ndarray,
@@ -543,7 +542,7 @@ def _compute_update(
         num_eval: int,
         delta: float,
         target: int,
-        mask: Optional[np.ndarray],
+        mask: np.ndarray | None,
     ) -> np.ndarray:
         """
         Compute the update in Eq.(14).
@@ -603,9 +602,7 @@ def _compute_update(
             grad = np.mean(f_val * rnd_noise, axis=0)
 
         # Compute update
-        result = grad / np.linalg.norm(grad) if self.norm == 2 else np.sign(grad)
-
-        return result
+        return grad / np.linalg.norm(grad) if self.norm == 2 else np.sign(grad)
 
     def _adversarial_satisfactory(self, samples: np.ndarray, target: int) -> np.ndarray:
         """
@@ -626,16 +623,14 @@ def _adversarial_satisfactory(self, samples: np.ndarray, target: int) -> np.ndar
         samples = np.clip(samples, self._clip_min, self._clip_max)
         preds = self.predict(samples)
 
-        result = preds == target if self.targeted else preds != target
-
-        return result
+        return preds == target if self.targeted else preds != target
 
     @staticmethod
     def _interpolate(
         current_sample: np.ndarray,
         original_sample: np.ndarray,
         alpha: float,
-        norm: Union[int, float, str],  # noqa: PYI041
+        norm: int | float | str,  # noqa: PYI041
     ) -> np.ndarray:
         """
         Interpolate a new sample based on the original and the current samples.
diff --git a/src/holisticai/robustness/attackers/classification/zeroth_order_optimization.py b/src/holisticai/robustness/attackers/classification/zeroth_order_optimization.py
index 274c5795..3566f22d 100644
--- a/src/holisticai/robustness/attackers/classification/zeroth_order_optimization.py
+++ b/src/holisticai/robustness/attackers/classification/zeroth_order_optimization.py
@@ -8,10 +8,9 @@
 
 from __future__ import annotations
 
-from typing import Any, Optional
+from typing import TYPE_CHECKING, Any
 
 import numpy as np
-import pandas as pd
 from holisticai.robustness.attackers.classification.commons import (
     format_function_predict_proba,
     to_categorical,
@@ -20,6 +19,9 @@
 )
 from scipy.ndimage import zoom
 
+if TYPE_CHECKING:
+    import pandas as pd
+
 BATCH_SIZE = 1
 
 
@@ -132,10 +134,11 @@ def _initialize_vars(self, x: np.ndarray) -> None:
         if len(self.input_shape) == 1:
             self.input_is_feature_vector = True
             if self.batch_size != 1:
-                raise ValueError(
+                msg = (
                     "The current implementation of Zeroth-Order Optimisation attack only supports "
                     "`batch_size=1` with feature vectors as input."
                 )
+                raise ValueError(msg)
         else:
             self.input_is_feature_vector = False
 
@@ -196,7 +199,7 @@ def _loss(
 
         return preds, l2dist, c_weight * loss + l2dist
 
-    def generate(self, x_df: pd.DataFrame, y: Optional[np.ndarray] = None) -> pd.DataFrame:
+    def generate(self, x_df: pd.DataFrame, y: np.ndarray | None = None) -> pd.DataFrame:
         """
         Generate adversarial samples and return them in an array.
 
@@ -225,16 +228,16 @@ def generate(self, x_df: pd.DataFrame, y: Optional[np.ndarray] = None) -> pd.Dat
 
         # Check that `y` is provided for targeted attacks
         if self.targeted and y is None:  # pragma: no cover
-            raise ValueError("Target labels `y` need to be provided for a targeted attack.")
+            msg = "Target labels `y` need to be provided for a targeted attack."
+            raise ValueError(msg)
 
         # No labels provided, use model prediction as correct class
         if y is None:
             y = self.predict_proba(x)
 
         if self.nb_classes == 2 and y.shape[1] == 1:  # pragma: no cover
-            raise ValueError(
-                "This attack has not yet been tested for binary classification with a single output classifier."
-            )
+            msg = "This attack has not yet been tested for binary classification with a single output classifier."
+            raise ValueError(msg)
 
         # Compute adversarial examples with implicit batching
         nb_batches = int(np.ceil(x.shape[0] / float(self.batch_size)))
@@ -526,10 +529,11 @@ def _optimizer(self, x: np.ndarray, targets: np.ndarray, c_batch: np.ndarray) ->
                 )
             except ValueError as error:  # pragma: no cover
                 if "Cannot take a larger sample than population when 'replace=False'" in str(error):
-                    raise ValueError(
+                    msg = (
                         "Too many samples are requested for the random indices. Try to reduce the number of parallel"
                         "coordinate updates `nb_parallel`."
-                    ) from error
+                    )
+                    raise ValueError(msg) from error
 
                 raise
 
@@ -560,7 +564,8 @@ def _optimizer(self, x: np.ndarray, targets: np.ndarray, c_batch: np.ndarray) ->
                 True,
             )
         else:
-            raise ValueError("Unexpected `None` in `adam_mean`, `adam_var` or `adam_epochs` detected.")
+            msg = "Unexpected `None` in `adam_mean`, `adam_var` or `adam_epochs` detected."
+            raise ValueError(msg)
 
         if self.use_importance and self._current_noise.shape[2] > self._init_size:
             self._sample_prob = self._get_prob(self._current_noise).flatten()
@@ -626,7 +631,7 @@ def _optimizer_adam_coordinate(
 
         return current_noise.reshape(orig_shape)
 
-    def _reset_adam(self, nb_vars: int, indices: Optional[np.ndarray] = None) -> None:
+    def _reset_adam(self, nb_vars: int, indices: np.ndarray | None = None) -> None:
         """
         Reset the ADAM optimizer.
 
diff --git a/src/holisticai/robustness/attackers/regression/gb_attackers.py b/src/holisticai/robustness/attackers/regression/gb_attackers.py
index 3d661f81..cb112832 100644
--- a/src/holisticai/robustness/attackers/regression/gb_attackers.py
+++ b/src/holisticai/robustness/attackers/regression/gb_attackers.py
@@ -121,8 +121,7 @@ def _compute_sigma(self):
             The covariance matrix.
         """
         sigma = np.dot(np.transpose(self.trnx), self.trnx)
-        sigma = sigma / self.trnx.shape[0]
-        return sigma
+        return sigma / self.trnx.shape[0]
 
     def _compute_mu(self):
         """
@@ -133,8 +132,7 @@ def _compute_mu(self):
         array-like, shape (n_features,)
             The mean of the input samples.
         """
-        mu = np.mean(np.matrix(self.trnx), axis=0)
-        return mu
+        return np.mean(np.matrix(self.trnx), axis=0)
 
     def _compute_m(self, clf, poisxelem, poisyelem):
         """
@@ -159,8 +157,7 @@ def _compute_m(self, clf, poisxelem, poisyelem):
         wtransp = np.reshape(w, (1, self.feanum))
         errterm = (np.dot(w, poisxelemtransp) + b - poisyelem).reshape((1, 1))
         first = np.dot(poisxelemtransp, wtransp)
-        m = first + errterm[0, 0] * np.identity(self.feanum)
-        return m
+        return first + errterm[0, 0] * np.identity(self.feanum)
 
     def _compute_wb_zc(self, eq7lhs, mu, w, m, n, poisxelem):  # noqa: ARG002
         """
@@ -220,8 +217,7 @@ def _compute_r(self, clf, lam):  # noqa: ARG002
         array-like, shape (1, n_features)
             The regularization term.
         """
-        r = np.zeros((1, self.feanum))
-        return r
+        return np.zeros((1, self.feanum))
 
     def _comp_obj_trn(self, clf, lam, otherargs):  # noqa: ARG002
         """
@@ -242,9 +238,7 @@ def _comp_obj_trn(self, clf, lam, otherargs):  # noqa: ARG002
             The objective value.
         """
         errs = clf.predict(np.asarray(self.trnx)) - self.trny
-        mse = np.linalg.norm(errs) ** 2 / self.samplenum
-
-        return mse
+        return np.linalg.norm(errs) ** 2 / self.samplenum
 
     def _comp_attack_trn(self, clf, wxc, bxc, wyc, byc, otherargs):  # noqa: ARG002
         """
@@ -458,8 +452,7 @@ def _compute_sigma(self):
         """
         basesigma = np.dot(np.transpose(self.trnx), self.trnx)
         basesigma = basesigma / self.trnx.shape[0]
-        sigma = basesigma + self.initlam * np.eye(self.feanum)
-        return sigma
+        return basesigma + self.initlam * np.eye(self.feanum)
 
     def learn_model(self, x, y, clf, lam=None):
         """
@@ -495,8 +488,7 @@ def _compute_mu(self):
         array-like, shape (n_features,)
             The mean of the input samples.
         """
-        mu = np.mean(np.matrix(self.trnx), axis=0)
-        return mu
+        return np.mean(np.matrix(self.trnx), axis=0)
 
     def _compute_m(self, clf, poisxelem, poisyelem):
         """
@@ -521,8 +513,7 @@ def _compute_m(self, clf, poisxelem, poisyelem):
         wtransp = np.reshape(w, (1, self.feanum))
         errterm = (np.dot(w, poisxelemtransp) + b - poisyelem).reshape((1, 1))
         first = np.dot(poisxelemtransp, wtransp)
-        m = first + errterm[0, 0] * np.identity(self.feanum)
-        return m
+        return first + errterm[0, 0] * np.identity(self.feanum)
 
     def _compute_wb_zc(self, eq7lhs, mu, w, m, n, poisxelem):  # noqa: ARG002
         """
diff --git a/src/holisticai/robustness/metrics/classification/_binary_classification.py b/src/holisticai/robustness/metrics/classification/_binary_classification.py
index 8a9a215b..45a83d81 100644
--- a/src/holisticai/robustness/metrics/classification/_binary_classification.py
+++ b/src/holisticai/robustness/metrics/classification/_binary_classification.py
@@ -36,7 +36,8 @@ def adversarial_accuracy(y, y_pred, y_adv_pred):
         y_pred = np.array(y_pred)
         y_adv_pred = np.array(y_adv_pred)
     except Exception as e:
-        raise ValueError("One or more inputs could not be converted to a numpy array.") from e
+        msg = "One or more inputs could not be converted to a numpy array."
+        raise ValueError(msg) from e
 
     if y is None:
         idxs = y_pred == y_adv_pred
@@ -91,11 +92,13 @@ def empirical_robustness(
         y_pred = np.array(y_pred)
         y_adv_pred = np.array(y_adv_pred)
     except Exception as e:
-        raise ValueError("One or more inputs could not be converted to a numpy array.") from e
+        msg = "One or more inputs could not be converted to a numpy array."
+        raise ValueError(msg) from e
 
     # Verify that `norm` has the correct type
     if not isinstance(norm, int):
-        raise TypeError("norm must be of type int")
+        msg = "norm must be of type int"
+        raise TypeError(msg)
 
     idxs = y_adv_pred != y_pred
     if np.sum(idxs) == 0.0:
diff --git a/src/holisticai/robustness/metrics/dataset_shift/_accuracy_degradation_profile.py b/src/holisticai/robustness/metrics/dataset_shift/_accuracy_degradation_profile.py
index 04df48b8..5981fae0 100644
--- a/src/holisticai/robustness/metrics/dataset_shift/_accuracy_degradation_profile.py
+++ b/src/holisticai/robustness/metrics/dataset_shift/_accuracy_degradation_profile.py
@@ -27,7 +27,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Optional
+from typing import Any
 
 import numpy as np
 import pandas as pd
@@ -91,8 +91,8 @@ def accuracy_degradation_profile(
     y_test: pd.Series,
     y_pred: pd.Series,
     n_neighbors: int = 5,
-    neighbor_estimator: Optional[Any] = None,
-    baseline_accuracy: Optional[float] = None,
+    neighbor_estimator: Any | None = None,
+    baseline_accuracy: float | None = None,
     threshold_percentual: float = 0.95,
     above_percentual: float = 0.90,
     step_size: float = STEP_SIZE,
@@ -184,7 +184,8 @@ def accuracy_degradation_profile(
 
     # Check if the step size is too small
     if step_size < (1 / X_test.shape[0]):
-        raise ValueError("'step_size' is too small (less than 1 divided by the number of samples).")
+        msg = "'step_size' is too small (less than 1 divided by the number of samples)."
+        raise ValueError(msg)
 
     # Validate inputs
     if isinstance(X_test, pd.DataFrame):
@@ -212,9 +213,7 @@ def accuracy_degradation_profile(
     results_summary_df = _summarize_results(results_df, baseline_accuracy, threshold_percentual, above_percentual)
 
     # Apply styling
-    styled_df = _styled_results(results_summary_df)
-
-    return styled_df
+    return _styled_results(results_summary_df)
 
 
 def _validate_inputs(
@@ -287,13 +286,17 @@ def _validate_inputs(
     """
 
     if len(X_test) != len(y_test) or len(y_test) != len(y_pred):
-        raise ValueError("X_test, y_test, and y_pred must have the same length.")
+        msg = "X_test, y_test, and y_pred must have the same length."
+        raise ValueError(msg)
     if not (0 < threshold_percentual <= 1):
-        raise ValueError("threshold_percentual must be between 0 and 1.")
+        msg = "threshold_percentual must be between 0 and 1."
+        raise ValueError(msg)
     if not (0 < above_percentual <= 1):
-        raise ValueError("above_percentual must be between 0 and 1.")
+        msg = "above_percentual must be between 0 and 1."
+        raise ValueError(msg)
     if not (0 < baseline_accuracy <= 1):
-        raise ValueError("baseline_accuracy must be between 0 and 1.")
+        msg = "baseline_accuracy must be between 0 and 1."
+        raise ValueError(msg)
 
 
 def batched(X, batch_size=100):
@@ -368,7 +371,8 @@ def _calculate_accuracies(
 
     # Validate step_size input
     if not (0 < step_size <= 1):
-        raise ValueError("step_size must be between 0 and 1.")
+        msg = "step_size must be between 0 and 1."
+        raise ValueError(msg)
 
     # Auxiliary data structures
     full_set_size = X_test.shape[0]
@@ -565,5 +569,4 @@ def _styled_results(results_summary_df: pd.DataFrame, decision_column: str = DEC
     pd.DataFrame
         DataFrame with color-coded decisions.
     """
-    styled_df = results_summary_df.style.map(_color_cells, subset=[decision_column])
-    return styled_df
+    return results_summary_df.style.map(_color_cells, subset=[decision_column])
diff --git a/src/holisticai/robustness/plots/_dataset_shift.py b/src/holisticai/robustness/plots/_dataset_shift.py
index 037819c3..c9820381 100644
--- a/src/holisticai/robustness/plots/_dataset_shift.py
+++ b/src/holisticai/robustness/plots/_dataset_shift.py
@@ -71,7 +71,8 @@ def _validate_and_extract_data(data):
     # Check if data is a pandas DataFrame
     if isinstance(data, pd.DataFrame):
         if data.shape[1] != 2:
-            raise ValueError("Data should have exactly two columns.")
+            msg = "Data should have exactly two columns."
+            raise ValueError(msg)
         data_vals = data.values  # Convert DataFrame to NumPy array
     # Check if data is a pandas Series
     elif isinstance(data, pd.Series):
@@ -82,7 +83,8 @@ def _validate_and_extract_data(data):
 
     # Raise error if the data is not a DataFrame or NumPy array
     else:
-        raise TypeError("Data must be either a pandas DataFrame or a NumPy array.")
+        msg = "Data must be either a pandas DataFrame or a NumPy array."
+        raise TypeError(msg)
 
     return data_vals
 
@@ -212,7 +214,8 @@ def plot_2d(X, y, highlight_group=None, show_just_group=None, features_to_plot=N
         # If highlight_group is provided, outline the selected points
         if highlight_group is not None:
             if not isinstance(highlight_group, (np.ndarray, list)):
-                raise TypeError("highlight_group must be either a list or a NumPy array.")
+                msg = "highlight_group must be either a list or a NumPy array."
+                raise TypeError(msg)
 
             plt.scatter(
                 X_vals[highlight_group, 0],
@@ -485,7 +488,8 @@ def plot_neighborhood(
 
     for sample_index in points_of_interest:
         if sample_index not in indices_show:
-            raise ValueError(f"The point {sample_index} is not a point in 'indices_show'.")
+            msg = f"The point {sample_index} is not a point in 'indices_show'."
+            raise ValueError(msg)
 
         # Find the position of sample_index in indices_show
         position = np.where(indices_show == sample_index)[0]
diff --git a/src/holisticai/robustness/plots/_utils.py b/src/holisticai/robustness/plots/_utils.py
index 79213bf4..930d0212 100644
--- a/src/holisticai/robustness/plots/_utils.py
+++ b/src/holisticai/robustness/plots/_utils.py
@@ -55,18 +55,22 @@ def prepare_to_plot(
 
     # Check if X is a DataFrame and y is a NumPy array
     if not isinstance(X, pd.DataFrame):
-        raise TypeError("X must be a pandas DataFrame.")
+        msg = "X must be a pandas DataFrame."
+        raise TypeError(msg)
     if not isinstance(y, np.ndarray):
-        raise TypeError("y must be a NumPy array.")
+        msg = "y must be a NumPy array."
+        raise TypeError(msg)
 
     # Check if all the features are present in X
     missing_features = [feature for feature in features_to_plot if feature not in X.columns]
     if missing_features:
-        raise KeyError(f"The following features are missing from X: {', '.join(missing_features)}")
+        msg = f"The following features are missing from X: {', '.join(missing_features)}"
+        raise KeyError(msg)
 
     # Check if the length of X and y match
     if len(X) != len(y):
-        raise ValueError("The length of X and y must match.")
+        msg = "The length of X and y must match."
+        raise ValueError(msg)
 
     # Select only the columns for the chosen features to plot
     X_selected = X[features_to_plot]
diff --git a/src/holisticai/security/__init__.py b/src/holisticai/security/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/src/holisticai/security/commons/_black_box_attack.py b/src/holisticai/security/commons/_black_box_attack.py
index 4df03cb0..c2824469 100644
--- a/src/holisticai/security/commons/_black_box_attack.py
+++ b/src/holisticai/security/commons/_black_box_attack.py
@@ -88,4 +88,5 @@ def classification_security_features(X, y, attacker, attack_feature):
         attacker = BlackBoxAttack(learning_task="classification", attack_feature=attack_feature, attack_train_ratio=0.5)
         attacker.fit(X, y)
         return attacker
-    raise ValueError("Invalid attacker type. Please choose from 'black_box'")
+    msg = "Invalid attacker type. Please choose from 'black_box'"
+    raise ValueError(msg)
diff --git a/src/holisticai/security/commons/data_minimization/_core.py b/src/holisticai/security/commons/data_minimization/_core.py
index bb5c3262..2e2a651a 100644
--- a/src/holisticai/security/commons/data_minimization/_core.py
+++ b/src/holisticai/security/commons/data_minimization/_core.py
@@ -1,12 +1,14 @@
 from __future__ import annotations
 
 import logging
-from typing import Optional
+from typing import TYPE_CHECKING
 
-import pandas as pd
 from holisticai.security.commons.data_minimization._modificators import ModifierHandler, ModifierType
 from holisticai.security.commons.data_minimization._selectors import SelectorsHandler, SelectorType
-from holisticai.utils import ModelProxy
+
+if TYPE_CHECKING:
+    import pandas as pd
+    from holisticai.utils import ModelProxy
 
 logger = logging.getLogger(__name__)
 
@@ -15,8 +17,8 @@ class DataMinimizer:
     def __init__(
         self,
         proxy: ModelProxy,
-        selector_types: Optional[list[SelectorType]] = None,
-        modifier_types: Optional[list[ModifierType]] = None,
+        selector_types: list[SelectorType] | None = None,
+        modifier_types: list[ModifierType] | None = None,
     ):
         if modifier_types is None:
             modifier_types = ["Average", "Permutation"]
diff --git a/src/holisticai/security/commons/data_minimization/_modificators.py b/src/holisticai/security/commons/data_minimization/_modificators.py
index e0390d12..7a4e00c3 100644
--- a/src/holisticai/security/commons/data_minimization/_modificators.py
+++ b/src/holisticai/security/commons/data_minimization/_modificators.py
@@ -22,7 +22,8 @@ def apply_method(self, method_name: ModifierType, x, indexes) -> pd.DataFrame:
             return replace_data_with_average(x, indexes)
         if method_name == "Permutation":
             return replace_data_with_permutation(x, indexes)
-        raise NotImplementedError(f"Method {method_name} not implemented")
+        msg = f"Method {method_name} not implemented"
+        raise NotImplementedError(msg)
 
 
 def replace_data_with_average(x, important_feature_names):
diff --git a/src/holisticai/security/commons/data_minimization/_selectors.py b/src/holisticai/security/commons/data_minimization/_selectors.py
index c9b7518b..ede69fef 100644
--- a/src/holisticai/security/commons/data_minimization/_selectors.py
+++ b/src/holisticai/security/commons/data_minimization/_selectors.py
@@ -1,12 +1,10 @@
 from __future__ import annotations
 
 import logging
-from typing import Literal, get_args
+from typing import TYPE_CHECKING, Literal, get_args
 
 import numpy as np
-import pandas as pd
 from holisticai.inspection import compute_permutation_importance
-from holisticai.utils import Importances, ModelProxy
 from sklearn.feature_selection import (
     SelectPercentile,
     VarianceThreshold,
@@ -14,6 +12,10 @@
     f_regression,
 )
 
+if TYPE_CHECKING:
+    import pandas as pd
+    from holisticai.utils import Importances, ModelProxy
+
 logger = logging.getLogger(__name__)
 SelectorbyData = Literal["Percentile", "Variance"]
 SelectorbyImportance = Literal["FImportance"]
@@ -25,7 +27,8 @@ def get_score_fn(learning_task: str):
         return f_classif
     if learning_task == "regression":
         return f_regression
-    raise ValueError(f"Learning task {learning_task} not supported")
+    msg = f"Learning task {learning_task} not supported"
+    raise ValueError(msg)
 
 
 class SelectorsHandler:
@@ -53,7 +56,8 @@ def _get_selectors_from_data(self, selector_type: SelectorbyData):
             for p in variance_thresholds:
                 methods[f"Variance >{p}"] = VarianceThreshold(threshold=p / 100)
             return methods
-        raise ValueError(f"Selector type {selector_type} not supported")
+        msg = f"Selector type {selector_type} not supported"
+        raise ValueError(msg)
 
     def _get_selectors_from_importances(self, selector_type: SelectorbyImportance):
         if selector_type == "FImportance":
@@ -61,7 +65,8 @@ def _get_selectors_from_importances(self, selector_type: SelectorbyImportance):
             for p in self.importance_thresholds:
                 methods[f"FImportance >{p}"] = SelectFromFeatureImportance(threshold=p / 100)
             return methods
-        raise ValueError(f"Selector type {selector_type} not supported")
+        msg = f"Selector type {selector_type} not supported"
+        raise ValueError(msg)
 
     def fit(self, X: pd.DataFrame, y: pd.Series):
         selectors_by_data = {}
diff --git a/src/holisticai/security/metrics/__init__.py b/src/holisticai/security/metrics/__init__.py
index 75f8c764..072736df 100644
--- a/src/holisticai/security/metrics/__init__.py
+++ b/src/holisticai/security/metrics/__init__.py
@@ -4,8 +4,6 @@
 
 from __future__ import annotations
 
-from typing import Union
-
 import pandas as pd
 from holisticai.security.metrics._anonymization import k_anonymity, l_diversity
 from holisticai.security.metrics._attribute_attack import AttributeAttackScore, attribute_attack_score
@@ -26,7 +24,7 @@ def classification_privacy_metrics(
     y_pred_train: pd.Series,
     y_pred_test: pd.Series,
     y_pred_test_dm: dict[str, : pd.Series],
-    attribute_attack: Union[str, list[str]],
+    attribute_attack: str | list[str],
 ):
     shapr_score = ShaprScore()
     dm_accuracy_ratio = DataMinimizationAccuracyRatio()
@@ -52,7 +50,7 @@ def regression_privacy_metrics(
     y_test: pd.Series,
     y_pred_test: pd.Series,
     y_pred_test_dm: dict[str, : pd.Series],
-    attribute_attack: Union[str, list[str]],
+    attribute_attack: str | list[str],
 ):
     attr_attack_score = AttributeAttackScore()
     dm_mse_ratio = DataMinimizationMSERatio()
diff --git a/src/holisticai/security/metrics/_attribute_attack.py b/src/holisticai/security/metrics/_attribute_attack.py
index 1a76a8d1..c5bfc5bf 100644
--- a/src/holisticai/security/metrics/_attribute_attack.py
+++ b/src/holisticai/security/metrics/_attribute_attack.py
@@ -1,13 +1,15 @@
 from __future__ import annotations
 
-from typing import Any, Callable, Union
+from typing import TYPE_CHECKING, Any, Callable
 
-import pandas as pd
 from holisticai.security.commons import BlackBoxAttack
 from holisticai.security.metrics._utils import check_valid_output_type
 from sklearn.linear_model import LinearRegression, LogisticRegression
 from sklearn.metrics import accuracy_score, f1_score, mean_absolute_error, mean_squared_error
 
+if TYPE_CHECKING:
+    import pandas as pd
+
 
 def to_numerical_or_categorical(y: pd.Series):
     if y.dtype.kind in ["f"]:
@@ -17,7 +19,8 @@ def to_numerical_or_categorical(y: pd.Series):
         return y.astype("category")
 
     if len(y.unique()) < 2:
-        raise ValueError("The target variable must have more than 1 unique value")
+        msg = "The target variable must have more than 1 unique value"
+        raise ValueError(msg)
     return y.astype("category")
 
 
@@ -33,7 +36,7 @@ def __call__(
         y_test: pd.Series,
         attribute_attack: str,
         attack_train_ratio: float = 0.5,
-        metric_fn: Union[str, Callable, None] = None,
+        metric_fn: str | Callable | None = None,
         attacker_estimator: Any = None,
     ) -> float:
         check_valid_output_type(y_train)
diff --git a/src/holisticai/security/metrics/_data_minimization.py b/src/holisticai/security/metrics/_data_minimization.py
index dd075cb8..32daea51 100644
--- a/src/holisticai/security/metrics/_data_minimization.py
+++ b/src/holisticai/security/metrics/_data_minimization.py
@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Union
-
 import numpy as np
 import pandas as pd
 from sklearn.metrics import accuracy_score, mean_squared_error
@@ -86,7 +84,8 @@ def get_learning_task(y_true: pd.Series):
         return "classification"
     if y_true.dtype.kind in ["f"]:
         return "regression"
-    raise ValueError(f"Unknown learning task. dtype: {y_true.dtype.kind}")
+    msg = f"Unknown learning task. dtype: {y_true.dtype.kind}"
+    raise ValueError(msg)
 
 
 def data_minimization_score(
@@ -94,7 +93,7 @@ def data_minimization_score(
     y_pred: pd.Series,
     y_pred_dm: dict[str, pd.Series],
     return_results=False,
-    learning_task: Union[str, None] = None,
+    learning_task: str | None = None,
 ):
     """
     Calculate the accuracy ratio for data minimization. The accuracy ratio is the ratio of the accuracy of the data minimization model to the accuracy of the original model.
diff --git a/src/holisticai/security/metrics/_privacy_risk_score.py b/src/holisticai/security/metrics/_privacy_risk_score.py
index 5c52e965..6393beb4 100644
--- a/src/holisticai/security/metrics/_privacy_risk_score.py
+++ b/src/holisticai/security/metrics/_privacy_risk_score.py
@@ -283,5 +283,4 @@ def privacy_risk_score(shadow_train, shadow_test, target_train):
     tr_distrs, te_distrs, all_bins = distrs_compute(
         shadow_train_m_entr, shadow_test_m_entr, shadow_train_labels, shadow_test_labels, num_bins=5, log_bins=True
     )
-    risk_score = _risk_score_compute(tr_distrs, te_distrs, all_bins, target_train_m_entr, target_train_labels)
-    return risk_score
+    return _risk_score_compute(tr_distrs, te_distrs, all_bins, target_train_m_entr, target_train_labels)
diff --git a/src/holisticai/security/metrics/_shapr.py b/src/holisticai/security/metrics/_shapr.py
index 669264da..8c01002a 100644
--- a/src/holisticai/security/metrics/_shapr.py
+++ b/src/holisticai/security/metrics/_shapr.py
@@ -1,9 +1,8 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING
 
 import numpy as np
-import pandas as pd
 from holisticai.typing import ArrayLike
 from holisticai.utils.models.neighbors import KNeighborsClassifier
 from sklearn.preprocessing import LabelEncoder
@@ -17,6 +16,7 @@
 
 
 if TYPE_CHECKING:
+    import pandas as pd
     from numpy.typing import ArrayLike
 
 
@@ -62,7 +62,8 @@ def check_and_transform_label_format(labels: np.ndarray):
     :return: Labels with shape `(nb_samples, nb_classes)` (one-hot) or `(nb_samples,)` (index).
     """
     if one_hot is None or jnp is None:
-        raise ImportError("jax or jax.nn is not installed. Please install it with `pip install jax jaxlib`.")
+        msg = "jax or jax.nn is not installed. Please install it with `pip install jax jaxlib`."
+        raise ImportError(msg)
 
     labels = jnp.array(labels)
     return_one_hot = True
@@ -110,9 +111,10 @@ def __call__(
         batch_size=500,
         train_size=1.0,
         aggregated=True,
-    ) -> Union[np.ndarray, float]:
+    ) -> np.ndarray | float:
         if one_hot is None or jnp is None:
-            raise ImportError("jax or jax.nn is not installed. Please install it with `pip install jax jaxlib`.")
+            msg = "jax or jax.nn is not installed. Please install it with `pip install jax jaxlib`."
+            raise ImportError(msg)
 
         y_train, le = transform_label_to_numerical_label(y_train)
         y_test = transform_label_to_numerical_label(y_test, le)
diff --git a/src/holisticai/security/metrics/_utils.py b/src/holisticai/security/metrics/_utils.py
index 223051d8..5a24c14f 100644
--- a/src/holisticai/security/metrics/_utils.py
+++ b/src/holisticai/security/metrics/_utils.py
@@ -6,4 +6,5 @@ def check_valid_output_type(y_true: pd.Series):
         return "classification"
     if y_true.dtype.kind in ["f"]:
         return "regression"
-    raise ValueError(f"The target variable must be either continuous or categorical, found: {y_true.dtype}")
+    msg = f"The target variable must be either continuous or categorical, found: {y_true.dtype}"
+    raise ValueError(msg)
diff --git a/src/holisticai/security/mitigation/_anonymization.py b/src/holisticai/security/mitigation/_anonymization.py
index ef49147e..7eff8fc1 100644
--- a/src/holisticai/security/mitigation/_anonymization.py
+++ b/src/holisticai/security/mitigation/_anonymization.py
@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from collections import Counter
-from typing import Optional, Union
 
 import numpy as np
 import pandas as pd
@@ -55,18 +54,20 @@ class Anonymize:
     def __init__(
         self,
         k: int,
-        quasi_identifiers: Union[np.ndarray, list],
-        features: Optional[list] = None,
-        features_names: Optional[list] = None,
-        quasi_identifer_slices: Optional[list] = None,
-        categorical_features: Optional[list] = None,
-        is_regression: Optional[bool] = False,
-        train_only_QI: Optional[bool] = False,
+        quasi_identifiers: np.ndarray | list,
+        features: list | None = None,
+        features_names: list | None = None,
+        quasi_identifer_slices: list | None = None,
+        categorical_features: list | None = None,
+        is_regression: bool | None = False,
+        train_only_QI: bool | None = False,
     ):
         if k < 2:
-            raise ValueError("k should be a positive integer with a value of 2 or higher")
+            msg = "k should be a positive integer with a value of 2 or higher"
+            raise ValueError(msg)
         if quasi_identifiers is None or len(quasi_identifiers) < 1:
-            raise ValueError("The list of quasi-identifiers cannot be empty")
+            msg = "The list of quasi-identifiers cannot be empty"
+            raise ValueError(msg)
 
         self.k = k
         self.quasi_identifiers = quasi_identifiers
@@ -99,22 +100,25 @@ def anonymize(self, X_train, y_train):
         if X_train.shape[1] != 0:
             self.features = list(range(X_train.shape[1]))
         else:
-            raise ValueError("No data provided")
+            msg = "No data provided"
+            raise ValueError(msg)
 
         if self.features_names is None:
             # if no names provided, use numbers instead
             self.features_names = self.features
 
         if not set(self.quasi_identifiers).issubset(set(self.features_names)):
-            raise ValueError(
+            msg = (
                 "Quasi identifiers should bs a subset of the supplied features or indexes in range of "
                 "the data columns"
             )
+            raise ValueError(msg)
         if self.categorical_features and not set(self.categorical_features).issubset(set(self.features_names)):
-            raise ValueError(
+            msg = (
                 "Categorical features should bs a subset of the supplied features or indexes in range of "
                 "the data columns"
             )
+            raise ValueError(msg)
 
         # transform quasi identifiers to indexes
         self.quasi_identifiers = [i for i, v in enumerate(self.features_names) if v in self.quasi_identifiers]
@@ -133,10 +137,12 @@ def anonymize(self, X_train, y_train):
 
     def _anonymize(self, x, y):
         if x.shape[0] != y.shape[0]:
-            raise ValueError("x and y should have same number of rows")
+            msg = "x and y should have same number of rows"
+            raise ValueError(msg)
         if any(x.select_dtypes(include="category").columns):
             if not self.categorical_features:
-                raise ValueError("when supplying an array with non-numeric data, categorical_features must be defined")
+                msg = "when supplying an array with non-numeric data, categorical_features must be defined"
+                raise ValueError(msg)
             x_prepared = self._modify_categorical_features(x)
         else:
             x_prepared = x
@@ -252,5 +258,4 @@ def _modify_categorical_features(self, x):
                 ("cat", categorical_transformer, categorical_features),
             ]
         )
-        encoded = preprocessor.fit_transform(x)
-        return encoded
+        return preprocessor.fit_transform(x)
diff --git a/src/holisticai/utils/_commons.py b/src/holisticai/utils/_commons.py
index 2a90c4ce..f76f574e 100644
--- a/src/holisticai/utils/_commons.py
+++ b/src/holisticai/utils/_commons.py
@@ -30,7 +30,8 @@ def get_item(obj, key):
         return obj.loc[key]
     if isinstance(obj, np.ndarray):
         return obj[key]
-    raise ValueError(f"Type {type(obj)} not supported")
+    msg = f"Type {type(obj)} not supported"
+    raise ValueError(msg)
 
 
 def get_columns(obj):
@@ -38,4 +39,5 @@ def get_columns(obj):
         return obj.columns
     if isinstance(obj, np.ndarray):
         return [f"feature_{i}" for i in range(obj.shape[1])]
-    raise ValueError(f"Type {type(obj)} not supported")
+    msg = f"Type {type(obj)} not supported"
+    raise ValueError(msg)
diff --git a/src/holisticai/utils/_definitions.py b/src/holisticai/utils/_definitions.py
index 3f7599f2..b3d3fbdc 100644
--- a/src/holisticai/utils/_definitions.py
+++ b/src/holisticai/utils/_definitions.py
@@ -1,10 +1,9 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Callable, Literal, Optional, Union
+from typing import TYPE_CHECKING, Callable, Literal, Union
 
 import numpy as np
 import pandas as pd
-
 from holisticai.utils._commons import get_number_of_feature_above_threshold_importance
 from holisticai.utils._validation import _array_like_to_numpy
 from holisticai.utils.obj_rep.object_repr import ReprObj
@@ -19,8 +18,8 @@ class BinaryClassificationProxy(ReprObj):
     def __init__(
         self,
         predict: Callable,
-        predict_proba: Optional[Callable] = None,
-        classes: Union[list, None] = None,
+        predict_proba: Callable | None = None,
+        classes: list | None = None,
     ):
         if classes is None:
             classes = [0, 1]
@@ -100,15 +99,14 @@ def create_proxy(**kargs) -> ModelProxy:
         return RegressionProxy(**kargs)
     if task == "clustering":
         return ClusteringProxy(**kargs)
-    raise ValueError("Unknown learning task type")
+    msg = "Unknown learning task type"
+    raise ValueError(msg)
 
 
 class Importances(ReprObj):
     _theme = "blue"
 
-    def __init__(
-        self, values: ArrayLike, feature_names: list[str], extra_attrs: Union[dict, None] = None, normalize=True
-    ):
+    def __init__(self, values: ArrayLike, feature_names: list[str], extra_attrs: dict | None = None, normalize=True):
         if extra_attrs is None:
             extra_attrs = {}
         values_ = np.abs(_array_like_to_numpy(values))
@@ -125,7 +123,8 @@ def __getitem__(self, idx: int | str) -> float:
             return self.values[idx]
         if isinstance(idx, str):
             return self.values[self.feature_names.index(idx)]
-        raise ValueError(f"Invalid index type: {type(idx)}")
+        msg = f"Invalid index type: {type(idx)}"
+        raise ValueError(msg)
 
     def select(self, idx: list[int]):
         data = pd.DataFrame({"feature_names": self.feature_names, "values": self.values})
@@ -224,7 +223,8 @@ def conditional(self):
 
     def __add__(self, other):
         if not isinstance(other, LocalImportances):
-            raise TypeError("Both operands must be instances of LocalImportances")
+            msg = "Both operands must be instances of LocalImportances"
+            raise TypeError(msg)
 
         data = self.data.droplevel(0, axis=1)
         serie = data["condition"]
@@ -281,7 +281,7 @@ def __len__(self):
 
 
 class PartialDependence(ReprObj):
-    def __init__(self, values: list[list[dict]], feature_names: Optional[list[str]] = None):
+    def __init__(self, values: list[list[dict]], feature_names: list[str] | None = None):
         self.values = values
         if feature_names is None:
             feature_names = [f"Feature {i}" for i in range(len(values))]
diff --git a/src/holisticai/utils/_formatting.py b/src/holisticai/utils/_formatting.py
index d73ea45c..a4f37dad 100644
--- a/src/holisticai/utils/_formatting.py
+++ b/src/holisticai/utils/_formatting.py
@@ -1,6 +1,5 @@
 # Base Imports
 import numpy as np
-
 from holisticai.utils._validation import _array_like_to_numpy
 
 
diff --git a/src/holisticai/utils/_recommender_tools.py b/src/holisticai/utils/_recommender_tools.py
index 8bee75b2..de58cabe 100644
--- a/src/holisticai/utils/_recommender_tools.py
+++ b/src/holisticai/utils/_recommender_tools.py
@@ -1,11 +1,11 @@
 import numpy as np
 
-# scikit
-from sklearn.metrics import f1_score, precision_score, recall_score
-
 # Formatting
 from holisticai.utils import mat_to_binary
 
+# scikit
+from sklearn.metrics import f1_score, precision_score, recall_score
+
 
 def avg_precision(mat_pred, mat_true, top=None, thresh=0.5):
     """
diff --git a/src/holisticai/utils/_validation.py b/src/holisticai/utils/_validation.py
index 285f96d9..1bf61195 100644
--- a/src/holisticai/utils/_validation.py
+++ b/src/holisticai/utils/_validation.py
@@ -226,7 +226,8 @@ def _array_like_to_numpy(arr, name=""):
             return np.array([out])
         if len(out.shape) == 1:
             return out
-        raise ValueError(f"input is not 1d array-like.: {out}")
+        msg = f"input is not 1d array-like.: {out}"
+        raise ValueError(msg)
     except TypeError as e:
         msg = f"input {name} is not array-like. This includes numpy 1d arrays, lists,\
             pandas Series or pandas 1d DataFrame"
@@ -272,14 +273,16 @@ def _matrix_like_to_dataframe(arr, name=""):  # noqa: ARG001
             return pd.DataFrame(out, columns=columns)
         ValueError("input is not matrix-like.")
     except TypeError as e:
-        raise TypeError("input is not matrix-like.") from e
+        msg = "input is not matrix-like."
+        raise TypeError(msg) from e
 
 
 def _array_like_to_series(arr, name=""):  # noqa: ARG001
     num_dimensions = 1
 
     def raise_value_error():
-        raise ValueError("input is not array-like.")
+        msg = "input is not array-like."
+        raise ValueError(msg)
 
     try:
         out = np.squeeze(np.asarray(arr))
@@ -287,7 +290,8 @@ def raise_value_error():
             return pd.Series(out)
         raise_value_error()
     except TypeError as e:
-        raise TypeError("input is not array-like.") from e
+        msg = "input is not array-like."
+        raise TypeError(msg) from e
 
 
 def _coerce_and_check_arr(arr, name="input"):
@@ -607,7 +611,8 @@ def _check_numerical_dataframe(df: pd.DataFrame):
     try:
         return df.astype(float)
     except ValueError as e:
-        raise ValueError("DataFrame cannot be converted to numerical values") from e
+        msg = "DataFrame cannot be converted to numerical values"
+        raise ValueError(msg) from e
 
 
 def _check_columns(df: pd.DataFrame, column: str):
diff --git a/src/holisticai/utils/models/cluster/_kcenters.py b/src/holisticai/utils/models/cluster/_kcenters.py
index aa565ce4..cc14f056 100644
--- a/src/holisticai/utils/models/cluster/_kcenters.py
+++ b/src/holisticai/utils/models/cluster/_kcenters.py
@@ -1,13 +1,11 @@
 from __future__ import annotations
 
-from typing import Union
-
 from holisticai.utils.models.cluster._utils import distance
 from numpy.random import RandomState
 
 
 class KCenters:
-    def __init__(self, n_clusters=5, random_state: Union[RandomState, int] = 42):
+    def __init__(self, n_clusters=5, random_state: RandomState | int = 42):
         """
         k (int) : Number of centers to be identified
         """
diff --git a/src/holisticai/utils/models/cluster/_kmedoids.py b/src/holisticai/utils/models/cluster/_kmedoids.py
index ddfaab95..50dec952 100644
--- a/src/holisticai/utils/models/cluster/_kmedoids.py
+++ b/src/holisticai/utils/models/cluster/_kmedoids.py
@@ -88,7 +88,8 @@ def _check_nonnegative_int(self, value, desc, strict=True):
         """Validates if value is a valid integer > 0"""
         negative = value is None or value <= 0 if strict else value is None or value < 0
         if negative or not isinstance(value, (int, np.integer)):
-            raise ValueError(f"{desc} should be a nonnegative integer. " f"{value} was given")
+            msg = f"{desc} should be a nonnegative integer. " f"{value} was given"
+            raise ValueError(msg)
 
     def _check_init_args(self):
         """Validates the input arguments."""
@@ -289,7 +290,8 @@ def _initialize_medoids(self, D, n_clusters, random_state_):
             # to every other point. These are the initial medoids.
             medoids = np.argpartition(np.sum(D, axis=1), n_clusters - 1)[:n_clusters]
         else:
-            raise ValueError(f"init value '{self.init}' not recognized")
+            msg = f"init value '{self.init}' not recognized"
+            raise ValueError(msg)
 
         return medoids
 
diff --git a/src/holisticai/utils/models/neighbors/_classification.py b/src/holisticai/utils/models/neighbors/_classification.py
index be4a7052..787b4208 100644
--- a/src/holisticai/utils/models/neighbors/_classification.py
+++ b/src/holisticai/utils/models/neighbors/_classification.py
@@ -9,7 +9,8 @@
 class KNeighborsClassifier:
     def __init__(self):
         if jnp is None or vmap is None:
-            raise ImportError("jax or jax.nn is not installed. Please install it with `pip install jax jaxlib`.")
+            msg = "jax or jax.nn is not installed. Please install it with `pip install jax jaxlib`."
+            raise ImportError(msg)
 
     def fit(self, X_train, y_train):
         self.X_train = jnp.array(X_train)
@@ -57,5 +58,4 @@ def _predict_single(self, x):
 
     def predict(self, X):
         # Vectorize prediction for all input points
-        predictions = vmap(self._predict_single)(jnp.array(X))
-        return predictions
+        return vmap(self._predict_single)(jnp.array(X))
diff --git a/src/holisticai/utils/obj_rep/object_repr.py b/src/holisticai/utils/obj_rep/object_repr.py
index ccf751e7..48560a4f 100644
--- a/src/holisticai/utils/obj_rep/object_repr.py
+++ b/src/holisticai/utils/obj_rep/object_repr.py
@@ -109,12 +109,10 @@ def generate_html_for_generic_object(obj, feature_columns=5, theme="blue"):
         nested_objects_html += generate_html_for_generic_object(nested_obj, feature_columns, theme)
 
     header = f"[{obj_type}]" if name in ("N/A", "") else f"{name} [{obj_type}]"
-    html_output = html_template.format(
+    return html_template.format(
         header=header,
         attributes=attributes_html,
         nested_objects=nested_objects_html,
         css_template=css_template,
         theme=theme,
     )
-
-    return html_output
diff --git a/src/holisticai/utils/optimizers/_genetic_algorithm.py b/src/holisticai/utils/optimizers/_genetic_algorithm.py
index d7c73cf8..afa9642f 100644
--- a/src/holisticai/utils/optimizers/_genetic_algorithm.py
+++ b/src/holisticai/utils/optimizers/_genetic_algorithm.py
@@ -96,9 +96,11 @@ class containing GA algoirhtm hiperparameters
                 self.var_type = np.array([["int"]] * self.dim)
         else:
             if type(variable_type_mixed).__module__ != "numpy":
-                raise ValueError("variable_type must be numpy array")
+                msg = "variable_type must be numpy array"
+                raise ValueError(msg)
             if len(variable_type_mixed) != self.dim:
-                raise ValueError("variable_type must have a length equal to dimension.")
+                msg = "variable_type must have a length equal to dimension."
+                raise ValueError(msg)
 
             for i in variable_type_mixed:
                 assert i in ("real", "int"), (
@@ -112,10 +114,12 @@ class containing GA algoirhtm hiperparameters
         # input variables' boundaries
         if variable_type != "bool" or type(variable_type_mixed).__module__ == "numpy":
             if type(variable_boundaries).__module__ != "numpy":
-                raise ValueError("variable_boundaries must be numpy array")
+                msg = "variable_boundaries must be numpy array"
+                raise ValueError(msg)
 
             if len(variable_boundaries) != self.dim:
-                raise ValueError("variable_boundaries must have a length equal to dimension.")
+                msg = "variable_boundaries must have a length equal to dimension."
+                raise ValueError(msg)
 
             for i in variable_boundaries:
                 assert len(i) == 2, "\n boundary for each variable must be a tuple of length two."
@@ -130,7 +134,8 @@ class containing GA algoirhtm hiperparameters
         self.pop_s = int(self.param["population_size"])
 
         if not (0 <= self.param["parents_portion"] <= 1):
-            raise ValueError("parents_portion must be in range [0,1]")
+            msg = "parents_portion must be in range [0,1]"
+            raise ValueError(msg)
 
         self.par_s = int(self.param["parents_portion"] * self.pop_s)
         trl = self.pop_s - self.par_s
@@ -140,7 +145,8 @@ class containing GA algoirhtm hiperparameters
         self.prob_mut = self.param["mutation_probability"]
 
         if not (0 <= self.prob_mut <= 1):
-            raise ValueError("mutation_probability must be in range [0,1]")
+            msg = "mutation_probability must be in range [0,1]"
+            raise ValueError(msg)
 
         self.prob_cross = self.param["crossover_probability"]
         assert self.prob_cross <= 1, "mutation_probability must be less than or equal to 1"
diff --git a/src/holisticai/utils/plots/_plots.py b/src/holisticai/utils/plots/_plots.py
index 4f6c511b..c348ba3b 100644
--- a/src/holisticai/utils/plots/_plots.py
+++ b/src/holisticai/utils/plots/_plots.py
@@ -47,7 +47,8 @@ def _validate_and_extract_data(data):
     # Check if data is a pandas DataFrame
     if isinstance(data, pd.DataFrame):
         if data.shape[1] != 2:
-            raise ValueError("Data should have exactly two columns.")
+            msg = "Data should have exactly two columns."
+            raise ValueError(msg)
         data_vals = data.values  # Convert DataFrame to NumPy array
     # Check if data is a pandas Series
     elif isinstance(data, pd.Series):
@@ -57,7 +58,8 @@ def _validate_and_extract_data(data):
         data_vals = data
     # Raise error if the data is not a DataFrame or NumPy array
     else:
-        raise TypeError("Data must be either a pandas DataFrame or a NumPy array.")
+        msg = "Data must be either a pandas DataFrame or a NumPy array."
+        raise TypeError(msg)
 
     return data_vals
 
@@ -92,7 +94,8 @@ def plot_graph(X, y, test_indices=None):
     # If test_indices are provided, outline the selected points
     if test_indices is not None:
         if not isinstance(test_indices, (np.ndarray, list)):
-            raise TypeError("test_indices must be either a list or a NumPy array.")
+            msg = "test_indices must be either a list or a NumPy array."
+            raise TypeError(msg)
 
         plt.scatter(
             X_vals[test_indices, 0], X_vals[test_indices, 1], facecolors="none", edgecolors="red", linewidths=2, s=150
diff --git a/src/holisticai/utils/plots/_utils.py b/src/holisticai/utils/plots/_utils.py
index 79213bf4..930d0212 100644
--- a/src/holisticai/utils/plots/_utils.py
+++ b/src/holisticai/utils/plots/_utils.py
@@ -55,18 +55,22 @@ def prepare_to_plot(
 
     # Check if X is a DataFrame and y is a NumPy array
     if not isinstance(X, pd.DataFrame):
-        raise TypeError("X must be a pandas DataFrame.")
+        msg = "X must be a pandas DataFrame."
+        raise TypeError(msg)
     if not isinstance(y, np.ndarray):
-        raise TypeError("y must be a NumPy array.")
+        msg = "y must be a NumPy array."
+        raise TypeError(msg)
 
     # Check if all the features are present in X
     missing_features = [feature for feature in features_to_plot if feature not in X.columns]
     if missing_features:
-        raise KeyError(f"The following features are missing from X: {', '.join(missing_features)}")
+        msg = f"The following features are missing from X: {', '.join(missing_features)}"
+        raise KeyError(msg)
 
     # Check if the length of X and y match
     if len(X) != len(y):
-        raise ValueError("The length of X and y must match.")
+        msg = "The length of X and y must match."
+        raise ValueError(msg)
 
     # Select only the columns for the chosen features to plot
     X_selected = X[features_to_plot]
diff --git a/src/holisticai/utils/surrogate_models/__init__.py b/src/holisticai/utils/surrogate_models/__init__.py
index 52259d0b..a0cd1cbb 100644
--- a/src/holisticai/utils/surrogate_models/__init__.py
+++ b/src/holisticai/utils/surrogate_models/__init__.py
@@ -1,14 +1,13 @@
 from __future__ import annotations
 
-from typing import Literal, Optional, Union
+from typing import Literal, Union
 
 import numpy as np
-from numpy.random import RandomState
-
 from holisticai.utils.surrogate_models._trees import (
     DecisionTreeClassifier,
     DecisionTreeRegressor,
 )
+from numpy.random import RandomState
 
 Surrogate = Union[DecisionTreeClassifier, DecisionTreeRegressor]
 LearningTask = Literal["binary_classification", "multi_classification", "regression"]
@@ -22,16 +21,18 @@ def create_surrogate_model(X, y_pred, surrogate_type, learning_task="classificat
         elif len(np.unique(y_pred)) > 2:
             surrogate = MultiClassificationSurrogate(X, y_pred=y_pred, model_type=surrogate_type)
         else:
-            raise ValueError("y_pred must have at least two unique values")
+            msg = "y_pred must have at least two unique values"
+            raise ValueError(msg)
     elif learning_task == "regression":
         surrogate = RegressionSurrogate(X, y_pred=y_pred, model_type=surrogate_type)
     else:
-        raise ValueError(f"Learning task {learning_task} not supported")
+        msg = f"Learning task {learning_task} not supported"
+        raise ValueError(msg)
     return surrogate
 
 
 class BinaryClassificationSurrogate:
-    def __new__(cls, X, y_pred, model_type: SurrogateType = "shallow_tree", random_state: Optional[RandomState] = None):
+    def __new__(cls, X, y_pred, model_type: SurrogateType = "shallow_tree", random_state: RandomState | None = None):
         if random_state is None:
             random_state = RandomState(42)
 
@@ -40,11 +41,12 @@ def __new__(cls, X, y_pred, model_type: SurrogateType = "shallow_tree", random_s
                 learning_task="binary_classification", model_type=model_type, random_state=random_state
             )
             return surrogate.fit(X=X, y=y_pred)
-        raise ValueError(f"Surrogate type {model_type} not supported")
+        msg = f"Surrogate type {model_type} not supported"
+        raise ValueError(msg)
 
 
 class MultiClassificationSurrogate:
-    def __new__(cls, X, y_pred, model_type: SurrogateType = "shallow_tree", random_state: Optional[RandomState] = None):
+    def __new__(cls, X, y_pred, model_type: SurrogateType = "shallow_tree", random_state: RandomState | None = None):
         if random_state is None:
             random_state = RandomState(42)
 
@@ -53,11 +55,12 @@ def __new__(cls, X, y_pred, model_type: SurrogateType = "shallow_tree", random_s
                 learning_task="multi_classification", model_type=model_type, random_state=random_state
             )
             return surrogate.fit(X=X, y=y_pred)
-        raise ValueError(f"Surrogate type {model_type} not supported")
+        msg = f"Surrogate type {model_type} not supported"
+        raise ValueError(msg)
 
 
 class RegressionSurrogate:
-    def __new__(cls, X, y_pred, model_type: SurrogateType = "shallow_tree", random_state: Optional[RandomState] = None):
+    def __new__(cls, X, y_pred, model_type: SurrogateType = "shallow_tree", random_state: RandomState | None = None):
         if random_state is None:
             random_state = RandomState(42)
         if model_type in ["shallow_tree", "tree"]:
@@ -65,11 +68,12 @@ def __new__(cls, X, y_pred, model_type: SurrogateType = "shallow_tree", random_s
                 learning_task="regression", model_type=model_type, random_state=random_state
             )
             return surrogate.fit(X=X, y=y_pred)
-        raise ValueError(f"Surrogate type {model_type} not supported")
+        msg = f"Surrogate type {model_type} not supported"
+        raise ValueError(msg)
 
 
 class ClusteringSurrogate:
-    def __new__(cls, X, y_pred, model_type: SurrogateType = "shallow_tree", random_state: Optional[RandomState] = None):
+    def __new__(cls, X, y_pred, model_type: SurrogateType = "shallow_tree", random_state: RandomState | None = None):
         if random_state is None:
             random_state = RandomState(42)
 
@@ -78,7 +82,8 @@ def __new__(cls, X, y_pred, model_type: SurrogateType = "shallow_tree", random_s
                 learning_task="clustering", model_type=model_type, random_state=random_state
             )
             return surrogate.fit(X=X, y=y_pred)
-        raise ValueError(f"Surrogate type {model_type} not supported")
+        msg = f"Surrogate type {model_type} not supported"
+        raise ValueError(msg)
 
 
 def get_features(surrogate):
@@ -88,7 +93,8 @@ def get_features(surrogate):
     if isinstance(surrogate, (DecisionTreeClassifier, DecisionTreeRegressor)):
         assert surrogate.__is_fitted__, "Model not fitted"
         return surrogate._surrogate.tree_.feature  # noqa: SLF001
-    raise ValueError(f"Surrogate type {type(surrogate)} not supported")
+    msg = f"Surrogate type {type(surrogate)} not supported"
+    raise ValueError(msg)
 
 
 def get_number_of_rules(surrogate):
@@ -98,4 +104,5 @@ def get_number_of_rules(surrogate):
     if isinstance(surrogate, (DecisionTreeClassifier, DecisionTreeRegressor)):
         assert surrogate.__is_fitted__, "Model not fitted"
         return surrogate._surrogate.get_n_leaves()  # noqa: SLF001
-    raise ValueError(f"Surrogate type {type(surrogate)} not supported")
+    msg = f"Surrogate type {type(surrogate)} not supported"
+    raise ValueError(msg)
diff --git a/src/holisticai/utils/surrogate_models/_trees.py b/src/holisticai/utils/surrogate_models/_trees.py
index adc9b68b..07e11bdc 100644
--- a/src/holisticai/utils/surrogate_models/_trees.py
+++ b/src/holisticai/utils/surrogate_models/_trees.py
@@ -1,14 +1,15 @@
 from __future__ import annotations
 
-from typing import Literal, Optional
+from typing import TYPE_CHECKING, Literal
 
 import numpy as np
 import pandas as pd
-from numpy.random import RandomState
-from sklearn.metrics import accuracy_score, mean_squared_error
-
 from holisticai.utils.obj_rep.object_repr import ReprObj
 from holisticai.utils.surrogate_models._base import SurrogateBase
+from sklearn.metrics import accuracy_score, mean_squared_error
+
+if TYPE_CHECKING:
+    from numpy.random import RandomState
 
 
 def validate_input(X, y=None):
@@ -72,7 +73,7 @@ def __init__(
         self,
         learning_task: Literal["binary_classification", "multi_classification", "clustering"],
         model_type: Literal["shallow_tree", "tree"] = "shallow_tree",
-        random_state: Optional[RandomState] = None,
+        random_state: RandomState | None = None,
     ):
         self.random_state = random_state
         self.model_type = model_type
@@ -89,7 +90,8 @@ def build(self, X, y):
         elif self.model_type == "tree":
             rf = RandomForestClassifier(n_estimators=100, random_state=self.random_state)
         else:
-            raise ValueError(f"Model type {self.model_type} not supported")
+            msg = f"Model type {self.model_type} not supported"
+            raise ValueError(msg)
         rf.fit(X, y)
         best_score = -np.inf
         for tree in rf.estimators_:
@@ -123,7 +125,7 @@ def __init__(
         self,
         learning_task: Literal["regression"],
         model_type: Literal["shallow_tree", "tree"] = "shallow_tree",
-        random_state: Optional[RandomState] = None,
+        random_state: RandomState | None = None,
     ):
         self.model_type = model_type
         self.random_state = random_state
@@ -140,7 +142,8 @@ def build(self, X, y):
         elif self.model_type == "tree":
             rf = RandomForestRegressor(n_estimators=100, random_state=self.random_state)
         else:
-            raise ValueError(f"Model type {self.model_type} not supported")
+            msg = f"Model type {self.model_type} not supported"
+            raise ValueError(msg)
         rf.fit(X, y)
         best_score = np.inf
         for tree in rf.estimators_:
diff --git a/src/holisticai/utils/transformers/bias/_inprocessing.py b/src/holisticai/utils/transformers/bias/_inprocessing.py
index 42cb99f3..a44fac36 100644
--- a/src/holisticai/utils/transformers/bias/_inprocessing.py
+++ b/src/holisticai/utils/transformers/bias/_inprocessing.py
@@ -1,7 +1,6 @@
 import inspect
 
 import numpy as np
-
 from holisticai.utils.obj_rep.object_repr import BMReprObj
 from holisticai.utils.transformers._transformer_base import BMTransformerBase
 
diff --git a/src/holisticai/utils/transformers/bias/_postprocessing.py b/src/holisticai/utils/transformers/bias/_postprocessing.py
index 38a9f9e2..fdcefb77 100644
--- a/src/holisticai/utils/transformers/bias/_postprocessing.py
+++ b/src/holisticai/utils/transformers/bias/_postprocessing.py
@@ -2,7 +2,6 @@
 
 import numpy as np
 import pandas as pd
-
 from holisticai.utils._validation import _check_valid_y_proba
 from holisticai.utils.obj_rep.object_repr import BMReprObj
 from holisticai.utils.transformers._transformer_base import BMTransformerBase
diff --git a/src/holisticai/utils/transformers/bias/_preprocessing.py b/src/holisticai/utils/transformers/bias/_preprocessing.py
index 78b97e76..0fc496dd 100644
--- a/src/holisticai/utils/transformers/bias/_preprocessing.py
+++ b/src/holisticai/utils/transformers/bias/_preprocessing.py
@@ -1,7 +1,6 @@
 import inspect
 
 import numpy as np
-
 from holisticai.utils.obj_rep.object_repr import BMReprObj
 from holisticai.utils.transformers._transformer_base import BMTransformerBase
 

From 7ff7e707946ae2e7fbb0bf701a95385474b4c35e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cristian=20Mu=C3=B1oz?= <cristian.munoz@holisticai.com>
Date: Mon, 3 Mar 2025 17:22:22 -0300
Subject: [PATCH 19/34] Update publish-testpypi-workflow.yml

---
 .github/workflows/publish-testpypi-workflow.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/publish-testpypi-workflow.yml b/.github/workflows/publish-testpypi-workflow.yml
index b7665295..1979e3f5 100644
--- a/.github/workflows/publish-testpypi-workflow.yml
+++ b/.github/workflows/publish-testpypi-workflow.yml
@@ -1,4 +1,4 @@
-name: Publish PyPI
+name: Publish TestPyPI
 
 on:
   workflow_dispatch:

From f96892b77bff35c7cd6dd09cea573149ad664dab Mon Sep 17 00:00:00 2001
From: "github-actions[bot]" <github-actions[bot]@users.noreply.github.com>
Date: Mon, 3 Mar 2025 20:23:44 +0000
Subject: [PATCH 20/34] Update version and changelog

---
 src/holisticai/__about__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/holisticai/__about__.py b/src/holisticai/__about__.py
index bd538f76..66c607f6 100644
--- a/src/holisticai/__about__.py
+++ b/src/holisticai/__about__.py
@@ -1 +1 @@
-__version__ = "1.0.12"
+__version__ = "1.0.13"

From ff2b35bc6664e076278d0d2c6fe4ee6b74f0e261 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cristian=20Mu=C3=B1oz?= <cristian.munoz@holisticai.com>
Date: Mon, 3 Mar 2025 17:28:25 -0300
Subject: [PATCH 21/34] Update publish-testpypi-workflow.yml

---
 .github/workflows/publish-testpypi-workflow.yml | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/publish-testpypi-workflow.yml b/.github/workflows/publish-testpypi-workflow.yml
index 1979e3f5..ecbc1b51 100644
--- a/.github/workflows/publish-testpypi-workflow.yml
+++ b/.github/workflows/publish-testpypi-workflow.yml
@@ -38,10 +38,12 @@ jobs:
           echo "Latest release version: $latest_tag"
           echo "tag=$latest_tag" >> $GITHUB_ENV # Save the tag to an environment variable
 
-      - name: Publish to PyPI
+      - name: Publish to TestPyPI
         env:
           HATCH_INDEX_USER: __token__
-          HATCH_INDEX_AUTH: ${{ secrets.PYPI_TOKEN }}
+          HATCH_INDEX_AUTH: ${{ secrets.TEST_PYPI_API_TOKEN }}
         run: |
           hatch build
           hatch publish --repo test
+
+      

From fbe9e3af2a4090e159a9e113831f82c0cf4be3e5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cristian=20Mu=C3=B1oz?= <cristian.munoz@holisticai.com>
Date: Mon, 3 Mar 2025 17:34:11 -0300
Subject: [PATCH 22/34] Update pyproject.toml

---
 pyproject.toml | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/pyproject.toml b/pyproject.toml
index 96d21f12..907bcddd 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -141,3 +141,9 @@ packages = [
   "src/holisticai/typing",
   "src/holisticai/utils"
 ]
+
+[tool.hatch.indexes]
+testpypi = "https://test.pypi.org/legacy/"
+
+[tool.hatch.publish]
+default = "testpypi"

From bc37961f25770cd5482a59cde77cbc41e5a6b247 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cristian=20Mu=C3=B1oz?= <cristian.munoz@holisticai.com>
Date: Mon, 3 Mar 2025 17:34:31 -0300
Subject: [PATCH 23/34] Update publish-testpypi-workflow.yml

---
 .github/workflows/publish-testpypi-workflow.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/publish-testpypi-workflow.yml b/.github/workflows/publish-testpypi-workflow.yml
index ecbc1b51..ee444ba2 100644
--- a/.github/workflows/publish-testpypi-workflow.yml
+++ b/.github/workflows/publish-testpypi-workflow.yml
@@ -44,6 +44,6 @@ jobs:
           HATCH_INDEX_AUTH: ${{ secrets.TEST_PYPI_API_TOKEN }}
         run: |
           hatch build
-          hatch publish --repo test
+          hatch publish --repo testpypi
 
       

From 36c4399b0dce49a9de3ecbd6ac4d64b543f680cf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cristian=20Mu=C3=B1oz?= <cristian.munoz@holisticai.com>
Date: Mon, 3 Mar 2025 17:39:05 -0300
Subject: [PATCH 24/34] Update publish-testpypi-workflow.yml

---
 .../workflows/publish-testpypi-workflow.yml    | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/publish-testpypi-workflow.yml b/.github/workflows/publish-testpypi-workflow.yml
index ee444ba2..25fc658d 100644
--- a/.github/workflows/publish-testpypi-workflow.yml
+++ b/.github/workflows/publish-testpypi-workflow.yml
@@ -38,12 +38,18 @@ jobs:
           echo "Latest release version: $latest_tag"
           echo "tag=$latest_tag" >> $GITHUB_ENV # Save the tag to an environment variable
 
+      - name: Create .pypirc file
+        run: |
+          echo "[distutils]" > ~/.pypirc
+          echo "index-servers =" >> ~/.pypirc
+          echo "    testpypi" >> ~/.pypirc
+          echo "" >> ~/.pypirc
+          echo "[test]" >> ~/.pypirc
+          echo "repository = https://test.pypi.org/legacy/" >> ~/.pypirc
+          echo "username = __token__" >> ~/.pypirc
+          echo "password = ${{ secrets.TEST_PYPI_API_TOKEN }}" >> ~/.pypirc
+
       - name: Publish to TestPyPI
-        env:
-          HATCH_INDEX_USER: __token__
-          HATCH_INDEX_AUTH: ${{ secrets.TEST_PYPI_API_TOKEN }}
         run: |
           hatch build
-          hatch publish --repo testpypi
-
-      
+          hatch publish --repo test

From c94c18ac1225d2ec36a87761794f37041f2754c8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cristian=20Mu=C3=B1oz?= <cristian.munoz@holisticai.com>
Date: Mon, 3 Mar 2025 17:39:28 -0300
Subject: [PATCH 25/34] Update pyproject.toml

---
 pyproject.toml | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index 907bcddd..f281c618 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -142,8 +142,3 @@ packages = [
   "src/holisticai/utils"
 ]
 
-[tool.hatch.indexes]
-testpypi = "https://test.pypi.org/legacy/"
-
-[tool.hatch.publish]
-default = "testpypi"

From 5612d648ad157d30dfca98f25821a7e59511f1b8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cristian=20Mu=C3=B1oz?= <cristian.munoz@holisticai.com>
Date: Mon, 3 Mar 2025 17:41:59 -0300
Subject: [PATCH 26/34] Update publish-testpypi-workflow.yml

---
 .github/workflows/publish-testpypi-workflow.yml | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/publish-testpypi-workflow.yml b/.github/workflows/publish-testpypi-workflow.yml
index 25fc658d..ae25af14 100644
--- a/.github/workflows/publish-testpypi-workflow.yml
+++ b/.github/workflows/publish-testpypi-workflow.yml
@@ -40,14 +40,11 @@ jobs:
 
       - name: Create .pypirc file
         run: |
-          echo "[distutils]" > ~/.pypirc
-          echo "index-servers =" >> ~/.pypirc
-          echo "    testpypi" >> ~/.pypirc
-          echo "" >> ~/.pypirc
-          echo "[test]" >> ~/.pypirc
+          echo "[test]" > ~/.pypirc
           echo "repository = https://test.pypi.org/legacy/" >> ~/.pypirc
           echo "username = __token__" >> ~/.pypirc
           echo "password = ${{ secrets.TEST_PYPI_API_TOKEN }}" >> ~/.pypirc
+          chmod 600 ~/.pypirc
 
       - name: Publish to TestPyPI
         run: |

From a1546ee2cbfc584a8e224824be4ca0acda7e8ce5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cristian=20Mu=C3=B1oz?= <cristian.munoz@holisticai.com>
Date: Mon, 3 Mar 2025 17:54:24 -0300
Subject: [PATCH 27/34] Delete .github/workflows/publish-testpypi-workflow.yml

---
 .../workflows/publish-testpypi-workflow.yml   | 52 -------------------
 1 file changed, 52 deletions(-)
 delete mode 100644 .github/workflows/publish-testpypi-workflow.yml

diff --git a/.github/workflows/publish-testpypi-workflow.yml b/.github/workflows/publish-testpypi-workflow.yml
deleted file mode 100644
index ae25af14..00000000
--- a/.github/workflows/publish-testpypi-workflow.yml
+++ /dev/null
@@ -1,52 +0,0 @@
-name: Publish TestPyPI
-
-on:
-  workflow_dispatch:
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/create-github-app-token@v1
-        id: app-token
-        with:
-          app-id: ${{ secrets.APPLICATION_ID }}
-          private-key: ${{ secrets.APPLICATION_PRIVATE_KEY }}
-
-      - name: Checkout code
-        uses: actions/checkout@v4.2.2
-        with:
-          fetch-tags: true
-          fetch-depth: 0
-          ref: main
-          token: ${{ steps.app-token.outputs.token }} # Needed to trigger other actions
-
-      - name: Set up Python
-        uses: actions/setup-python@v5.3.0
-        with:
-          python-version: "3.9"
-
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install hatch
-
-      - name: Get Latest Release Version
-        id: get_release
-        run: |
-          latest_tag=$(git describe --tags `git rev-list --tags --max-count=1`)
-          echo "Latest release version: $latest_tag"
-          echo "tag=$latest_tag" >> $GITHUB_ENV # Save the tag to an environment variable
-
-      - name: Create .pypirc file
-        run: |
-          echo "[test]" > ~/.pypirc
-          echo "repository = https://test.pypi.org/legacy/" >> ~/.pypirc
-          echo "username = __token__" >> ~/.pypirc
-          echo "password = ${{ secrets.TEST_PYPI_API_TOKEN }}" >> ~/.pypirc
-          chmod 600 ~/.pypirc
-
-      - name: Publish to TestPyPI
-        run: |
-          hatch build
-          hatch publish --repo test

From fb8007618a8b739f6c554a0378f6b1d81e1f447b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cristian=20Mu=C3=B1oz?= <cristian.munoz@holisticai.com>
Date: Mon, 3 Mar 2025 18:26:00 -0300
Subject: [PATCH 28/34] Create __init__.py

---
 src/holisticai/__init__.py | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 src/holisticai/__init__.py

diff --git a/src/holisticai/__init__.py b/src/holisticai/__init__.py
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/src/holisticai/__init__.py
@@ -0,0 +1 @@
+

From 5180a9ba0e7c374e7ae246f3d4e88b6dbc0f9519 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cristian=20Mu=C3=B1oz?= <cristian.munoz@holisticai.com>
Date: Mon, 3 Mar 2025 18:26:36 -0300
Subject: [PATCH 29/34] Update pyproject.toml

---
 pyproject.toml | 10 +---------
 1 file changed, 1 insertion(+), 9 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index f281c618..fcc1ed2b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -131,14 +131,6 @@ env-vars = { PYTHONPATH = "src" }
 
 [tool.hatch.build.targets.wheel]
 packages = [
-  "src/holisticai/bias",
-  "src/holisticai/explainability",
-  "src/holisticai/robustness",
-  "src/holisticai/efficacy",
-  "src/holisticai/inspection",
-  "src/holisticai/pipeline",
-  "src/holisticai/security",
-  "src/holisticai/typing",
-  "src/holisticai/utils"
+  "src/holisticai",
 ]
 

From 979fcdfbfb97ec6f409adc8c09c2435b6674aad6 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]" <github-actions[bot]@users.noreply.github.com>
Date: Mon, 3 Mar 2025 21:27:36 +0000
Subject: [PATCH 30/34] Update version and changelog

---
 src/holisticai/__about__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/holisticai/__about__.py b/src/holisticai/__about__.py
index 66c607f6..b19b12ea 100644
--- a/src/holisticai/__about__.py
+++ b/src/holisticai/__about__.py
@@ -1 +1 @@
-__version__ = "1.0.13"
+__version__ = "1.0.14"

From 96b084f7d44ba81d7cd379ecf229334dcf48ba12 Mon Sep 17 00:00:00 2001
From: Franklin Cardenoso Fernandez
 <44931423+fracarfer5@users.noreply.github.com>
Date: Sat, 3 May 2025 07:24:28 -0300
Subject: [PATCH 31/34] chore: fixing lint and formatting (#304)

---
 src/holisticai/bias/metrics/_classification.py           | 8 ++++----
 src/holisticai/bias/metrics/_clustering.py               | 5 +++--
 src/holisticai/bias/metrics/_recommender.py              | 6 +++---
 .../inprocessing/adversarial_debiasing/transformer.py    | 1 +
 .../mitigation/inprocessing/commons/_moments_utils.py    | 1 +
 .../inprocessing/commons/classification/_constraints.py  | 1 +
 .../inprocessing/commons/classification/_objectives.py   | 1 +
 .../inprocessing/commons/regression/_constraints.py      | 1 +
 .../inprocessing/exponentiated_gradient/_lagrangian.py   | 3 ++-
 .../inprocessing/exponentiated_gradient/algorithm.py     | 3 ++-
 .../inprocessing/exponentiated_gradient/transformer.py   | 3 ++-
 .../inprocessing/fair_k_center_clustering/transformer.py | 5 +++--
 .../inprocessing/fair_k_mediam_clustering/transformer.py | 3 ++-
 .../inprocessing/fair_scoring_classifier/algorithm.py    | 1 +
 .../inprocessing/fair_scoring_classifier/transformer.py  | 3 ++-
 .../inprocessing/fairlet_clustering/transformer.py       | 3 ++-
 .../mitigation/inprocessing/grid_search/algorithm.py     | 3 ++-
 .../mitigation/inprocessing/grid_search/transformer.py   | 3 ++-
 .../matrix_factorization/blind_spot_aware.py             | 1 +
 .../common_utils/propensity_utils.py                     | 1 +
 .../matrix_factorization/debiasing_learning/algorithm.py | 1 +
 .../debiasing_learning/transformer.py                    | 1 +
 .../matrix_factorization/popularity_propensity.py        | 1 +
 .../inprocessing/meta_fair_classifier/algorithm.py       | 3 ++-
 .../inprocessing/meta_fair_classifier/algorithm_utils.py | 1 +
 .../inprocessing/meta_fair_classifier/transformer.py     | 1 +
 .../inprocessing/prejudice_remover/algorithm.py          | 3 ++-
 .../inprocessing/prejudice_remover/algorithm_utils.py    | 1 +
 .../inprocessing/prejudice_remover/transformer.py        | 3 ++-
 .../inprocessing/two_sided_fairness/transformer.py       | 1 +
 .../variational_fair_clustering/algorithm.py             | 1 +
 .../algorithm_utils/_fair_clustering.py                  | 3 ++-
 .../algorithm_utils/_methods.py                          | 3 ++-
 .../variational_fair_clustering/transformer.py           | 3 ++-
 .../postprocessing/calibrated_eq_odds_postprocessing.py  | 1 +
 .../postprocessing/debiasing_exposure/algorithm.py       | 1 +
 .../postprocessing/debiasing_exposure/transformer.py     | 1 +
 .../mitigation/postprocessing/eq_odds_postprocessing.py  | 3 ++-
 .../fair_topk/algorithm_utils/fail_prob.py               | 3 ++-
 .../mitigation/postprocessing/fair_topk/transformer.py   | 1 +
 .../postprocessing/mcmf_clustering/algorithm.py          | 3 ++-
 .../postprocessing/mcmf_clustering/utils/algorithm.py    | 1 +
 .../ml_debiaser/randomized_threshold/algorithm.py        | 1 +
 .../ml_debiaser/randomized_threshold/algorithm_utils.py  | 1 +
 .../ml_debiaser/reduce2binary/algorithm.py               | 1 +
 .../mitigation/postprocessing/ml_debiaser/transformer.py | 1 +
 .../plugin_estimator_and_recalibration/algorithm.py      | 1 +
 .../plugin_estimator_and_recalibration/transformer.py    | 1 +
 .../postprocessing/reject_option_classification.py       | 5 +++--
 .../postprocessing/wasserstein_barycenters/algorithm.py  | 1 +
 .../wasserstein_barycenters/transformer.py               | 1 +
 .../bias/mitigation/preprocessing/correlation_remover.py | 3 ++-
 .../mitigation/preprocessing/disparate_impact_remover.py | 1 +
 .../preprocessing/fairlet_clustering/transformer.py      | 5 +++--
 .../preprocessing/learning_fair_representation.py        | 3 ++-
 .../bias/mitigation/preprocessing/reweighing.py          | 1 +
 src/holisticai/bias/plots/_bias_classification_plots.py  | 6 +++---
 src/holisticai/bias/plots/_bias_exploratory_plots.py     | 1 +
 src/holisticai/bias/plots/_bias_exploratory_view.py      | 3 ++-
 src/holisticai/bias/plots/_bias_multiclass_plots.py      | 2 +-
 src/holisticai/bias/plots/_bias_recommender_plots.py     | 2 +-
 src/holisticai/bias/plots/_bias_regression_plots.py      | 8 ++++----
 src/holisticai/bias/plots/_classification.py             | 8 ++++----
 src/holisticai/bias/plots/_multiclass.py                 | 2 +-
 src/holisticai/bias/plots/_recommender.py                | 2 +-
 src/holisticai/bias/plots/_regression.py                 | 8 ++++----
 src/holisticai/datasets/_dataset.py                      | 3 ++-
 src/holisticai/datasets/_load_dataset.py                 | 1 +
 src/holisticai/datasets/plots/_exploratory.py            | 1 +
 src/holisticai/explainability/metrics/_classification.py | 1 +
 src/holisticai/explainability/metrics/_multiclass.py     | 1 +
 src/holisticai/explainability/metrics/_regression.py     | 1 +
 src/holisticai/explainability/metrics/_tree.py           | 1 +
 .../metrics/global_feature_importance/__init__.py        | 1 +
 .../global_feature_importance/_importance_spread.py      | 3 ++-
 .../metrics/local_feature_importance/__init__.py         | 1 +
 .../explainability/metrics/surrogate/_classification.py  | 3 ++-
 .../explainability/metrics/surrogate/_clustering.py      | 3 ++-
 .../explainability/metrics/surrogate/_regression.py      | 1 +
 .../explainability/metrics/surrogate/_stability.py       | 3 ++-
 src/holisticai/explainability/metrics/tree/_tree.py      | 1 +
 .../explainability/plots/_feature_importance.py          | 9 +++++----
 .../explainability/plots/_partial_dependence.py          | 5 +++--
 .../explainability/plots/_partial_dependencies.py        | 5 +++--
 src/holisticai/explainability/plots/_tree.py             | 3 ++-
 src/holisticai/inspection/_lime.py                       | 3 ++-
 src/holisticai/inspection/_partial_dependence.py         | 5 +++--
 src/holisticai/inspection/_permutation_importance.py     | 5 +++--
 src/holisticai/inspection/_shap.py                       | 3 ++-
 src/holisticai/inspection/_surrogate_importance.py       | 5 +++--
 src/holisticai/pipeline/_pipeline.py                     | 5 +++--
 src/holisticai/pipeline/_pipeline_helper.py              | 3 ++-
 .../robustness/attackers/classification/hop_skip_jump.py | 1 +
 .../classification/zeroth_order_optimization.py          | 3 ++-
 .../robustness/attackers/regression/gb_attackers.py      | 3 ++-
 .../robustness/attackers/regression/gb_base.py           | 5 +++--
 .../security/commons/data_minimization/_core.py          | 1 +
 .../security/commons/data_minimization/_selectors.py     | 4 +++-
 src/holisticai/security/metrics/__init__.py              | 1 +
 src/holisticai/security/metrics/_attribute_attack.py     | 5 +++--
 src/holisticai/security/metrics/_shapr.py                | 3 ++-
 src/holisticai/utils/_definitions.py                     | 1 +
 src/holisticai/utils/_formatting.py                      | 1 +
 src/holisticai/utils/_recommender_tools.py               | 6 +++---
 src/holisticai/utils/surrogate_models/__init__.py        | 3 ++-
 src/holisticai/utils/surrogate_models/_trees.py          | 3 ++-
 src/holisticai/utils/transformers/bias/_inprocessing.py  | 1 +
 .../utils/transformers/bias/_postprocessing.py           | 1 +
 src/holisticai/utils/transformers/bias/_preprocessing.py | 1 +
 109 files changed, 191 insertions(+), 92 deletions(-)

diff --git a/src/holisticai/bias/metrics/_classification.py b/src/holisticai/bias/metrics/_classification.py
index e79728c2..1329ca47 100644
--- a/src/holisticai/bias/metrics/_classification.py
+++ b/src/holisticai/bias/metrics/_classification.py
@@ -4,6 +4,10 @@
 import numpy as np
 import pandas as pd
 
+# Efficacy metrics
+from sklearn.metrics import accuracy_score, confusion_matrix, roc_auc_score
+from sklearn.neighbors import NearestNeighbors
+
 # utils
 from holisticai.utils._validation import (
     _array_like_to_numpy,
@@ -13,10 +17,6 @@
     _regression_checks,
 )
 
-# Efficacy metrics
-from sklearn.metrics import accuracy_score, confusion_matrix, roc_auc_score
-from sklearn.neighbors import NearestNeighbors
-
 
 def _group_success_rate(g, y):
     """Group success rate.
diff --git a/src/holisticai/bias/metrics/_clustering.py b/src/holisticai/bias/metrics/_clustering.py
index 9fa84d1f..c492a3ac 100644
--- a/src/holisticai/bias/metrics/_clustering.py
+++ b/src/holisticai/bias/metrics/_clustering.py
@@ -1,7 +1,5 @@
 import numpy as np
 import pandas as pd
-from holisticai.utils._recommender_tools import entropy
-from holisticai.utils._validation import _clustering_checks
 
 # sklearn imports
 from sklearn.metrics import (
@@ -10,6 +8,9 @@
     silhouette_samples,
 )
 
+from holisticai.utils._recommender_tools import entropy
+from holisticai.utils._validation import _clustering_checks
+
 
 def cluster_balance(group_a, group_b, y_pred):
     """Cluster Balance
diff --git a/src/holisticai/bias/metrics/_recommender.py b/src/holisticai/bias/metrics/_recommender.py
index f9d10a78..bbc268d8 100644
--- a/src/holisticai/bias/metrics/_recommender.py
+++ b/src/holisticai/bias/metrics/_recommender.py
@@ -2,6 +2,9 @@
 import numpy as np
 import pandas as pd
 
+# sklearn imports
+from sklearn.metrics import mean_absolute_error
+
 # utils
 from holisticai.utils import mat_to_binary, normalize_tensor
 
@@ -16,9 +19,6 @@
 )
 from holisticai.utils._validation import _recommender_checks
 
-# sklearn imports
-from sklearn.metrics import mean_absolute_error
-
 
 def aggregate_diversity(mat_pred, top=None, thresh=0.5, normalize=False):
     r"""Aggregate Diversity
diff --git a/src/holisticai/bias/mitigation/inprocessing/adversarial_debiasing/transformer.py b/src/holisticai/bias/mitigation/inprocessing/adversarial_debiasing/transformer.py
index 12c145b1..eb854888 100644
--- a/src/holisticai/bias/mitigation/inprocessing/adversarial_debiasing/transformer.py
+++ b/src/holisticai/bias/mitigation/inprocessing/adversarial_debiasing/transformer.py
@@ -6,6 +6,7 @@
 import jax.numpy as jnp
 import numpy as np
 import pandas as pd
+
 from holisticai.bias.mitigation.inprocessing.adversarial_debiasing.models import (
     ADModel,
     AdversarialModel,
diff --git a/src/holisticai/bias/mitigation/inprocessing/commons/_moments_utils.py b/src/holisticai/bias/mitigation/inprocessing/commons/_moments_utils.py
index 20bfdcb7..cbcfd8b5 100644
--- a/src/holisticai/bias/mitigation/inprocessing/commons/_moments_utils.py
+++ b/src/holisticai/bias/mitigation/inprocessing/commons/_moments_utils.py
@@ -2,6 +2,7 @@
 
 import numpy as np
 import pandas as pd
+
 from holisticai.bias.mitigation.inprocessing.commons._conventions import _EVENT, _GROUP_ID, _LABEL, _SIGNED
 
 
diff --git a/src/holisticai/bias/mitigation/inprocessing/commons/classification/_constraints.py b/src/holisticai/bias/mitigation/inprocessing/commons/classification/_constraints.py
index 4e1e47c8..5586103a 100644
--- a/src/holisticai/bias/mitigation/inprocessing/commons/classification/_constraints.py
+++ b/src/holisticai/bias/mitigation/inprocessing/commons/classification/_constraints.py
@@ -2,6 +2,7 @@
 
 import numpy as np
 import pandas as pd
+
 from holisticai.bias.mitigation.inprocessing.commons._conventions import (
     _ALL,
     _EVENT,
diff --git a/src/holisticai/bias/mitigation/inprocessing/commons/classification/_objectives.py b/src/holisticai/bias/mitigation/inprocessing/commons/classification/_objectives.py
index 213402ab..f6d2107f 100644
--- a/src/holisticai/bias/mitigation/inprocessing/commons/classification/_objectives.py
+++ b/src/holisticai/bias/mitigation/inprocessing/commons/classification/_objectives.py
@@ -1,5 +1,6 @@
 import numpy as np
 import pandas as pd
+
 from holisticai.bias.mitigation.inprocessing.commons._conventions import _ALL, _LABEL
 from holisticai.bias.mitigation.inprocessing.commons._moments_utils import BaseMoment
 
diff --git a/src/holisticai/bias/mitigation/inprocessing/commons/regression/_constraints.py b/src/holisticai/bias/mitigation/inprocessing/commons/regression/_constraints.py
index 887b7078..7fd26e8d 100644
--- a/src/holisticai/bias/mitigation/inprocessing/commons/regression/_constraints.py
+++ b/src/holisticai/bias/mitigation/inprocessing/commons/regression/_constraints.py
@@ -1,5 +1,6 @@
 import numpy as np
 import pandas as pd
+
 from holisticai.bias.mitigation.inprocessing.commons._conventions import (
     _ALL,
     _EVENT,
diff --git a/src/holisticai/bias/mitigation/inprocessing/exponentiated_gradient/_lagrangian.py b/src/holisticai/bias/mitigation/inprocessing/exponentiated_gradient/_lagrangian.py
index 8d6a622a..f1083132 100644
--- a/src/holisticai/bias/mitigation/inprocessing/exponentiated_gradient/_lagrangian.py
+++ b/src/holisticai/bias/mitigation/inprocessing/exponentiated_gradient/_lagrangian.py
@@ -1,9 +1,10 @@
 import numpy as np
 import pandas as pd
 import scipy.optimize as opt
-from holisticai.bias.mitigation.inprocessing.commons._conventions import PRECISION
 from sklearn import clone
 
+from holisticai.bias.mitigation.inprocessing.commons._conventions import PRECISION
+
 
 class Lagrangian:
     """Operations related to the Lagrangian"""
diff --git a/src/holisticai/bias/mitigation/inprocessing/exponentiated_gradient/algorithm.py b/src/holisticai/bias/mitigation/inprocessing/exponentiated_gradient/algorithm.py
index c84e8cee..0db12d44 100644
--- a/src/holisticai/bias/mitigation/inprocessing/exponentiated_gradient/algorithm.py
+++ b/src/holisticai/bias/mitigation/inprocessing/exponentiated_gradient/algorithm.py
@@ -4,6 +4,8 @@
 
 import numpy as np
 import pandas as pd
+from sklearn.utils import check_random_state
+
 from holisticai.bias.mitigation.inprocessing.commons._conventions import (
     ACCURACY_MUL,
     MIN_ITER,
@@ -14,7 +16,6 @@
     SHRINK_REGRET,
 )
 from holisticai.bias.mitigation.inprocessing.exponentiated_gradient._lagrangian import Lagrangian
-from sklearn.utils import check_random_state
 
 
 class ExponentiatedGradientAlgorithm:
diff --git a/src/holisticai/bias/mitigation/inprocessing/exponentiated_gradient/transformer.py b/src/holisticai/bias/mitigation/inprocessing/exponentiated_gradient/transformer.py
index 92552ce4..f4402d15 100644
--- a/src/holisticai/bias/mitigation/inprocessing/exponentiated_gradient/transformer.py
+++ b/src/holisticai/bias/mitigation/inprocessing/exponentiated_gradient/transformer.py
@@ -3,12 +3,13 @@
 from typing import Literal
 
 import numpy as np
+from sklearn.base import BaseEstimator, ClassifierMixin, clone
+
 from holisticai.bias.mitigation.inprocessing.commons.classification import _constraints as cc
 from holisticai.bias.mitigation.inprocessing.commons.regression import _constraints as rc
 from holisticai.bias.mitigation.inprocessing.commons.regression import _losses as rl
 from holisticai.bias.mitigation.inprocessing.exponentiated_gradient.algorithm import ExponentiatedGradientAlgorithm
 from holisticai.utils.transformers.bias import BMInprocessing as BMImp
-from sklearn.base import BaseEstimator, ClassifierMixin, clone
 
 
 class ExponentiatedGradientReduction(BaseEstimator, ClassifierMixin, BMImp):
diff --git a/src/holisticai/bias/mitigation/inprocessing/fair_k_center_clustering/transformer.py b/src/holisticai/bias/mitigation/inprocessing/fair_k_center_clustering/transformer.py
index 42cf9211..4244ae82 100644
--- a/src/holisticai/bias/mitigation/inprocessing/fair_k_center_clustering/transformer.py
+++ b/src/holisticai/bias/mitigation/inprocessing/fair_k_center_clustering/transformer.py
@@ -1,6 +1,9 @@
 from __future__ import annotations
 
 import numpy as np
+from sklearn.base import BaseEstimator
+from sklearn.metrics.pairwise import pairwise_distances, pairwise_distances_argmin
+
 from holisticai.bias.mitigation.inprocessing.fair_k_center_clustering.algorithms import (
     fair_k_center_approx,
     heuristic_greedy_on_each_group,
@@ -8,8 +11,6 @@
 )
 from holisticai.utils.transformers.bias import BMInprocessing as BMImp
 from holisticai.utils.transformers.bias import SensitiveGroups
-from sklearn.base import BaseEstimator
-from sklearn.metrics.pairwise import pairwise_distances, pairwise_distances_argmin
 
 STRATEGIES_CATALOG = {
     "Fair K-Center": fair_k_center_approx,
diff --git a/src/holisticai/bias/mitigation/inprocessing/fair_k_mediam_clustering/transformer.py b/src/holisticai/bias/mitigation/inprocessing/fair_k_mediam_clustering/transformer.py
index e00fb906..26cdfbd5 100644
--- a/src/holisticai/bias/mitigation/inprocessing/fair_k_mediam_clustering/transformer.py
+++ b/src/holisticai/bias/mitigation/inprocessing/fair_k_mediam_clustering/transformer.py
@@ -1,10 +1,11 @@
 from __future__ import annotations
 
 import numpy as np
+from sklearn.base import BaseEstimator
+
 from holisticai.bias.mitigation.inprocessing.fair_k_mediam_clustering.algorithm import KMediamClusteringAlgorithm
 from holisticai.utils.transformers.bias import BMInprocessing as BMImp
 from holisticai.utils.transformers.bias import SensitiveGroups
-from sklearn.base import BaseEstimator
 
 
 class FairKMedianClustering(BaseEstimator, BMImp):
diff --git a/src/holisticai/bias/mitigation/inprocessing/fair_scoring_classifier/algorithm.py b/src/holisticai/bias/mitigation/inprocessing/fair_scoring_classifier/algorithm.py
index 371624f7..e70a9ca9 100644
--- a/src/holisticai/bias/mitigation/inprocessing/fair_scoring_classifier/algorithm.py
+++ b/src/holisticai/bias/mitigation/inprocessing/fair_scoring_classifier/algorithm.py
@@ -3,6 +3,7 @@
 import logging
 
 import numpy as np
+
 from holisticai.bias.mitigation.inprocessing.fair_scoring_classifier.utils import get_class_count, get_class_indexes
 
 logger = logging.getLogger(__name__)
diff --git a/src/holisticai/bias/mitigation/inprocessing/fair_scoring_classifier/transformer.py b/src/holisticai/bias/mitigation/inprocessing/fair_scoring_classifier/transformer.py
index cccf18c7..48b95886 100644
--- a/src/holisticai/bias/mitigation/inprocessing/fair_scoring_classifier/transformer.py
+++ b/src/holisticai/bias/mitigation/inprocessing/fair_scoring_classifier/transformer.py
@@ -4,10 +4,11 @@
 
 import numpy as np
 import pandas as pd
+from sklearn.base import BaseEstimator
+
 from holisticai.bias.mitigation.inprocessing.fair_scoring_classifier.algorithm import FairScoreClassifierAlgorithm
 from holisticai.utils.transformers.bias import BMInprocessing as BMImp
 from holisticai.utils.transformers.bias import SensitiveGroups
-from sklearn.base import BaseEstimator
 
 
 class FairScoreClassifier(BaseEstimator, BMImp):
diff --git a/src/holisticai/bias/mitigation/inprocessing/fairlet_clustering/transformer.py b/src/holisticai/bias/mitigation/inprocessing/fairlet_clustering/transformer.py
index 76385b8a..989df16e 100644
--- a/src/holisticai/bias/mitigation/inprocessing/fairlet_clustering/transformer.py
+++ b/src/holisticai/bias/mitigation/inprocessing/fairlet_clustering/transformer.py
@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import numpy as np
+from sklearn.base import BaseEstimator
+
 from holisticai.bias.mitigation.commons.fairlet_clustering.decompositions import (
     DecompositionMixin,
     ScalableFairletDecomposition,
@@ -11,7 +13,6 @@
 )
 from holisticai.utils.models.cluster import KCenters, KMedoids
 from holisticai.utils.transformers.bias import BMInprocessing as BMImp
-from sklearn.base import BaseEstimator
 
 DECOMPOSITION_CATALOG = {
     "Scalable": ScalableFairletDecomposition,
diff --git a/src/holisticai/bias/mitigation/inprocessing/grid_search/algorithm.py b/src/holisticai/bias/mitigation/inprocessing/grid_search/algorithm.py
index ca755c9c..d34e1ada 100644
--- a/src/holisticai/bias/mitigation/inprocessing/grid_search/algorithm.py
+++ b/src/holisticai/bias/mitigation/inprocessing/grid_search/algorithm.py
@@ -2,9 +2,10 @@
 import logging
 from typing import Any
 
-from holisticai.bias.mitigation.inprocessing.grid_search._grid_generator import GridGenerator
 from joblib import Parallel, delayed
 
+from holisticai.bias.mitigation.inprocessing.grid_search._grid_generator import GridGenerator
+
 logger = logging.getLogger(__name__)
 
 
diff --git a/src/holisticai/bias/mitigation/inprocessing/grid_search/transformer.py b/src/holisticai/bias/mitigation/inprocessing/grid_search/transformer.py
index f3331ddc..5036ed30 100644
--- a/src/holisticai/bias/mitigation/inprocessing/grid_search/transformer.py
+++ b/src/holisticai/bias/mitigation/inprocessing/grid_search/transformer.py
@@ -3,12 +3,13 @@
 from typing import Literal
 
 import numpy as np
+from sklearn.base import BaseEstimator, clone
+
 from holisticai.bias.mitigation.inprocessing.commons.classification import _constraints as cc
 from holisticai.bias.mitigation.inprocessing.commons.regression import _constraints as rc
 from holisticai.bias.mitigation.inprocessing.commons.regression import _losses as rl
 from holisticai.bias.mitigation.inprocessing.grid_search.algorithm import GridSearchAlgorithm
 from holisticai.utils.transformers.bias import BMInprocessing as BMImp
-from sklearn.base import BaseEstimator, clone
 
 
 class GridSearchReduction(BMImp, BaseEstimator):
diff --git a/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/blind_spot_aware.py b/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/blind_spot_aware.py
index 2324b3f8..ad042bf9 100644
--- a/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/blind_spot_aware.py
+++ b/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/blind_spot_aware.py
@@ -3,6 +3,7 @@
 import logging
 
 import numpy as np
+
 from holisticai.utils.models.recommender._rsbase import RecommenderSystemBase
 from holisticai.utils.transformers.bias import BMInprocessing as BMImp
 
diff --git a/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/common_utils/propensity_utils.py b/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/common_utils/propensity_utils.py
index c5fecbc9..e02453b1 100644
--- a/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/common_utils/propensity_utils.py
+++ b/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/common_utils/propensity_utils.py
@@ -1,4 +1,5 @@
 import numpy as np
+
 from holisticai.bias.mitigation.inprocessing.matrix_factorization.common_utils.utils import calculate_popularity_model
 
 
diff --git a/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/debiasing_learning/algorithm.py b/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/debiasing_learning/algorithm.py
index 0a94b378..b34d81c2 100644
--- a/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/debiasing_learning/algorithm.py
+++ b/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/debiasing_learning/algorithm.py
@@ -1,5 +1,6 @@
 import numpy as np
 import scipy
+
 from holisticai.bias.mitigation.inprocessing.matrix_factorization.debiasing_learning.algorithm_utils import (
     ParameterSerializer,
     Problem,
diff --git a/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/debiasing_learning/transformer.py b/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/debiasing_learning/transformer.py
index eafaeddb..2d6bc5f0 100644
--- a/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/debiasing_learning/transformer.py
+++ b/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/debiasing_learning/transformer.py
@@ -2,6 +2,7 @@
 
 import numpy as np
 import scipy
+
 from holisticai.bias.mitigation.inprocessing.matrix_factorization.debiasing_learning.algorithm import (
     DebiasingLearningAlgorithm,
 )
diff --git a/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/popularity_propensity.py b/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/popularity_propensity.py
index b3bfb72a..fa037485 100644
--- a/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/popularity_propensity.py
+++ b/src/holisticai/bias/mitigation/inprocessing/matrix_factorization/popularity_propensity.py
@@ -3,6 +3,7 @@
 import logging
 
 import numpy as np
+
 from holisticai.bias.mitigation.inprocessing.matrix_factorization.common_utils.propensity_utils import (
     popularity_model_propensity,
 )
diff --git a/src/holisticai/bias/mitigation/inprocessing/meta_fair_classifier/algorithm.py b/src/holisticai/bias/mitigation/inprocessing/meta_fair_classifier/algorithm.py
index bbd7c84c..97e12ad3 100644
--- a/src/holisticai/bias/mitigation/inprocessing/meta_fair_classifier/algorithm.py
+++ b/src/holisticai/bias/mitigation/inprocessing/meta_fair_classifier/algorithm.py
@@ -1,10 +1,11 @@
 from functools import partial
 
 import numpy as np
-from holisticai.utils.transformers.bias import SensitiveGroups
 from scipy.stats import multivariate_normal
 from sklearn.metrics import accuracy_score
 
+from holisticai.utils.transformers.bias import SensitiveGroups
+
 
 def prob(dist, x):
     return dist.pdf(x)
diff --git a/src/holisticai/bias/mitigation/inprocessing/meta_fair_classifier/algorithm_utils.py b/src/holisticai/bias/mitigation/inprocessing/meta_fair_classifier/algorithm_utils.py
index 551f4174..ae6a54cd 100644
--- a/src/holisticai/bias/mitigation/inprocessing/meta_fair_classifier/algorithm_utils.py
+++ b/src/holisticai/bias/mitigation/inprocessing/meta_fair_classifier/algorithm_utils.py
@@ -1,4 +1,5 @@
 import numpy as np
+
 from holisticai.bias.mitigation.inprocessing.commons import Logging
 
 
diff --git a/src/holisticai/bias/mitigation/inprocessing/meta_fair_classifier/transformer.py b/src/holisticai/bias/mitigation/inprocessing/meta_fair_classifier/transformer.py
index eea79d7c..36f5b845 100644
--- a/src/holisticai/bias/mitigation/inprocessing/meta_fair_classifier/transformer.py
+++ b/src/holisticai/bias/mitigation/inprocessing/meta_fair_classifier/transformer.py
@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import numpy as np
+
 from holisticai.bias.mitigation.inprocessing.meta_fair_classifier.algorithm import MetaFairClassifierAlgorithm
 from holisticai.bias.mitigation.inprocessing.meta_fair_classifier.algorithm_utils import MFLogger
 from holisticai.bias.mitigation.inprocessing.meta_fair_classifier.constraints import FalseDiscovery, StatisticalRate
diff --git a/src/holisticai/bias/mitigation/inprocessing/prejudice_remover/algorithm.py b/src/holisticai/bias/mitigation/inprocessing/prejudice_remover/algorithm.py
index cef4b23b..ae8df42e 100644
--- a/src/holisticai/bias/mitigation/inprocessing/prejudice_remover/algorithm.py
+++ b/src/holisticai/bias/mitigation/inprocessing/prejudice_remover/algorithm.py
@@ -1,7 +1,8 @@
 import numpy as np
-from holisticai.utils.transformers.bias import SensitiveGroups
 from scipy.optimize import fmin_cg
 
+from holisticai.utils.transformers.bias import SensitiveGroups
+
 
 class PrejudiceRemoverAlgorithm:
     """Two class LogisticRegression with Prejudice Remover"""
diff --git a/src/holisticai/bias/mitigation/inprocessing/prejudice_remover/algorithm_utils.py b/src/holisticai/bias/mitigation/inprocessing/prejudice_remover/algorithm_utils.py
index 54799d14..2a829b61 100644
--- a/src/holisticai/bias/mitigation/inprocessing/prejudice_remover/algorithm_utils.py
+++ b/src/holisticai/bias/mitigation/inprocessing/prejudice_remover/algorithm_utils.py
@@ -1,4 +1,5 @@
 import numpy as np
+
 from holisticai.bias.mitigation.inprocessing.commons import Logging
 
 
diff --git a/src/holisticai/bias/mitigation/inprocessing/prejudice_remover/transformer.py b/src/holisticai/bias/mitigation/inprocessing/prejudice_remover/transformer.py
index b71e5be0..1ea0f55a 100644
--- a/src/holisticai/bias/mitigation/inprocessing/prejudice_remover/transformer.py
+++ b/src/holisticai/bias/mitigation/inprocessing/prejudice_remover/transformer.py
@@ -1,12 +1,13 @@
 from __future__ import annotations
 
 import numpy as np
+from sklearn.base import BaseEstimator, ClassifierMixin
+
 from holisticai.bias.mitigation.inprocessing.prejudice_remover.algorithm import PrejudiceRemoverAlgorithm
 from holisticai.bias.mitigation.inprocessing.prejudice_remover.algorithm_utils import ObjectiveFunction, PRLogger
 from holisticai.bias.mitigation.inprocessing.prejudice_remover.losses import PRBinaryCrossEntropy
 from holisticai.bias.mitigation.inprocessing.prejudice_remover.model import PRLogiticRegression, PRParamInitializer
 from holisticai.utils.transformers.bias import BMInprocessing as BMImp
-from sklearn.base import BaseEstimator, ClassifierMixin
 
 
 class PrejudiceRemover(BaseEstimator, ClassifierMixin, BMImp):
diff --git a/src/holisticai/bias/mitigation/inprocessing/two_sided_fairness/transformer.py b/src/holisticai/bias/mitigation/inprocessing/two_sided_fairness/transformer.py
index fa1a66eb..149a30e3 100644
--- a/src/holisticai/bias/mitigation/inprocessing/two_sided_fairness/transformer.py
+++ b/src/holisticai/bias/mitigation/inprocessing/two_sided_fairness/transformer.py
@@ -2,6 +2,7 @@
 
 import numpy as np
 import pandas as pd
+
 from holisticai.bias.mitigation.inprocessing.two_sided_fairness.algorithm import FairRecAlg
 from holisticai.utils.transformers.bias import BMInprocessing as BMImp
 
diff --git a/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm.py b/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm.py
index aafdcb4c..e042dee4 100644
--- a/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm.py
+++ b/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm.py
@@ -2,6 +2,7 @@
 
 import numpy as np
 import pandas as pd
+
 from holisticai.bias.mitigation.inprocessing.variational_fair_clustering.algorithm_utils._fair_clustering import (
     FairClustering,
 )
diff --git a/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm_utils/_fair_clustering.py b/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm_utils/_fair_clustering.py
index 0363cc2f..767a1918 100644
--- a/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm_utils/_fair_clustering.py
+++ b/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm_utils/_fair_clustering.py
@@ -3,6 +3,8 @@
 from collections import defaultdict
 
 import numpy as np
+from sklearn.cluster import KMeans
+
 from holisticai.bias.mitigation.inprocessing.variational_fair_clustering.algorithm_utils._bound_update import (
     BoundUpdate,
     normalize_2,
@@ -22,7 +24,6 @@
 from holisticai.bias.mitigation.inprocessing.variational_fair_clustering.algorithm_utils._utils import (
     get_fair_accuracy_proportional,
 )
-from sklearn.cluster import KMeans
 
 logger = logging.getLogger()
 
diff --git a/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm_utils/_methods.py b/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm_utils/_methods.py
index ed7f5cf2..5c615a52 100644
--- a/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm_utils/_methods.py
+++ b/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/algorithm_utils/_methods.py
@@ -1,4 +1,6 @@
 import numpy as np
+from sklearn.metrics import pairwise_distances_chunked as pdist_chunk
+
 from holisticai.bias.mitigation.inprocessing.variational_fair_clustering.algorithm_utils._bound_update import (
     get_S_discrete,
 )
@@ -12,7 +14,6 @@
     reduce_func,
 )
 from holisticai.bias.mitigation.inprocessing.variational_fair_clustering.algorithm_utils._utils import create_affinity
-from sklearn.metrics import pairwise_distances_chunked as pdist_chunk
 
 
 class KUtils:
diff --git a/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/transformer.py b/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/transformer.py
index 3235f7a4..d5a09a8e 100644
--- a/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/transformer.py
+++ b/src/holisticai/bias/mitigation/inprocessing/variational_fair_clustering/transformer.py
@@ -1,10 +1,11 @@
 from __future__ import annotations
 
 import numpy as np
+from sklearn.base import BaseEstimator
+
 from holisticai.bias.mitigation.inprocessing.variational_fair_clustering.algorithm import FairClusteringAlgorithm
 from holisticai.utils.transformers.bias import BMInprocessing as BMImp
 from holisticai.utils.transformers.bias import SensitiveGroups
-from sklearn.base import BaseEstimator
 
 
 class VariationalFairClustering(BaseEstimator, BMImp):
diff --git a/src/holisticai/bias/mitigation/postprocessing/calibrated_eq_odds_postprocessing.py b/src/holisticai/bias/mitigation/postprocessing/calibrated_eq_odds_postprocessing.py
index 0c9fa290..104bc63b 100644
--- a/src/holisticai/bias/mitigation/postprocessing/calibrated_eq_odds_postprocessing.py
+++ b/src/holisticai/bias/mitigation/postprocessing/calibrated_eq_odds_postprocessing.py
@@ -3,6 +3,7 @@
 from typing import Literal
 
 import numpy as np
+
 from holisticai.utils.transformers.bias import BMPostprocessing as BMPost
 
 
diff --git a/src/holisticai/bias/mitigation/postprocessing/debiasing_exposure/algorithm.py b/src/holisticai/bias/mitigation/postprocessing/debiasing_exposure/algorithm.py
index d87a652a..9caf870b 100644
--- a/src/holisticai/bias/mitigation/postprocessing/debiasing_exposure/algorithm.py
+++ b/src/holisticai/bias/mitigation/postprocessing/debiasing_exposure/algorithm.py
@@ -1,6 +1,7 @@
 import logging
 
 import numpy as np
+
 from holisticai.bias.mitigation.postprocessing.debiasing_exposure.algorithm_utils import (
     exposure_diff,
     find_items_per_group_per_query,
diff --git a/src/holisticai/bias/mitigation/postprocessing/debiasing_exposure/transformer.py b/src/holisticai/bias/mitigation/postprocessing/debiasing_exposure/transformer.py
index fbb35c15..87bb394b 100644
--- a/src/holisticai/bias/mitigation/postprocessing/debiasing_exposure/transformer.py
+++ b/src/holisticai/bias/mitigation/postprocessing/debiasing_exposure/transformer.py
@@ -1,5 +1,6 @@
 import numpy as np
 import pandas as pd
+
 from holisticai.bias.mitigation.postprocessing.debiasing_exposure.algorithm import DELTRAlgorithm
 from holisticai.bias.mitigation.postprocessing.debiasing_exposure.algorithm_utils import Standarizer
 
diff --git a/src/holisticai/bias/mitigation/postprocessing/eq_odds_postprocessing.py b/src/holisticai/bias/mitigation/postprocessing/eq_odds_postprocessing.py
index dbee5068..2c563495 100644
--- a/src/holisticai/bias/mitigation/postprocessing/eq_odds_postprocessing.py
+++ b/src/holisticai/bias/mitigation/postprocessing/eq_odds_postprocessing.py
@@ -3,10 +3,11 @@
 from typing import Literal
 
 import numpy as np
-from holisticai.utils.transformers.bias import BMPostprocessing as BMPost
 from scipy.optimize import linprog
 from sklearn.metrics import confusion_matrix
 
+from holisticai.utils.transformers.bias import BMPostprocessing as BMPost
+
 
 class EqualizedOdds(BMPost):
     """
diff --git a/src/holisticai/bias/mitigation/postprocessing/fair_topk/algorithm_utils/fail_prob.py b/src/holisticai/bias/mitigation/postprocessing/fair_topk/algorithm_utils/fail_prob.py
index ec4402ac..9e4b1708 100644
--- a/src/holisticai/bias/mitigation/postprocessing/fair_topk/algorithm_utils/fail_prob.py
+++ b/src/holisticai/bias/mitigation/postprocessing/fair_topk/algorithm_utils/fail_prob.py
@@ -1,6 +1,7 @@
-from holisticai.bias.mitigation.postprocessing.fair_topk.algorithm_utils import mtable_generator
 from scipy.stats import binom
 
+from holisticai.bias.mitigation.postprocessing.fair_topk.algorithm_utils import mtable_generator
+
 EPS = 0.0000000000000001
 
 
diff --git a/src/holisticai/bias/mitigation/postprocessing/fair_topk/transformer.py b/src/holisticai/bias/mitigation/postprocessing/fair_topk/transformer.py
index 9c0d0dd6..ac188a0b 100644
--- a/src/holisticai/bias/mitigation/postprocessing/fair_topk/transformer.py
+++ b/src/holisticai/bias/mitigation/postprocessing/fair_topk/transformer.py
@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import pandas as pd
+
 from holisticai.bias.mitigation.postprocessing.fair_topk.algorithm_utils.fail_prob import (
     RecursiveNumericFailProbabilityCalculator,
 )
diff --git a/src/holisticai/bias/mitigation/postprocessing/mcmf_clustering/algorithm.py b/src/holisticai/bias/mitigation/postprocessing/mcmf_clustering/algorithm.py
index aa4cbd81..be24cf34 100644
--- a/src/holisticai/bias/mitigation/postprocessing/mcmf_clustering/algorithm.py
+++ b/src/holisticai/bias/mitigation/postprocessing/mcmf_clustering/algorithm.py
@@ -1,10 +1,11 @@
 import logging
 
 import numpy as np
-from holisticai.utils.transformers.bias import SensitiveGroups
 from scipy.optimize import linprog
 from scipy.sparse import lil_matrix
 
+from holisticai.utils.transformers.bias import SensitiveGroups
+
 logger = logging.getLogger(__name__)
 
 
diff --git a/src/holisticai/bias/mitigation/postprocessing/mcmf_clustering/utils/algorithm.py b/src/holisticai/bias/mitigation/postprocessing/mcmf_clustering/utils/algorithm.py
index fe8a53b5..ffb3ed2c 100644
--- a/src/holisticai/bias/mitigation/postprocessing/mcmf_clustering/utils/algorithm.py
+++ b/src/holisticai/bias/mitigation/postprocessing/mcmf_clustering/utils/algorithm.py
@@ -1,4 +1,5 @@
 import numpy as np
+
 from holisticai.bias.mitigation.postprocessing.mcmf_clustering.utils.algorithm_utils import Utils
 
 
diff --git a/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/randomized_threshold/algorithm.py b/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/randomized_threshold/algorithm.py
index 88680ff2..683a274b 100644
--- a/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/randomized_threshold/algorithm.py
+++ b/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/randomized_threshold/algorithm.py
@@ -1,4 +1,5 @@
 import numpy as np
+
 from holisticai.bias.mitigation.postprocessing.ml_debiaser.randomized_threshold.algorithm_utils import (
     FullGDDebiaser,
     RTLogger,
diff --git a/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/randomized_threshold/algorithm_utils.py b/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/randomized_threshold/algorithm_utils.py
index 6429ad24..75f6238b 100644
--- a/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/randomized_threshold/algorithm_utils.py
+++ b/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/randomized_threshold/algorithm_utils.py
@@ -1,6 +1,7 @@
 import math
 
 import numpy as np
+
 from holisticai.bias.mitigation.inprocessing.commons import Logging
 
 
diff --git a/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/reduce2binary/algorithm.py b/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/reduce2binary/algorithm.py
index ffe4ff0a..b6b03bdd 100644
--- a/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/reduce2binary/algorithm.py
+++ b/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/reduce2binary/algorithm.py
@@ -1,6 +1,7 @@
 import copy
 
 import numpy as np
+
 from holisticai.bias.mitigation.postprocessing.ml_debiaser.randomized_threshold.algorithm import (
     RandomizedThresholdAlgorithm,
 )
diff --git a/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/transformer.py b/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/transformer.py
index 8541d442..d0f079ab 100644
--- a/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/transformer.py
+++ b/src/holisticai/bias/mitigation/postprocessing/ml_debiaser/transformer.py
@@ -1,4 +1,5 @@
 import numpy as np
+
 from holisticai.bias.mitigation.postprocessing.ml_debiaser.randomized_threshold.algorithm import (
     RandomizedThresholdAlgorithm,
 )
diff --git a/src/holisticai/bias/mitigation/postprocessing/plugin_estimator_and_recalibration/algorithm.py b/src/holisticai/bias/mitigation/postprocessing/plugin_estimator_and_recalibration/algorithm.py
index 391a6b6d..432918a6 100644
--- a/src/holisticai/bias/mitigation/postprocessing/plugin_estimator_and_recalibration/algorithm.py
+++ b/src/holisticai/bias/mitigation/postprocessing/plugin_estimator_and_recalibration/algorithm.py
@@ -1,4 +1,5 @@
 import numpy as np
+
 from holisticai.bias.mitigation.postprocessing.plugin_estimator_and_recalibration.algorithm_utils import f_lambda
 from holisticai.utils.transformers.bias import SensitiveGroups
 
diff --git a/src/holisticai/bias/mitigation/postprocessing/plugin_estimator_and_recalibration/transformer.py b/src/holisticai/bias/mitigation/postprocessing/plugin_estimator_and_recalibration/transformer.py
index c1c98e31..33155b45 100644
--- a/src/holisticai/bias/mitigation/postprocessing/plugin_estimator_and_recalibration/transformer.py
+++ b/src/holisticai/bias/mitigation/postprocessing/plugin_estimator_and_recalibration/transformer.py
@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import numpy as np
+
 from holisticai.bias.mitigation.postprocessing.plugin_estimator_and_recalibration.algorithm import (
     PluginEstimationAndCalibrationAlgorithm,
 )
diff --git a/src/holisticai/bias/mitigation/postprocessing/reject_option_classification.py b/src/holisticai/bias/mitigation/postprocessing/reject_option_classification.py
index cbc72999..67458efb 100644
--- a/src/holisticai/bias/mitigation/postprocessing/reject_option_classification.py
+++ b/src/holisticai/bias/mitigation/postprocessing/reject_option_classification.py
@@ -4,11 +4,12 @@
 import sys
 from typing import Literal
 
-import holisticai.bias.metrics as bias_metrics
 import numpy as np
-from holisticai.utils.transformers.bias import BMPostprocessing as BMPost
 from sklearn.metrics import balanced_accuracy_score
 
+import holisticai.bias.metrics as bias_metrics
+from holisticai.utils.transformers.bias import BMPostprocessing as BMPost
+
 
 def statistical_parity(group_a, group_b, y_pred, _):
     return bias_metrics.statistical_parity(group_a, group_b, y_pred)
diff --git a/src/holisticai/bias/mitigation/postprocessing/wasserstein_barycenters/algorithm.py b/src/holisticai/bias/mitigation/postprocessing/wasserstein_barycenters/algorithm.py
index f8c3e0b6..3a2b3756 100644
--- a/src/holisticai/bias/mitigation/postprocessing/wasserstein_barycenters/algorithm.py
+++ b/src/holisticai/bias/mitigation/postprocessing/wasserstein_barycenters/algorithm.py
@@ -1,4 +1,5 @@
 import numpy as np
+
 from holisticai.utils.transformers.bias import SensitiveGroups
 
 
diff --git a/src/holisticai/bias/mitigation/postprocessing/wasserstein_barycenters/transformer.py b/src/holisticai/bias/mitigation/postprocessing/wasserstein_barycenters/transformer.py
index 574084ba..fd6e1c9f 100644
--- a/src/holisticai/bias/mitigation/postprocessing/wasserstein_barycenters/transformer.py
+++ b/src/holisticai/bias/mitigation/postprocessing/wasserstein_barycenters/transformer.py
@@ -1,4 +1,5 @@
 import numpy as np
+
 from holisticai.bias.mitigation.postprocessing.wasserstein_barycenters.algorithm import WassersteinBarycenterAlgorithm
 from holisticai.utils.transformers.bias import BMPostprocessing as BMPost
 
diff --git a/src/holisticai/bias/mitigation/preprocessing/correlation_remover.py b/src/holisticai/bias/mitigation/preprocessing/correlation_remover.py
index cc8489a5..7f2ad03f 100644
--- a/src/holisticai/bias/mitigation/preprocessing/correlation_remover.py
+++ b/src/holisticai/bias/mitigation/preprocessing/correlation_remover.py
@@ -1,7 +1,8 @@
 import jax.numpy as jnp
-from holisticai.utils.transformers.bias import BMPreprocessing as BMPre
 from jax import jit
 
+from holisticai.utils.transformers.bias import BMPreprocessing as BMPre
+
 
 @jit
 def _fit(X, sensitive_features, sensitive_mean):
diff --git a/src/holisticai/bias/mitigation/preprocessing/disparate_impact_remover.py b/src/holisticai/bias/mitigation/preprocessing/disparate_impact_remover.py
index 5ce3fa1c..65b662ce 100644
--- a/src/holisticai/bias/mitigation/preprocessing/disparate_impact_remover.py
+++ b/src/holisticai/bias/mitigation/preprocessing/disparate_impact_remover.py
@@ -1,4 +1,5 @@
 import numpy as np
+
 from holisticai.bias.mitigation.commons.disparate_impact_remover._numerical_repairer import (
     NumericalRepairer,
 )
diff --git a/src/holisticai/bias/mitigation/preprocessing/fairlet_clustering/transformer.py b/src/holisticai/bias/mitigation/preprocessing/fairlet_clustering/transformer.py
index ad00d898..387ac482 100644
--- a/src/holisticai/bias/mitigation/preprocessing/fairlet_clustering/transformer.py
+++ b/src/holisticai/bias/mitigation/preprocessing/fairlet_clustering/transformer.py
@@ -1,6 +1,9 @@
 from __future__ import annotations
 
 import numpy as np
+from sklearn.base import BaseEstimator
+from sklearn.metrics.pairwise import pairwise_distances_argmin
+
 from holisticai.bias.mitigation.commons.fairlet_clustering.decompositions import (
     DecompositionMixin,
     ScalableFairletDecomposition,
@@ -8,8 +11,6 @@
 )
 from holisticai.utils.models.cluster import KCenters, KMedoids
 from holisticai.utils.transformers.bias import BMPreprocessing as BMPre
-from sklearn.base import BaseEstimator
-from sklearn.metrics.pairwise import pairwise_distances_argmin
 
 DECOMPOSITION_CATALOG = {
     "Scalable": ScalableFairletDecomposition,
diff --git a/src/holisticai/bias/mitigation/preprocessing/learning_fair_representation.py b/src/holisticai/bias/mitigation/preprocessing/learning_fair_representation.py
index 5038e178..0a89253c 100644
--- a/src/holisticai/bias/mitigation/preprocessing/learning_fair_representation.py
+++ b/src/holisticai/bias/mitigation/preprocessing/learning_fair_representation.py
@@ -5,10 +5,11 @@
 import jax
 import jax.numpy as jnp
 import numpy as np
-from holisticai.utils.transformers.bias import BMPreprocessing
 from jax.nn import softmax
 from scipy.optimize import minimize
 
+from holisticai.utils.transformers.bias import BMPreprocessing
+
 logger = logging.getLogger(__name__)
 
 
diff --git a/src/holisticai/bias/mitigation/preprocessing/reweighing.py b/src/holisticai/bias/mitigation/preprocessing/reweighing.py
index 6405c8d8..ec935c95 100644
--- a/src/holisticai/bias/mitigation/preprocessing/reweighing.py
+++ b/src/holisticai/bias/mitigation/preprocessing/reweighing.py
@@ -2,6 +2,7 @@
 
 import numpy as np
 import pandas as pd
+
 from holisticai.utils.transformers.bias import BMPreprocessing as BMPre
 from holisticai.utils.transformers.bias import SensitiveGroups
 
diff --git a/src/holisticai/bias/plots/_bias_classification_plots.py b/src/holisticai/bias/plots/_bias_classification_plots.py
index b154f952..65392f9a 100644
--- a/src/holisticai/bias/plots/_bias_classification_plots.py
+++ b/src/holisticai/bias/plots/_bias_classification_plots.py
@@ -3,13 +3,13 @@
 import numpy as np
 import seaborn as sns
 
+# sklearn imports
+from sklearn.metrics import roc_curve
+
 # utils
 from holisticai.utils import get_colors
 from holisticai.utils._validation import _check_binary, _regression_checks
 
-# sklearn imports
-from sklearn.metrics import roc_curve
-
 
 def abroca_plot(group_a, group_b, y_score, y_true, ax=None, size=None, title=None):
     """
diff --git a/src/holisticai/bias/plots/_bias_exploratory_plots.py b/src/holisticai/bias/plots/_bias_exploratory_plots.py
index b0a865e5..63bc457d 100644
--- a/src/holisticai/bias/plots/_bias_exploratory_plots.py
+++ b/src/holisticai/bias/plots/_bias_exploratory_plots.py
@@ -3,6 +3,7 @@
 import numpy as np
 import pandas as pd
 import seaborn as sns
+
 from holisticai.bias.metrics import confusion_matrix
 
 # utils
diff --git a/src/holisticai/bias/plots/_bias_exploratory_view.py b/src/holisticai/bias/plots/_bias_exploratory_view.py
index d9024be1..dc818bc8 100644
--- a/src/holisticai/bias/plots/_bias_exploratory_view.py
+++ b/src/holisticai/bias/plots/_bias_exploratory_view.py
@@ -1,8 +1,9 @@
 import ipywidgets as widgets  # type: ignore
 import matplotlib.pyplot as plt
+from IPython.display import display
+
 from holisticai.bias.plots._bias_exploratory_plots import group_pie_plot, histogram_plot
 from holisticai.bias.plots._bias_multiclass_plots import accuracy_bar_plot, frequency_matrix_plot, frequency_plot
-from IPython.display import display
 
 
 def binary_classification_data_exploration(dataset):
diff --git a/src/holisticai/bias/plots/_bias_multiclass_plots.py b/src/holisticai/bias/plots/_bias_multiclass_plots.py
index 63a9a7ad..01911f1a 100644
--- a/src/holisticai/bias/plots/_bias_multiclass_plots.py
+++ b/src/holisticai/bias/plots/_bias_multiclass_plots.py
@@ -2,6 +2,7 @@
 import numpy as np
 import pandas as pd
 import seaborn as sns
+from matplotlib import pyplot as plt
 
 # Import metrics
 from holisticai.bias.metrics import frequency_matrix
@@ -9,7 +10,6 @@
 
 # utils
 from holisticai.utils._validation import _check_binary, _multiclass_checks
-from matplotlib import pyplot as plt
 
 
 def frequency_plot(p_attr, y_pred, ax=None, size=None, title=None):
diff --git a/src/holisticai/bias/plots/_bias_recommender_plots.py b/src/holisticai/bias/plots/_bias_recommender_plots.py
index 8581c455..00cfd8ff 100644
--- a/src/holisticai/bias/plots/_bias_recommender_plots.py
+++ b/src/holisticai/bias/plots/_bias_recommender_plots.py
@@ -1,11 +1,11 @@
 # Base Imports
 import numpy as np
 import seaborn as sns
+from matplotlib import pyplot as plt
 
 # utils
 from holisticai.utils import get_colors, mat_to_binary, normalize_tensor
 from holisticai.utils._validation import _recommender_checks
-from matplotlib import pyplot as plt
 
 
 def long_tail_plot(mat_pred, top=None, thresh=0.5, normalize=False, ax=None, size=None, title=None):
diff --git a/src/holisticai/bias/plots/_bias_regression_plots.py b/src/holisticai/bias/plots/_bias_regression_plots.py
index ee22cf55..fee89c17 100644
--- a/src/holisticai/bias/plots/_bias_regression_plots.py
+++ b/src/holisticai/bias/plots/_bias_regression_plots.py
@@ -1,15 +1,15 @@
 # Base Imports
 import numpy as np
 import seaborn as sns
-
-# utils
-from holisticai.utils import get_colors
-from holisticai.utils._validation import _multiclass_checks, _regression_checks
 from matplotlib import pyplot as plt
 
 # sklearn imports
 from sklearn.metrics import mean_absolute_error, mean_squared_error
 
+# utils
+from holisticai.utils import get_colors
+from holisticai.utils._validation import _multiclass_checks, _regression_checks
+
 
 def success_rate_curve(group_a, group_b, y_pred, ax=None, size=None, title=None):
     """
diff --git a/src/holisticai/bias/plots/_classification.py b/src/holisticai/bias/plots/_classification.py
index 10af2285..76d7856b 100644
--- a/src/holisticai/bias/plots/_classification.py
+++ b/src/holisticai/bias/plots/_classification.py
@@ -1,15 +1,15 @@
 # Base Imports
 import numpy as np
 import seaborn as sns
-
-# utils
-from holisticai.utils import get_colors
-from holisticai.utils._validation import _check_binary, _classification_checks
 from matplotlib import pyplot as plt
 
 # sklearn imports
 from sklearn.metrics import roc_curve
 
+# utils
+from holisticai.utils import get_colors
+from holisticai.utils._validation import _check_binary, _classification_checks
+
 
 def abroca_plot(group_a, group_b, y_pred, y_true, ax=None, size=None, title=None):
     """
diff --git a/src/holisticai/bias/plots/_multiclass.py b/src/holisticai/bias/plots/_multiclass.py
index fddd8790..49afbd82 100644
--- a/src/holisticai/bias/plots/_multiclass.py
+++ b/src/holisticai/bias/plots/_multiclass.py
@@ -2,6 +2,7 @@
 import numpy as np
 import pandas as pd
 import seaborn as sns
+from matplotlib import pyplot as plt
 
 # Import metrics
 from holisticai.bias.metrics import frequency_matrix
@@ -9,7 +10,6 @@
 
 # utils
 from holisticai.utils._validation import _multiclass_checks
-from matplotlib import pyplot as plt
 
 
 def frequency_plot(p_attr, y_pred, ax=None, size=None, title=None):
diff --git a/src/holisticai/bias/plots/_recommender.py b/src/holisticai/bias/plots/_recommender.py
index 8c4c0611..43630af6 100644
--- a/src/holisticai/bias/plots/_recommender.py
+++ b/src/holisticai/bias/plots/_recommender.py
@@ -1,11 +1,11 @@
 # Base Imports
 import numpy as np
 import seaborn as sns
+from matplotlib import pyplot as plt
 
 # utils
 from holisticai.utils import get_colors, mat_to_binary, normalize_tensor
 from holisticai.utils._validation import _recommender_checks
-from matplotlib import pyplot as plt
 
 
 def long_tail_plot(mat_pred, top=None, thresh=0.5, normalize=False, ax=None, size=None, title=None):
diff --git a/src/holisticai/bias/plots/_regression.py b/src/holisticai/bias/plots/_regression.py
index 2fc1fc34..92667a31 100644
--- a/src/holisticai/bias/plots/_regression.py
+++ b/src/holisticai/bias/plots/_regression.py
@@ -1,15 +1,15 @@
 # Base Imports
 import numpy as np
 import seaborn as sns
-
-# utils
-from holisticai.utils import get_colors
-from holisticai.utils._validation import _multiclass_checks, _regression_checks
 from matplotlib import pyplot as plt
 
 # sklearn imports
 from sklearn.metrics import mean_absolute_error, mean_squared_error
 
+# utils
+from holisticai.utils import get_colors
+from holisticai.utils._validation import _multiclass_checks, _regression_checks
+
 
 def success_rate_curve(group_a, group_b, y_pred, ax=None, size=None, title=None):
     """
diff --git a/src/holisticai/datasets/_dataset.py b/src/holisticai/datasets/_dataset.py
index 0a063f08..c62bb771 100644
--- a/src/holisticai/datasets/_dataset.py
+++ b/src/holisticai/datasets/_dataset.py
@@ -3,9 +3,10 @@
 from typing import TYPE_CHECKING, Literal
 
 import pandas as pd
-from holisticai.utils.obj_rep.object_repr import DatasetReprObj
 from sklearn.model_selection import train_test_split
 
+from holisticai.utils.obj_rep.object_repr import DatasetReprObj
+
 if TYPE_CHECKING:
     from collections.abc import Iterable
 
diff --git a/src/holisticai/datasets/_load_dataset.py b/src/holisticai/datasets/_load_dataset.py
index 8220d3b5..c443a49b 100644
--- a/src/holisticai/datasets/_load_dataset.py
+++ b/src/holisticai/datasets/_load_dataset.py
@@ -4,6 +4,7 @@
 
 import numpy as np
 import pandas as pd
+
 from holisticai.datasets._dataloaders import load_hai_datasets
 from holisticai.datasets._dataset import Dataset
 from holisticai.datasets._utils import convert_float_to_categorical, get_protected_values
diff --git a/src/holisticai/datasets/plots/_exploratory.py b/src/holisticai/datasets/plots/_exploratory.py
index 082ce958..5de608fc 100644
--- a/src/holisticai/datasets/plots/_exploratory.py
+++ b/src/holisticai/datasets/plots/_exploratory.py
@@ -1,6 +1,7 @@
 import matplotlib.pyplot as plt
 import numpy as np
 import seaborn as sns
+
 from holisticai.datasets import Dataset
 
 # utils
diff --git a/src/holisticai/explainability/metrics/_classification.py b/src/holisticai/explainability/metrics/_classification.py
index 5e2114ad..b6447bbc 100644
--- a/src/holisticai/explainability/metrics/_classification.py
+++ b/src/holisticai/explainability/metrics/_classification.py
@@ -3,6 +3,7 @@
 from typing import TYPE_CHECKING
 
 import pandas as pd
+
 from holisticai.explainability.metrics.global_feature_importance import (
     AlphaScore,
     PositionParity,
diff --git a/src/holisticai/explainability/metrics/_multiclass.py b/src/holisticai/explainability/metrics/_multiclass.py
index 2efa0968..6ac39fc6 100644
--- a/src/holisticai/explainability/metrics/_multiclass.py
+++ b/src/holisticai/explainability/metrics/_multiclass.py
@@ -3,6 +3,7 @@
 from typing import TYPE_CHECKING
 
 import pandas as pd
+
 from holisticai.explainability.metrics.global_feature_importance import (
     AlphaScore,
     PositionParity,
diff --git a/src/holisticai/explainability/metrics/_regression.py b/src/holisticai/explainability/metrics/_regression.py
index 539a6842..b7c5664e 100644
--- a/src/holisticai/explainability/metrics/_regression.py
+++ b/src/holisticai/explainability/metrics/_regression.py
@@ -3,6 +3,7 @@
 from typing import TYPE_CHECKING
 
 import pandas as pd
+
 from holisticai.explainability.metrics.global_feature_importance import (
     AlphaScore,
     PositionParity,
diff --git a/src/holisticai/explainability/metrics/_tree.py b/src/holisticai/explainability/metrics/_tree.py
index 191b7b0c..1d09d58a 100644
--- a/src/holisticai/explainability/metrics/_tree.py
+++ b/src/holisticai/explainability/metrics/_tree.py
@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import pandas as pd
+
 from holisticai.explainability.metrics.tree import (
     TreeDepthVariance,
     TreeNumberOfFeatures,
diff --git a/src/holisticai/explainability/metrics/global_feature_importance/__init__.py b/src/holisticai/explainability/metrics/global_feature_importance/__init__.py
index 6bc640d9..fdefdfe2 100644
--- a/src/holisticai/explainability/metrics/global_feature_importance/__init__.py
+++ b/src/holisticai/explainability/metrics/global_feature_importance/__init__.py
@@ -1,4 +1,5 @@
 import pandas as pd
+
 from holisticai.explainability.metrics.global_feature_importance._alpha_score import (
     AlphaScore,
     alpha_score,
diff --git a/src/holisticai/explainability/metrics/global_feature_importance/_importance_spread.py b/src/holisticai/explainability/metrics/global_feature_importance/_importance_spread.py
index a0a7acf1..9ab48f3d 100644
--- a/src/holisticai/explainability/metrics/global_feature_importance/_importance_spread.py
+++ b/src/holisticai/explainability/metrics/global_feature_importance/_importance_spread.py
@@ -1,8 +1,9 @@
 import numpy as np
-from holisticai.typing import ArrayLike
 from scipy.spatial.distance import jensenshannon
 from scipy.stats import entropy
 
+from holisticai.typing import ArrayLike
+
 
 class FeatureImportanceSpread:
     """
diff --git a/src/holisticai/explainability/metrics/local_feature_importance/__init__.py b/src/holisticai/explainability/metrics/local_feature_importance/__init__.py
index 81324073..f27ea447 100644
--- a/src/holisticai/explainability/metrics/local_feature_importance/__init__.py
+++ b/src/holisticai/explainability/metrics/local_feature_importance/__init__.py
@@ -1,4 +1,5 @@
 import pandas as pd
+
 from holisticai.explainability.metrics.local_feature_importance._importance_stability import importance_stability
 from holisticai.explainability.metrics.local_feature_importance._rank_consistency import (
     local_normalized_desviation,
diff --git a/src/holisticai/explainability/metrics/surrogate/_classification.py b/src/holisticai/explainability/metrics/surrogate/_classification.py
index 4eb08640..b1a207f3 100644
--- a/src/holisticai/explainability/metrics/surrogate/_classification.py
+++ b/src/holisticai/explainability/metrics/surrogate/_classification.py
@@ -2,6 +2,8 @@
 
 import numpy as np
 import pandas as pd
+from sklearn.metrics import accuracy_score
+
 from holisticai.explainability.metrics.global_feature_importance._importance_spread import FeatureImportanceSpread
 from holisticai.explainability.metrics.global_feature_importance._surrogate import (
     surrogate_accuracy_score,
@@ -20,7 +22,6 @@
 )
 from holisticai.typing import ArrayLike
 from holisticai.utils.surrogate_models import BinaryClassificationSurrogate, MultiClassificationSurrogate
-from sklearn.metrics import accuracy_score
 
 
 class AccuracyDegradation:
diff --git a/src/holisticai/explainability/metrics/surrogate/_clustering.py b/src/holisticai/explainability/metrics/surrogate/_clustering.py
index 992a682f..c2532555 100644
--- a/src/holisticai/explainability/metrics/surrogate/_clustering.py
+++ b/src/holisticai/explainability/metrics/surrogate/_clustering.py
@@ -1,6 +1,8 @@
 from typing import Any, Literal
 
 import pandas as pd
+from sklearn.metrics import accuracy_score
+
 from holisticai.explainability.metrics.global_feature_importance._importance_spread import (
     FeatureImportanceSpread,
 )
@@ -20,7 +22,6 @@
     WeightedTreeGini,
 )
 from holisticai.utils.surrogate_models import ClusteringSurrogate
-from sklearn.metrics import accuracy_score
 
 
 class AccuracyDegradation:
diff --git a/src/holisticai/explainability/metrics/surrogate/_regression.py b/src/holisticai/explainability/metrics/surrogate/_regression.py
index e43c5e21..5cd53f87 100644
--- a/src/holisticai/explainability/metrics/surrogate/_regression.py
+++ b/src/holisticai/explainability/metrics/surrogate/_regression.py
@@ -2,6 +2,7 @@
 
 import numpy as np
 import pandas as pd
+
 from holisticai.explainability.metrics.global_feature_importance._importance_spread import (
     FeatureImportanceSpread,
 )
diff --git a/src/holisticai/explainability/metrics/surrogate/_stability.py b/src/holisticai/explainability/metrics/surrogate/_stability.py
index 6b3dd770..106dc821 100644
--- a/src/holisticai/explainability/metrics/surrogate/_stability.py
+++ b/src/holisticai/explainability/metrics/surrogate/_stability.py
@@ -2,9 +2,10 @@
 from typing import Any
 
 import numpy as np
-from holisticai.utils.surrogate_models import Surrogate, get_features
 from sklearn.utils import resample
 
+from holisticai.utils.surrogate_models import Surrogate, get_features
+
 
 class FeaturesStability:
     """
diff --git a/src/holisticai/explainability/metrics/tree/_tree.py b/src/holisticai/explainability/metrics/tree/_tree.py
index b5294386..ea900326 100644
--- a/src/holisticai/explainability/metrics/tree/_tree.py
+++ b/src/holisticai/explainability/metrics/tree/_tree.py
@@ -1,4 +1,5 @@
 import numpy as np
+
 from holisticai.utils.surrogate_models import get_features, get_number_of_rules
 
 
diff --git a/src/holisticai/explainability/plots/_feature_importance.py b/src/holisticai/explainability/plots/_feature_importance.py
index 70a465dd..52a592f7 100644
--- a/src/holisticai/explainability/plots/_feature_importance.py
+++ b/src/holisticai/explainability/plots/_feature_importance.py
@@ -1,6 +1,11 @@
 import numpy as np
 import pandas as pd
 import seaborn as sns
+from matplotlib import patches
+from matplotlib import pyplot as plt
+from matplotlib.colors import LinearSegmentedColormap
+from scipy.spatial.distance import jensenshannon
+
 from holisticai.explainability.metrics.global_feature_importance import fluctuation_ratio
 from holisticai.explainability.metrics.local_feature_importance import (
     compute_importance_distribution,
@@ -9,10 +14,6 @@
     rank_consistency,
 )
 from holisticai.utils import Importances
-from matplotlib import patches
-from matplotlib import pyplot as plt
-from matplotlib.colors import LinearSegmentedColormap
-from scipy.spatial.distance import jensenshannon
 
 
 def plot_feature_importance(feature_importance: Importances, alpha=0.8, top_n=20, ax=None):
diff --git a/src/holisticai/explainability/plots/_partial_dependence.py b/src/holisticai/explainability/plots/_partial_dependence.py
index 62102ed9..4b1fae3b 100644
--- a/src/holisticai/explainability/plots/_partial_dependence.py
+++ b/src/holisticai/explainability/plots/_partial_dependence.py
@@ -1,11 +1,12 @@
 import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
+from matplotlib import cm
+from scipy.interpolate import interp1d
+
 from holisticai.explainability.metrics.global_feature_importance._fluctuation_ratio import fluctuation_ratio
 from holisticai.explainability.metrics.global_feature_importance._xai_ease_score import XAIEaseAnnotator
 from holisticai.utils import Importances, PartialDependence
-from matplotlib import cm
-from scipy.interpolate import interp1d
 
 
 def plot_partial_dependence(
diff --git a/src/holisticai/explainability/plots/_partial_dependencies.py b/src/holisticai/explainability/plots/_partial_dependencies.py
index 62102ed9..4b1fae3b 100644
--- a/src/holisticai/explainability/plots/_partial_dependencies.py
+++ b/src/holisticai/explainability/plots/_partial_dependencies.py
@@ -1,11 +1,12 @@
 import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
+from matplotlib import cm
+from scipy.interpolate import interp1d
+
 from holisticai.explainability.metrics.global_feature_importance._fluctuation_ratio import fluctuation_ratio
 from holisticai.explainability.metrics.global_feature_importance._xai_ease_score import XAIEaseAnnotator
 from holisticai.utils import Importances, PartialDependence
-from matplotlib import cm
-from scipy.interpolate import interp1d
 
 
 def plot_partial_dependence(
diff --git a/src/holisticai/explainability/plots/_tree.py b/src/holisticai/explainability/plots/_tree.py
index 77e090fc..69814cd7 100644
--- a/src/holisticai/explainability/plots/_tree.py
+++ b/src/holisticai/explainability/plots/_tree.py
@@ -2,9 +2,10 @@
 
 import matplotlib.pyplot as plt
 import numpy as np
-from holisticai.utils import Importances
 from sklearn.tree._export import _MPLTreeExporter
 
+from holisticai.utils import Importances
+
 
 def _color_brew(n):
     """Generate n colors using the 'viridis' colormap.
diff --git a/src/holisticai/inspection/_lime.py b/src/holisticai/inspection/_lime.py
index a7d17a26..b4103e12 100644
--- a/src/holisticai/inspection/_lime.py
+++ b/src/holisticai/inspection/_lime.py
@@ -4,10 +4,11 @@
 
 import numpy as np
 import pandas as pd
+from numpy.random import RandomState
+
 from holisticai.datasets._dataset import Dataset
 from holisticai.inspection._utils import group_mask_samples_by_learning_task
 from holisticai.utils._definitions import LocalImportances, ModelProxy
-from numpy.random import RandomState
 
 warnings.filterwarnings("ignore")
 
diff --git a/src/holisticai/inspection/_partial_dependence.py b/src/holisticai/inspection/_partial_dependence.py
index 062090fb..46b102ea 100644
--- a/src/holisticai/inspection/_partial_dependence.py
+++ b/src/holisticai/inspection/_partial_dependence.py
@@ -4,12 +4,13 @@
 from typing import TYPE_CHECKING
 
 import numpy as np
-from holisticai.utils._commons import get_columns
-from holisticai.utils._definitions import ModelProxy, PartialDependence
 from joblib import Parallel, delayed
 from sklearn.inspection import partial_dependence
 from sklearn.metrics import accuracy_score, r2_score
 
+from holisticai.utils._commons import get_columns
+from holisticai.utils._definitions import ModelProxy, PartialDependence
+
 if TYPE_CHECKING:
     import pandas as pd
 
diff --git a/src/holisticai/inspection/_permutation_importance.py b/src/holisticai/inspection/_permutation_importance.py
index 8178e569..4bb69896 100644
--- a/src/holisticai/inspection/_permutation_importance.py
+++ b/src/holisticai/inspection/_permutation_importance.py
@@ -4,6 +4,9 @@
 
 import numpy as np
 import pandas as pd
+from numpy.random import RandomState
+from sklearn.metrics import accuracy_score, mean_squared_error
+
 from holisticai.inspection._utils import group_index_samples_by_learning_task
 from holisticai.utils._commons import get_columns, get_item
 from holisticai.utils._definitions import (
@@ -11,8 +14,6 @@
     Importances,
     ModelProxy,
 )
-from numpy.random import RandomState
-from sklearn.metrics import accuracy_score, mean_squared_error
 
 metric_scores = {
     "binary_classification": accuracy_score,
diff --git a/src/holisticai/inspection/_shap.py b/src/holisticai/inspection/_shap.py
index 4c5d5949..43997e5f 100644
--- a/src/holisticai/inspection/_shap.py
+++ b/src/holisticai/inspection/_shap.py
@@ -2,10 +2,11 @@
 
 import numpy as np
 import pandas as pd
+from numpy.random import RandomState
+
 from holisticai.datasets._dataset import Dataset
 from holisticai.inspection import group_mask_samples_by_learning_task
 from holisticai.utils import LocalImportances, ModelProxy
-from numpy.random import RandomState
 
 
 def compute_shap_feature_importance(
diff --git a/src/holisticai/inspection/_surrogate_importance.py b/src/holisticai/inspection/_surrogate_importance.py
index 3699fce9..a0494dd2 100644
--- a/src/holisticai/inspection/_surrogate_importance.py
+++ b/src/holisticai/inspection/_surrogate_importance.py
@@ -4,12 +4,13 @@
 
 import numpy as np
 import pandas as pd
-from holisticai.inspection._utils import group_index_samples_by_learning_task
-from holisticai.utils._definitions import ConditionalImportances, Importances, ModelProxy
 from numpy.random import RandomState
 from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
 from sklearn.metrics import accuracy_score, mean_squared_error
 
+from holisticai.inspection._utils import group_index_samples_by_learning_task
+from holisticai.utils._definitions import ConditionalImportances, Importances, ModelProxy
+
 metric_scores = {
     "binary_classification": accuracy_score,
     "regression": mean_squared_error,
diff --git a/src/holisticai/pipeline/_pipeline.py b/src/holisticai/pipeline/_pipeline.py
index 7bc44277..d0fda05e 100644
--- a/src/holisticai/pipeline/_pipeline.py
+++ b/src/holisticai/pipeline/_pipeline.py
@@ -1,10 +1,11 @@
 import inspect
 
-from holisticai.pipeline._pipeline_helper import PipelineHelper
-from holisticai.utils.obj_rep.object_repr import PipelineReprObj
 from sklearn.pipeline import Pipeline as SKLPipeline
 from sklearn.utils.metaestimators import available_if
 
+from holisticai.pipeline._pipeline_helper import PipelineHelper
+from holisticai.utils.obj_rep.object_repr import PipelineReprObj
+
 
 def _fulfill_conditions(fn_name: str):
     def check(self):
diff --git a/src/holisticai/pipeline/_pipeline_helper.py b/src/holisticai/pipeline/_pipeline_helper.py
index 31081b81..8937b924 100644
--- a/src/holisticai/pipeline/_pipeline_helper.py
+++ b/src/holisticai/pipeline/_pipeline_helper.py
@@ -1,7 +1,8 @@
+from sklearn.pipeline import Pipeline as SKLPipeline
+
 from holisticai.pipeline.handlers._estimator import EstimatorHandler
 from holisticai.pipeline.handlers._pipeline_params import PipelineParametersHandler
 from holisticai.pipeline.handlers._utransformers import UTransformersHandler
-from sklearn.pipeline import Pipeline as SKLPipeline
 
 SUPPORTED_FUNCTIONS = [
     "fit",
diff --git a/src/holisticai/robustness/attackers/classification/hop_skip_jump.py b/src/holisticai/robustness/attackers/classification/hop_skip_jump.py
index 7cb0366f..8e4c244f 100644
--- a/src/holisticai/robustness/attackers/classification/hop_skip_jump.py
+++ b/src/holisticai/robustness/attackers/classification/hop_skip_jump.py
@@ -10,6 +10,7 @@
 from typing import TYPE_CHECKING
 
 import numpy as np
+
 from holisticai.robustness.attackers.classification.commons import x_array_to_df, x_to_nd_array
 
 if TYPE_CHECKING:
diff --git a/src/holisticai/robustness/attackers/classification/zeroth_order_optimization.py b/src/holisticai/robustness/attackers/classification/zeroth_order_optimization.py
index 3566f22d..cb67ba5f 100644
--- a/src/holisticai/robustness/attackers/classification/zeroth_order_optimization.py
+++ b/src/holisticai/robustness/attackers/classification/zeroth_order_optimization.py
@@ -11,13 +11,14 @@
 from typing import TYPE_CHECKING, Any
 
 import numpy as np
+from scipy.ndimage import zoom
+
 from holisticai.robustness.attackers.classification.commons import (
     format_function_predict_proba,
     to_categorical,
     x_array_to_df,
     x_to_nd_array,
 )
-from scipy.ndimage import zoom
 
 if TYPE_CHECKING:
     import pandas as pd
diff --git a/src/holisticai/robustness/attackers/regression/gb_attackers.py b/src/holisticai/robustness/attackers/regression/gb_attackers.py
index cb112832..09bbb59b 100644
--- a/src/holisticai/robustness/attackers/regression/gb_attackers.py
+++ b/src/holisticai/robustness/attackers/regression/gb_attackers.py
@@ -1,8 +1,9 @@
 import numpy as np
 import numpy.linalg as la
-from holisticai.robustness.attackers.regression.gb_base import GDPoisoner
 from sklearn import linear_model
 
+from holisticai.robustness.attackers.regression.gb_base import GDPoisoner
+
 
 class LinRegGDPoisoner(GDPoisoner):
     """
diff --git a/src/holisticai/robustness/attackers/regression/gb_base.py b/src/holisticai/robustness/attackers/regression/gb_base.py
index 093f1256..ac937300 100644
--- a/src/holisticai/robustness/attackers/regression/gb_base.py
+++ b/src/holisticai/robustness/attackers/regression/gb_base.py
@@ -2,11 +2,12 @@
 
 import numpy as np
 import pandas as pd
-from holisticai.robustness.attackers.regression.initializers import adaptive, inf_flip, randflip, randflipnobd
-from holisticai.robustness.attackers.regression.utils import one_hot_encode_columns, revert_one_hot_encoding
 from sklearn.linear_model import Ridge
 from sklearn.metrics import mean_squared_error
 
+from holisticai.robustness.attackers.regression.initializers import adaptive, inf_flip, randflip, randflipnobd
+from holisticai.robustness.attackers.regression.utils import one_hot_encode_columns, revert_one_hot_encoding
+
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 logger = logging.getLogger()
 
diff --git a/src/holisticai/security/commons/data_minimization/_core.py b/src/holisticai/security/commons/data_minimization/_core.py
index 2e2a651a..e797494c 100644
--- a/src/holisticai/security/commons/data_minimization/_core.py
+++ b/src/holisticai/security/commons/data_minimization/_core.py
@@ -8,6 +8,7 @@
 
 if TYPE_CHECKING:
     import pandas as pd
+
     from holisticai.utils import ModelProxy
 
 logger = logging.getLogger(__name__)
diff --git a/src/holisticai/security/commons/data_minimization/_selectors.py b/src/holisticai/security/commons/data_minimization/_selectors.py
index ede69fef..a2433e68 100644
--- a/src/holisticai/security/commons/data_minimization/_selectors.py
+++ b/src/holisticai/security/commons/data_minimization/_selectors.py
@@ -4,7 +4,6 @@
 from typing import TYPE_CHECKING, Literal, get_args
 
 import numpy as np
-from holisticai.inspection import compute_permutation_importance
 from sklearn.feature_selection import (
     SelectPercentile,
     VarianceThreshold,
@@ -12,8 +11,11 @@
     f_regression,
 )
 
+from holisticai.inspection import compute_permutation_importance
+
 if TYPE_CHECKING:
     import pandas as pd
+
     from holisticai.utils import Importances, ModelProxy
 
 logger = logging.getLogger(__name__)
diff --git a/src/holisticai/security/metrics/__init__.py b/src/holisticai/security/metrics/__init__.py
index 072736df..e96df277 100644
--- a/src/holisticai/security/metrics/__init__.py
+++ b/src/holisticai/security/metrics/__init__.py
@@ -5,6 +5,7 @@
 from __future__ import annotations
 
 import pandas as pd
+
 from holisticai.security.metrics._anonymization import k_anonymity, l_diversity
 from holisticai.security.metrics._attribute_attack import AttributeAttackScore, attribute_attack_score
 from holisticai.security.metrics._data_minimization import (
diff --git a/src/holisticai/security/metrics/_attribute_attack.py b/src/holisticai/security/metrics/_attribute_attack.py
index c5bfc5bf..5fc79d2d 100644
--- a/src/holisticai/security/metrics/_attribute_attack.py
+++ b/src/holisticai/security/metrics/_attribute_attack.py
@@ -2,11 +2,12 @@
 
 from typing import TYPE_CHECKING, Any, Callable
 
-from holisticai.security.commons import BlackBoxAttack
-from holisticai.security.metrics._utils import check_valid_output_type
 from sklearn.linear_model import LinearRegression, LogisticRegression
 from sklearn.metrics import accuracy_score, f1_score, mean_absolute_error, mean_squared_error
 
+from holisticai.security.commons import BlackBoxAttack
+from holisticai.security.metrics._utils import check_valid_output_type
+
 if TYPE_CHECKING:
     import pandas as pd
 
diff --git a/src/holisticai/security/metrics/_shapr.py b/src/holisticai/security/metrics/_shapr.py
index 8c01002a..1dc4a7c0 100644
--- a/src/holisticai/security/metrics/_shapr.py
+++ b/src/holisticai/security/metrics/_shapr.py
@@ -3,9 +3,10 @@
 from typing import TYPE_CHECKING
 
 import numpy as np
+from sklearn.preprocessing import LabelEncoder
+
 from holisticai.typing import ArrayLike
 from holisticai.utils.models.neighbors import KNeighborsClassifier
-from sklearn.preprocessing import LabelEncoder
 
 try:
     import jax.numpy as jnp
diff --git a/src/holisticai/utils/_definitions.py b/src/holisticai/utils/_definitions.py
index b3d3fbdc..ac07e8e7 100644
--- a/src/holisticai/utils/_definitions.py
+++ b/src/holisticai/utils/_definitions.py
@@ -4,6 +4,7 @@
 
 import numpy as np
 import pandas as pd
+
 from holisticai.utils._commons import get_number_of_feature_above_threshold_importance
 from holisticai.utils._validation import _array_like_to_numpy
 from holisticai.utils.obj_rep.object_repr import ReprObj
diff --git a/src/holisticai/utils/_formatting.py b/src/holisticai/utils/_formatting.py
index a4f37dad..d73ea45c 100644
--- a/src/holisticai/utils/_formatting.py
+++ b/src/holisticai/utils/_formatting.py
@@ -1,5 +1,6 @@
 # Base Imports
 import numpy as np
+
 from holisticai.utils._validation import _array_like_to_numpy
 
 
diff --git a/src/holisticai/utils/_recommender_tools.py b/src/holisticai/utils/_recommender_tools.py
index de58cabe..8bee75b2 100644
--- a/src/holisticai/utils/_recommender_tools.py
+++ b/src/holisticai/utils/_recommender_tools.py
@@ -1,11 +1,11 @@
 import numpy as np
 
-# Formatting
-from holisticai.utils import mat_to_binary
-
 # scikit
 from sklearn.metrics import f1_score, precision_score, recall_score
 
+# Formatting
+from holisticai.utils import mat_to_binary
+
 
 def avg_precision(mat_pred, mat_true, top=None, thresh=0.5):
     """
diff --git a/src/holisticai/utils/surrogate_models/__init__.py b/src/holisticai/utils/surrogate_models/__init__.py
index a0cd1cbb..764a3c2f 100644
--- a/src/holisticai/utils/surrogate_models/__init__.py
+++ b/src/holisticai/utils/surrogate_models/__init__.py
@@ -3,11 +3,12 @@
 from typing import Literal, Union
 
 import numpy as np
+from numpy.random import RandomState
+
 from holisticai.utils.surrogate_models._trees import (
     DecisionTreeClassifier,
     DecisionTreeRegressor,
 )
-from numpy.random import RandomState
 
 Surrogate = Union[DecisionTreeClassifier, DecisionTreeRegressor]
 LearningTask = Literal["binary_classification", "multi_classification", "regression"]
diff --git a/src/holisticai/utils/surrogate_models/_trees.py b/src/holisticai/utils/surrogate_models/_trees.py
index 07e11bdc..fa2239d2 100644
--- a/src/holisticai/utils/surrogate_models/_trees.py
+++ b/src/holisticai/utils/surrogate_models/_trees.py
@@ -4,9 +4,10 @@
 
 import numpy as np
 import pandas as pd
+from sklearn.metrics import accuracy_score, mean_squared_error
+
 from holisticai.utils.obj_rep.object_repr import ReprObj
 from holisticai.utils.surrogate_models._base import SurrogateBase
-from sklearn.metrics import accuracy_score, mean_squared_error
 
 if TYPE_CHECKING:
     from numpy.random import RandomState
diff --git a/src/holisticai/utils/transformers/bias/_inprocessing.py b/src/holisticai/utils/transformers/bias/_inprocessing.py
index a44fac36..42cb99f3 100644
--- a/src/holisticai/utils/transformers/bias/_inprocessing.py
+++ b/src/holisticai/utils/transformers/bias/_inprocessing.py
@@ -1,6 +1,7 @@
 import inspect
 
 import numpy as np
+
 from holisticai.utils.obj_rep.object_repr import BMReprObj
 from holisticai.utils.transformers._transformer_base import BMTransformerBase
 
diff --git a/src/holisticai/utils/transformers/bias/_postprocessing.py b/src/holisticai/utils/transformers/bias/_postprocessing.py
index fdcefb77..38a9f9e2 100644
--- a/src/holisticai/utils/transformers/bias/_postprocessing.py
+++ b/src/holisticai/utils/transformers/bias/_postprocessing.py
@@ -2,6 +2,7 @@
 
 import numpy as np
 import pandas as pd
+
 from holisticai.utils._validation import _check_valid_y_proba
 from holisticai.utils.obj_rep.object_repr import BMReprObj
 from holisticai.utils.transformers._transformer_base import BMTransformerBase
diff --git a/src/holisticai/utils/transformers/bias/_preprocessing.py b/src/holisticai/utils/transformers/bias/_preprocessing.py
index 0fc496dd..78b97e76 100644
--- a/src/holisticai/utils/transformers/bias/_preprocessing.py
+++ b/src/holisticai/utils/transformers/bias/_preprocessing.py
@@ -1,6 +1,7 @@
 import inspect
 
 import numpy as np
+
 from holisticai.utils.obj_rep.object_repr import BMReprObj
 from holisticai.utils.transformers._transformer_base import BMTransformerBase
 

From 3a8004b99b57387ffe6f87b5e33e46471755a5ba Mon Sep 17 00:00:00 2001
From: franklincf <fracarfer5@gmail.com>
Date: Wed, 7 May 2025 19:43:00 -0300
Subject: [PATCH 32/34] chore: deleting unused files

---
 .../attackers/attribute_inference/attack.py   |  219 ---
 .../attribute_inference/exceptions.py         |   68 -
 .../mitigation/__init__.py                    |    0
 .../mitigation/attacks/__init__.py            |    0
 .../white_box_lifestyle_decision_tree.py      |  128 --
 .../attribute_inference/mitigation/config.py  |   25 -
 .../mitigation/defences/__init__.py           |    0
 .../defences/postprocessor/__init__.py        |    0
 .../defences/postprocessor/postprocessor.py   |  132 --
 .../defences/preprocessor/__init__.py         |    0
 .../defences/preprocessor/preprocessor.py     |  178 --
 .../mitigation/preprocessing/__init__.py      |    0
 .../mitigation/preprocessing/preprocessing.py |   22 -
 .../preprocessing/standardisation/__init__.py |    0
 .../preprocessing/standardisation/numpy.py    |  139 --
 .../preprocessing/standardisation/utils.py    |   53 -
 .../mitigation/scikitlearn.py                 |  140 --
 .../mitigation/utils/__init__.py              |    0
 .../mitigation/utils/exceptions.py            |   68 -
 .../mitigation/utils/formatting.py            |   50 -
 .../verification_decisions_trees.py           |  152 --
 .../attribute_inference/wrappers/__init__.py  |    0
 .../wrappers/classification/__init__.py       |    0
 .../wrappers/classification/classifier.py     |  254 ---
 .../wrappers/classification/scikitlearn.py    | 1627 -----------------
 .../attribute_inference/wrappers/estimator.py |  468 -----
 .../wrappers/regression/__init__.py           |    0
 .../wrappers/regression/regressor.py          |   28 -
 .../wrappers/regression/scikitlearn.py        |  417 -----
 .../wrappers/scikitlearn.py                   |   54 -
 30 files changed, 4222 deletions(-)
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/attack.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/exceptions.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/__init__.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/attacks/__init__.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/attacks/white_box_lifestyle_decision_tree.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/config.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/defences/__init__.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/defences/postprocessor/__init__.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/defences/postprocessor/postprocessor.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/defences/preprocessor/__init__.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/defences/preprocessor/preprocessor.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/__init__.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/preprocessing.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/standardisation/__init__.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/standardisation/numpy.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/standardisation/utils.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/scikitlearn.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/utils/__init__.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/utils/exceptions.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/utils/formatting.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/mitigation/verification_decisions_trees.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/wrappers/__init__.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/wrappers/classification/__init__.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/wrappers/classification/classifier.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/wrappers/classification/scikitlearn.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/wrappers/estimator.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/wrappers/regression/__init__.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/wrappers/regression/regressor.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/wrappers/regression/scikitlearn.py
 delete mode 100644 src/holisticai/security/attackers/attribute_inference/wrappers/scikitlearn.py

diff --git a/src/holisticai/security/attackers/attribute_inference/attack.py b/src/holisticai/security/attackers/attribute_inference/attack.py
deleted file mode 100644
index 36d77411..00000000
--- a/src/holisticai/security/attackers/attribute_inference/attack.py
+++ /dev/null
@@ -1,219 +0,0 @@
-from __future__ import annotations
-
-import abc
-import logging
-from typing import Any, Optional, Union
-
-import numpy as np
-from holisticai.security.attackers.attribute_inference.exceptions import EstimatorError
-from holisticai.security.attackers.attribute_inference.utils import is_estimator_valid
-
-logger = logging.getLogger(__name__)
-
-
-class InputFilter(abc.ABCMeta):  # pragma: no cover
-    """
-    Metaclass to ensure that inputs are ndarray for all of the subclass generate and extract calls
-
-    This metaclass is used to ensure that the input to all generate and extract methods is an ndarray. This is
-    necessary because the input to these methods is often a list or a pandas DataFrame, and the methods themselves
-    are not always implemented to handle these types of inputs. This metaclass overrides the generate and extract
-    methods with new methods that ensure the input is an ndarray.
-
-    Parameters
-    ----------
-    name : str
-        The name of the class.
-    bases : tuple
-        The base classes of the class.
-    clsdict : dict
-        The class dictionary.
-    """
-
-    def __init__(cls, name, bases, clsdict):  # noqa: ARG003
-        def make_replacement(fdict, func_name):
-            """
-            This function overrides creates replacement functions dynamically.
-
-            Parameters
-            ----------
-            fdict : dict
-                The class dictionary.
-            func_name : str
-                The name of the function to override.
-
-            Returns
-            -------
-            replacement_function : function
-                The replacement function.
-            """
-
-            def replacement_function(self, *args, **kwargs):
-                if len(args) > 0:
-                    lst = list(args)
-
-                if "x" in kwargs:
-                    if not isinstance(kwargs["x"], np.ndarray):
-                        kwargs["x"] = np.array(kwargs["x"])
-                elif not isinstance(args[0], np.ndarray):
-                    lst[0] = np.array(args[0])
-
-                if "y" in kwargs:
-                    if kwargs["y"] is not None and not isinstance(kwargs["y"], np.ndarray):
-                        kwargs["y"] = np.array(kwargs["y"])
-                elif len(args) == 2 and not isinstance(args[1], np.ndarray):
-                    lst[1] = np.array(args[1])
-
-                if len(args) > 0:
-                    args = tuple(lst)
-                return fdict[func_name](self, *args, **kwargs)
-
-            replacement_function.__doc__ = fdict[func_name].__doc__
-            replacement_function.__name__ = "new_" + func_name
-            return replacement_function
-
-        replacement_list = ["generate", "extract"]
-        for item in replacement_list:
-            if item in clsdict:
-                new_function = make_replacement(clsdict, item)
-                setattr(cls, item, new_function)
-
-
-class Attack(abc.ABC):  # noqa: B024
-    """
-    Abstract base class for all attack abstract base classes.
-
-    Parameters
-    ----------
-    estimator : :class:`.holisticai.wrappers.estimator.BaseEstimator`
-        An estimator.
-    """
-
-    attack_params: list[str] = []
-    # The _estimator_requirements define the requirements an estimator must satisfy to be used as a target for an
-    # attack. They should be a tuple of requirements, where each requirement is either a class the estimator must
-    # inherit from, or a tuple of classes which define a union, i.e. the estimator must inherit from at least one class
-    # in the requirement tuple.
-    _estimator_requirements: Optional[Union[tuple[Any, ...], tuple[()]]] = None
-
-    def __init__(self, estimator):
-        super().__init__()
-
-        if self.estimator_requirements is None:
-            raise ValueError("Estimator requirements have not been defined in `_estimator_requirements`.")
-
-        if not is_estimator_valid(estimator, self._estimator_requirements):
-            raise EstimatorError(self.__class__, self.estimator_requirements, estimator)
-
-        self._estimator = estimator
-
-    @property
-    def estimator(self):
-        """
-        The estimator.
-
-        Returns
-        -------
-        object
-            The estimator.
-        """
-        return self._estimator
-
-    @property
-    def estimator_requirements(self):
-        """
-        The estimator requirements.
-
-        Returns
-        -------
-        tuple
-            The estimator requirements.
-        """
-        return self._estimator_requirements
-
-    def set_params(self, **kwargs) -> None:
-        """
-        Take in a dictionary of parameters and apply attack-specific checks before saving them as attributes.
-
-        Parameters
-        ----------
-        **kwargs
-            A dictionary of attack-specific parameters.
-        """
-        for key, value in kwargs.items():
-            if key in self.attack_params:
-                setattr(self, key, value)
-        self._check_params()
-
-
-class InferenceAttack(Attack):
-    """
-    Abstract base class for inference attack classes.
-
-    Parameters
-    ----------
-    estimator : object
-        A trained estimator targeted for inference attack.
-    """
-
-    def __init__(self, estimator):
-        super().__init__(estimator)
-
-    @abc.abstractmethod
-    def infer(self, x: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> np.ndarray:
-        """
-        Infer sensitive attributes from the targeted estimator. This method
-        should be overridden by all concrete inference attack implementations.
-
-        Parameters
-        ----------
-        x : np.ndarray
-            An array with reference inputs to be used in the attack.
-        y : np.ndarray, optional
-            Labels for `x`. This parameter is only used by some of the attacks.
-
-        Returns
-        -------
-        np.ndarray
-            An array holding the inferred attribute values.
-        """
-        raise NotImplementedError
-
-
-class AttributeInferenceAttack(InferenceAttack):
-    """
-    Abstract base class for attribute inference attack classes.
-
-    Parameters
-    ----------
-    estimator : object
-        A trained estimator targeted for inference attack.
-    attack_feature : int or slice
-        The index of the feature to be attacked.
-    """
-
-    attack_params = [*InferenceAttack.attack_params, "attack_feature"]
-
-    def __init__(self, estimator, attack_feature: Union[int, slice] = 0):
-        super().__init__(estimator)
-        self.attack_feature = attack_feature
-
-    @abc.abstractmethod
-    def infer(self, x: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> np.ndarray:
-        """
-        Infer sensitive attributes from the targeted estimator. This method
-        should be overridden by all concrete inference attack implementations.
-
-        Parameters
-        ----------
-        x : np.ndarray
-            An array with reference inputs to be used in the attack.
-        y : np.ndarray, optional
-            Labels for `x`. This parameter is only used by some of the attacks.
-
-        Returns
-        -------
-        np.ndarray
-            An array holding the inferred attribute values.
-        """
-        raise NotImplementedError
diff --git a/src/holisticai/security/attackers/attribute_inference/exceptions.py b/src/holisticai/security/attackers/attribute_inference/exceptions.py
deleted file mode 100644
index db1f8be6..00000000
--- a/src/holisticai/security/attackers/attribute_inference/exceptions.py
+++ /dev/null
@@ -1,68 +0,0 @@
-# MIT License
-#
-# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2018
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
-# Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
-# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-"""
-Module containing ART's exceptions.
-"""
-
-from __future__ import annotations
-
-from typing import Union
-
-
-class EstimatorError(TypeError):
-    """
-    Basic exception for errors raised by unexpected estimator types.
-
-    Parameters
-    ----------
-    this_class : type
-        The class that raised the exception.
-    class_expected_list : list[Union[type, tuple[type]]]
-        The expected classes for the estimator.
-    classifier_given : object
-        The classifier that was given.
-    """
-
-    def __init__(self, this_class, class_expected_list: list[Union[type, tuple[type]]], classifier_given) -> None:
-        super().__init__()
-        self.this_class = this_class
-        self.class_expected_list = class_expected_list
-        self.classifier_given = classifier_given
-
-        classes_expected_message = ""
-        for idx, class_expected in enumerate(class_expected_list):
-            if idx != 0:
-                classes_expected_message += " and "
-            if isinstance(class_expected, type):
-                classes_expected_message += f"{class_expected}"
-            else:
-                classes_expected_message += "("
-                for or_idx, or_class in enumerate(class_expected):
-                    if or_idx != 0:
-                        classes_expected_message += " or "
-                    classes_expected_message += f"{or_class}"
-                classes_expected_message += ")"
-
-        self.message = (
-            f"{this_class.__name__} requires an estimator derived from {classes_expected_message}, "
-            f"the provided classifier is an instance of {type(classifier_given)} "
-            f"and is derived from {classifier_given.__class__.__bases__}."
-        )
-
-    def __str__(self) -> str:
-        return self.message
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/__init__.py b/src/holisticai/security/attackers/attribute_inference/mitigation/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/attacks/__init__.py b/src/holisticai/security/attackers/attribute_inference/mitigation/attacks/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/attacks/white_box_lifestyle_decision_tree.py b/src/holisticai/security/attackers/attribute_inference/mitigation/attacks/white_box_lifestyle_decision_tree.py
deleted file mode 100644
index b572b7d2..00000000
--- a/src/holisticai/security/attackers/attribute_inference/mitigation/attacks/white_box_lifestyle_decision_tree.py
+++ /dev/null
@@ -1,128 +0,0 @@
-"""
-This module implements attribute inference attacks.
-"""
-
-from __future__ import annotations
-
-import logging
-from typing import Optional
-
-import numpy as np
-from holisticai.security.attackers.attribute_inference.attack import AttributeInferenceAttack
-from holisticai.security.attackers.attribute_inference.wrappers.classification.scikitlearn import (
-    ScikitlearnDecisionTreeClassifier,
-)
-from holisticai.security.attackers.attribute_inference.wrappers.regression.scikitlearn import (
-    ScikitlearnDecisionTreeRegressor,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class AttributeInferenceWhiteBoxLifestyleDecisionTree(AttributeInferenceAttack):
-    """
-    Implementation of Fredrikson et al. white box inference attack for decision trees.
-
-    Assumes that the attacked feature is discrete or categorical, with limited number of possible values. For example:
-    a boolean feature.
-
-    Parameters
-    ----------
-    estimator : object
-        Target estimator.
-    attack_feature : int
-        The index of the feature to be attacked.
-
-    References
-    ----------
-    .. [1] Fredrikson, M., Jha, S., & Ristenpart, T. (2015, August). Model inversion attacks that exploit confidence\\
-          information and basic countermeasures. In Proceedings of the 22nd ACM SIGSAC Conference on Computer and\\
-              Communications Security (pp. 1322-1333).
-
-    | Paper link: https://dl.acm.org/doi/10.1145/2810103.2813677
-    """
-
-    _estimator_requirements = ((ScikitlearnDecisionTreeClassifier, ScikitlearnDecisionTreeRegressor),)
-
-    def __init__(self, estimator, attack_feature: int = 0):
-        super().__init__(estimator=estimator, attack_feature=attack_feature)
-        self.attack_feature: int
-        self._check_params()
-
-    def infer(self, x: np.ndarray, **kwargs) -> np.ndarray:
-        """
-        Infer the attacked feature.
-
-        Parameters
-        ----------
-        x : np.ndarray
-            Input to attack. Includes all features except the attacked feature.
-        kwargs : dict
-            Possible values for attacked feature and prior distributions of attacked feature values.
-
-        Returns
-        -------
-        np.ndarray
-            The inferred feature values.
-        """
-        priors: Optional[list] = kwargs.get("priors")
-        values: Optional[list] = kwargs.get("values")
-
-        # Checks:
-        if self.estimator.input_shape[0] != x.shape[1] + 1:  # pragma: no cover
-            raise ValueError("Number of features in x + 1 does not match input_shape of classifier")
-        if priors is None or values is None:  # pragma: no cover
-            raise ValueError("`priors` and `values` are required as inputs.")
-        if len(priors) != len(values):  # pragma: no cover
-            raise ValueError("Number of priors does not match number of values")
-
-        n_samples = x.shape[0]
-
-        # Calculate phi for each possible value of the attacked feature
-        # phi is the total number of samples in all tree leaves corresponding to this value
-        phi = self._calculate_phi(x, values, n_samples)
-
-        # Will contain the probability of each value
-        prob_values = []
-
-        for i, value in enumerate(values):
-            # prepare data with the given value in the attacked feature
-            v_full = np.full((n_samples, 1), value).astype(x.dtype)
-            x_value = np.concatenate((x[:, : self.attack_feature], v_full), axis=1)
-            x_value = np.concatenate((x_value, x[:, self.attack_feature :]), axis=1)
-
-            # find the relative probability of this value for all samples being attacked
-            prob_value = [
-                (
-                    (self.estimator.get_samples_at_node(self.estimator.get_decision_path([row])[-1]) / n_samples)
-                    * priors[i]
-                    / phi[i]
-                )
-                for row in x_value
-            ]
-            prob_values.append(prob_value)
-
-        # Choose the value with highest probability for each sample
-        return np.array([values[np.argmax(list(prob))] for prob in zip(*prob_values)])
-
-    def _calculate_phi(self, x, values, n_samples):
-        phi = []
-        for value in values:
-            v_full = np.full((n_samples, 1), value).astype(x.dtype)
-            x_value = np.concatenate((x[:, : self.attack_feature], v_full), axis=1)
-            x_value = np.concatenate((x_value, x[:, self.attack_feature :]), axis=1)
-            nodes_value = {}
-
-            for row in x_value:
-                # get leaf ids (no duplicates)
-                node_id = self.estimator.get_decision_path([row])[-1]
-                nodes_value[node_id] = self.estimator.get_samples_at_node(node_id)
-            # sum sample numbers
-            num_value = sum(nodes_value.values()) / n_samples
-            phi.append(num_value)
-
-        return phi
-
-    def _check_params(self) -> None:
-        if self.attack_feature < 0:
-            raise ValueError("Attack feature must be positive.")
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/config.py b/src/holisticai/security/attackers/attribute_inference/mitigation/config.py
deleted file mode 100644
index e730d20f..00000000
--- a/src/holisticai/security/attackers/attribute_inference/mitigation/config.py
+++ /dev/null
@@ -1,25 +0,0 @@
-# MIT License
-#
-# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2018
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
-# Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
-# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-"""
-This module loads and provides configuration parameters for ART.
-"""
-
-import numpy as np
-
-ART_NUMPY_DTYPE = np.float32  # pylint: disable=C0103
-ART_DATA_PATH: str
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/defences/__init__.py b/src/holisticai/security/attackers/attribute_inference/mitigation/defences/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/defences/postprocessor/__init__.py b/src/holisticai/security/attackers/attribute_inference/mitigation/defences/postprocessor/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/defences/postprocessor/postprocessor.py b/src/holisticai/security/attackers/attribute_inference/mitigation/defences/postprocessor/postprocessor.py
deleted file mode 100644
index 3d41f2e9..00000000
--- a/src/holisticai/security/attackers/attribute_inference/mitigation/defences/postprocessor/postprocessor.py
+++ /dev/null
@@ -1,132 +0,0 @@
-# MIT License
-#
-# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2020
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
-# Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
-# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-"""
-This module implements the abstract base class for defences that post-process classifier output.
-"""
-
-from __future__ import annotations
-
-import abc
-
-import numpy as np
-
-
-class Postprocessor(abc.ABC):
-    """
-    Abstract base class for postprocessing defences. Postprocessing defences are not included in the loss function
-    evaluation for loss gradients or the calculation of class gradients.
-
-    Parameters
-    ----------
-    is_fitted : bool
-        Whether the postprocessor has already been fitted.
-    apply_fit : bool
-        Whether the postprocessor should be applied at training time.
-    apply_predict : bool
-        Whether the postprocessor should be applied at test time.
-    """
-
-    params: list[str] = []
-
-    def __init__(self, is_fitted: bool = False, apply_fit: bool = True, apply_predict: bool = True) -> None:
-        self._is_fitted = bool(is_fitted)
-        self._apply_fit = bool(apply_fit)
-        self._apply_predict = bool(apply_predict)
-        Postprocessor._check_params(self)
-
-    @property
-    def is_fitted(self) -> bool:
-        """
-        Return the state of the postprocessing object.
-
-        Returns
-        -------
-        bool
-            `True` if the postprocessing model has been fitted (if this applies).
-        """
-        return self._is_fitted
-
-    @property
-    def apply_fit(self) -> bool:
-        """
-        Property of the defence indicating if it should be applied at training time.
-
-        Returns
-        -------
-        bool
-            `True` if the defence should be applied when fitting a model, `False` otherwise.
-        """
-        return self._apply_fit
-
-    @property
-    def apply_predict(self) -> bool:
-        """
-        Property of the defence indicating if it should be applied at test time.
-
-        Returns
-        -------
-        bool
-            `True` if the defence should be applied at prediction time, `False` otherwise.
-        """
-        return self._apply_predict
-
-    @abc.abstractmethod
-    def __call__(self, preds: np.ndarray) -> np.ndarray:
-        """
-        Perform model postprocessing and return postprocessed output.
-
-        Parameters
-        ----------
-        preds : np.ndarray
-            Model output to be postprocessed.
-
-        Returns
-        -------
-        np.ndarray
-            Postprocessed model output.
-        """
-        raise NotImplementedError
-
-    def fit(self, preds: np.ndarray, **kwargs) -> None:
-        """
-        Fit the parameters of the postprocessor if it has any.
-
-        Parameters
-        ----------
-        preds : np.ndarray
-            Training set to fit the postprocessor.
-        kwargs
-            Other parameters.
-        """
-
-    def set_params(self, **kwargs) -> None:
-        """
-        Take in a dictionary of parameters and apply checks before saving them as attributes.
-
-        Parameters
-        ----------
-        kwargs
-            Dictionary of parameters to apply checks to.
-        """
-        for key, value in kwargs.items():
-            if key in self.params:
-                setattr(self, key, value)
-        self._check_params()
-
-    def _check_params(self) -> None:
-        pass
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/defences/preprocessor/__init__.py b/src/holisticai/security/attackers/attribute_inference/mitigation/defences/preprocessor/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/defences/preprocessor/preprocessor.py b/src/holisticai/security/attackers/attribute_inference/mitigation/defences/preprocessor/preprocessor.py
deleted file mode 100644
index 3d810cf1..00000000
--- a/src/holisticai/security/attackers/attribute_inference/mitigation/defences/preprocessor/preprocessor.py
+++ /dev/null
@@ -1,178 +0,0 @@
-# MIT License
-#
-# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2018
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
-# Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
-# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-"""
-This module implements the abstract base class for defences that pre-process input data.
-"""
-
-from __future__ import annotations
-
-import abc
-from typing import Any, Optional
-
-import numpy as np
-
-
-class Preprocessor(abc.ABC):
-    """
-    Abstract base class for preprocessing defences.
-
-    By default, the gradient is estimated using BPDA with the identity function.
-        To modify, override `estimate_gradient`
-
-    Parameters
-    ----------
-    is_fitted : bool
-        Whether the preprocessor has already been fitted.
-    apply_fit : bool
-        Whether the preprocessor should be applied at training time.
-    apply_predict : bool
-        Whether the preprocessor should be applied at test time.
-    """
-
-    params: list[str] = []
-
-    def __init__(self, is_fitted: bool = False, apply_fit: bool = True, apply_predict: bool = True) -> None:
-        self._is_fitted = bool(is_fitted)
-        self._apply_fit = bool(apply_fit)
-        self._apply_predict = bool(apply_predict)
-
-    @property
-    def is_fitted(self) -> bool:
-        """
-        Return the state of the preprocessing object.
-
-        Returns
-        -------
-        bool
-            `True` if the preprocessing model has been fitted (if this applies).
-        """
-        return self._is_fitted
-
-    @property
-    def apply_fit(self) -> bool:
-        """
-        Property of the defence indicating if it should be applied at training time.
-
-        Returns
-        -------
-        bool
-            `True` if the defence should be applied when fitting a model, `False` otherwise.
-        """
-        return self._apply_fit
-
-    @property
-    def apply_predict(self) -> bool:
-        """
-        Property of the defence indicating if it should be applied at test time.
-
-        Returns
-        -------
-        bool
-            `True` if the defence should be applied at prediction time, `False` otherwise.
-        """
-        return self._apply_predict
-
-    @abc.abstractmethod
-    def __call__(self, x: np.ndarray, y: Optional[np.ndarray] = None) -> tuple[np.ndarray, Optional[np.ndarray]]:
-        """
-        Perform data preprocessing and return preprocessed data as tuple.
-
-        Parameters
-        ----------
-        x : np.ndarray
-            Dataset to be preprocessed.
-        y : np.ndarray
-            Labels to be preprocessed.
-
-        Returns
-        -------
-        np.ndarray
-            Preprocessed data.
-        np.ndarray
-            Preprocessed labels.
-        """
-        raise NotImplementedError
-
-    def fit(self, x: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> None:
-        """
-        Fit the parameters of the data preprocessor if it has any.
-
-        Parameters
-        ----------
-        x : np.ndarray
-            Training set to fit the preprocessor.
-        y : np.ndarray
-            Labels for the training set.
-        kwargs
-            Other parameters.
-        """
-
-    def estimate_gradient(self, x: np.ndarray, grad: np.ndarray) -> np.ndarray:  # noqa: ARG002
-        """
-        Provide an estimate of the gradients of the defence for the backward pass. If the defence is not differentiable,
-        this is an estimate of the gradient, most often replacing the computation performed by the defence with the
-        identity function (the default).
-
-        Parameters
-        ----------
-        x : np.ndarray
-            Input data for which the gradient is estimated. First dimension is the batch size.
-        grad : np.ndarray
-            Gradient value so far.
-
-        Returns
-        -------
-        np.ndarray
-            The gradient (estimate) of the defence.
-        """
-        return grad
-
-    def set_params(self, **kwargs) -> None:  # pragma: no cover
-        """
-        Take in a dictionary of parameters and apply checks before saving them as attributes.
-
-        Parameters
-        ----------
-        kwargs
-            Dictionary of parameters to apply checks to.
-        """
-        for key, value in kwargs.items():
-            if key in self.params:
-                setattr(self, key, value)
-        self._check_params()
-
-    def _check_params(self) -> None:  # pragma: no cover
-        pass
-
-    def forward(self, x: Any, y: Any = None) -> tuple[Any, Any]:
-        """
-        Perform data preprocessing and return preprocessed data.
-
-        Parameters
-        ----------
-        x : Any
-            Dataset to be preprocessed.
-        y : Any
-            Labels to be preprocessed.
-
-        Returns
-        -------
-        Any
-            Preprocessed data.
-        """
-        raise NotImplementedError
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/__init__.py b/src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/preprocessing.py b/src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/preprocessing.py
deleted file mode 100644
index 6745a2e3..00000000
--- a/src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/preprocessing.py
+++ /dev/null
@@ -1,22 +0,0 @@
-# MIT License
-#
-# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2020
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
-# Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
-# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-"""
-This module contains the Preprocessor API.
-"""
-# pylint: disable=W0611
-# from holisticai.security.attackers.attribute_inference.mitigation.defences.preprocessor.preprocessor import Preprocessor
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/standardisation/__init__.py b/src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/standardisation/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/standardisation/numpy.py b/src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/standardisation/numpy.py
deleted file mode 100644
index baf6c3b0..00000000
--- a/src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/standardisation/numpy.py
+++ /dev/null
@@ -1,139 +0,0 @@
-# MIT License
-#
-# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2020
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
-# Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
-# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-"""
-This module implements the standardisation with mean and standard deviation.
-"""
-
-from __future__ import annotations
-
-import logging
-from typing import Optional, Union
-
-import numpy as np
-from holisticai.security.attackers.attribute_inference.mitigation.config import ART_NUMPY_DTYPE
-from holisticai.security.attackers.attribute_inference.mitigation.defences.preprocessor.preprocessor import Preprocessor
-from holisticai.security.attackers.attribute_inference.mitigation.preprocessing.standardisation.utils import (
-    broadcastable_mean_std,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class StandardisationMeanStd(Preprocessor):
-    """
-    Implement the standardisation with mean and standard deviation.
-
-    Parameters
-    ----------
-    mean : Union[float, np.ndarray]
-        Mean.
-    std : Union[float, np.ndarray]
-        Standard Deviation.
-    apply_fit : bool
-        Whether the preprocessor should be applied at training time.
-    apply_predict : bool
-        Whether the preprocessor should be applied at test time.
-    """
-
-    params = ["mean", "std", "apply_fit", "apply_predict"]
-
-    def __init__(
-        self,
-        mean: Union[float, np.ndarray] = 0.0,
-        std: Union[float, np.ndarray] = 1.0,
-        apply_fit: bool = True,
-        apply_predict: bool = True,
-    ):
-        super().__init__(is_fitted=True, apply_fit=apply_fit, apply_predict=apply_predict)
-        self.mean = np.asarray(mean, dtype=ART_NUMPY_DTYPE)
-        self.std = np.asarray(std, dtype=ART_NUMPY_DTYPE)
-        self._check_params()
-
-        # init broadcastable mean and std for lazy loading
-        self._broadcastable_mean: Optional[np.ndarray] = None
-        self._broadcastable_std: Optional[np.ndarray] = None
-
-    def __call__(
-        self,
-        x: np.ndarray,
-        y: Optional[np.ndarray] = None,
-    ) -> tuple[np.ndarray, Optional[np.ndarray]]:
-        """
-        Apply StandardisationMeanStd inputs `x`.
-
-        Parameters
-        ----------
-        x : np.ndarray
-            Input samples to standardise.
-        y : np.ndarray
-            Label data, will not be affected by this preprocessing.
-
-        Returns
-        -------
-        np.ndarray
-            Standardise input samples.
-        np.ndarray
-            Unmodified labels.
-        """
-        if x.dtype in [np.uint8, np.uint16, np.uint32, np.uint64]:  # pragma: no cover
-            raise TypeError(
-                f"The data type of input data `x` is {x.dtype} and cannot represent negative values. Consider "
-                f"changing the data type of the input data `x` to a type that supports negative values e.g. "
-                f"np.float32."
-            )
-
-        if self._broadcastable_mean is None:
-            self._broadcastable_mean, self._broadcastable_std = broadcastable_mean_std(x, self.mean, self.std)
-
-        x_norm = x - self._broadcastable_mean
-        x_norm = x_norm / self._broadcastable_std
-        x_norm = x_norm.astype(ART_NUMPY_DTYPE)
-
-        return x_norm, y
-
-    def estimate_gradient(self, x: np.ndarray, grad: np.ndarray) -> np.ndarray:
-        """
-        Provide an estimate of the gradients of preprocessor for the backward pass. If the preprocessor is not
-        differentiable, this is an estimate of the gradient, most often replacing the computation performed by the
-        preprocessor with the identity function (the default).
-
-        Parameters
-        ----------
-        x : np.ndarray
-            Input data for which the gradient is estimated. First dimension is the batch size.
-        grad : np.ndarray
-            Gradient value so far.
-
-        Returns
-        -------
-        np.ndarray
-            The gradient (estimate) of the defence.
-        """
-        _, std = broadcastable_mean_std(x, self.mean, self.std)
-        gradient_back = grad / std
-
-        return gradient_back
-
-    def _check_params(self) -> None:
-        pass
-
-    def __repr__(self):
-        return (
-            f"StandardisationMeanStd(mean={self.mean}, std={self.std}, apply_fit={self.apply_fit}, "
-            f"apply_predict={self.apply_predict})"
-        )
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/standardisation/utils.py b/src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/standardisation/utils.py
deleted file mode 100644
index 9080eda2..00000000
--- a/src/holisticai/security/attackers/attribute_inference/mitigation/preprocessing/standardisation/utils.py
+++ /dev/null
@@ -1,53 +0,0 @@
-# MIT License
-#
-# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2021
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
-# Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
-# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-"""
-This module implements utilities for standardisation with mean and standard deviation.
-"""
-
-from __future__ import annotations
-
-import numpy as np
-
-
-def broadcastable_mean_std(x: np.ndarray, mean: np.ndarray, std: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
-    """
-    Ensure that the mean and standard deviation are broadcastable with respect to input `x`.
-
-    Parameters
-    ----------
-    x : np.ndarray
-        Input samples to standardise.
-    mean : np.ndarray
-        Mean.
-    std : np.ndarray
-        Standard Deviation.
-    """
-    if mean.shape != std.shape:  # pragma: no cover
-        raise ValueError("The shape of mean and the standard deviation must be identical.")
-
-    # catch non-broadcastable input, when mean and std are vectors
-    if mean.ndim == 1 and mean.shape[0] > 1 and mean.shape[0] != x.shape[-1]:
-        # allow input shapes NC* (batch) and C* (non-batch)
-        channel_idx = 1 if x.shape[1] == mean.shape[0] else 0
-        broadcastable_shape = [1] * x.ndim
-        broadcastable_shape[channel_idx] = mean.shape[0]
-
-        # expand mean and std to new shape
-        mean = mean.reshape(broadcastable_shape)
-        std = std.reshape(broadcastable_shape)
-    return mean, std
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/scikitlearn.py b/src/holisticai/security/attackers/attribute_inference/mitigation/scikitlearn.py
deleted file mode 100644
index 601415ee..00000000
--- a/src/holisticai/security/attackers/attribute_inference/mitigation/scikitlearn.py
+++ /dev/null
@@ -1,140 +0,0 @@
-"""
-This module implements attribute inference attacks.
-"""
-
-from __future__ import annotations
-
-import logging
-from typing import Optional
-
-import numpy as np
-from holisticai.security.attackers.attribute_inference.attack import AttributeInferenceAttack
-from holisticai.security.attackers.attribute_inference.wrappers.classification.scikitlearn import (
-    ScikitlearnDecisionTreeClassifier,
-)
-
-logger = logging.getLogger(__name__)
-
-
-class AttributeInferenceWhiteBoxDecisionTree(AttributeInferenceAttack):
-    """
-    A variation of the method proposed by of Fredrikson et al. in:
-    https://dl.acm.org/doi/10.1145/2810103.2813677
-
-    Assumes the availability of the attacked model's predictions for the samples under attack, in addition to access to
-    the model itself and the rest of the feature values. If this is not available, the true class label of the samples
-    may be used as a proxy. Also assumes that the attacked feature is discrete or categorical, with limited number of
-    possible values. For example: a boolean feature.
-
-    Parameters
-    ----------
-    classifier : ScikitlearnDecisionTreeClassifier
-        Target classifier.
-    attack_feature : int
-        The index of the feature to be attacked.
-
-    References
-    ----------
-    .. [1] Fredrikson, M., Jha, S., & Ristenpart, T. (2015, August). Model inversion attacks that exploit confidence
-           information and basic countermeasures. In Proceedings of the 22nd ACM SIGSAC Conference on Computer and
-           Communications Security (pp. 1322-1333).
-    """
-
-    _estimator_requirements = (ScikitlearnDecisionTreeClassifier,)
-
-    # def __init__(self, classifier: ScikitlearnDecisionTreeClassifier, attack_feature: int = 0):
-    def __init__(self, classifier, attack_feature: int = 0):
-        super().__init__(estimator=classifier, attack_feature=attack_feature)
-        self.attack_feature: int
-        self._check_params()
-
-    def infer(self, x: np.ndarray, y: np.ndarray, **kwargs) -> np.ndarray:
-        """
-        Infer the attacked feature.
-
-        If the model's prediction coincides with the real prediction for the sample for a single value, choose it as the
-        predicted value. If not, fall back to the Fredrikson method (without phi)
-
-        Parameters
-        ----------
-        x : np.ndarray
-            Input to attack. Includes all features except the attacked feature.
-        y : np.ndarray
-            Original model's predictions for x.
-        values : list
-            Possible values for attacked feature.
-        priors : list
-            Prior distributions of attacked feature values. Same size array as `values`.
-
-        Returns
-        -------
-        np.ndarray
-            The inferred feature values.
-        """
-        if "priors" not in kwargs:  # pragma: no cover
-            raise ValueError("Missing parameter `priors`.")
-        if "values" not in kwargs:  # pragma: no cover
-            raise ValueError("Missing parameter `values`.")
-        priors: Optional[list] = kwargs.get("priors")
-        values: Optional[list] = kwargs.get("values")
-
-        if priors is None or values is None:  # pragma: no cover
-            raise ValueError("`priors` and `values` are required as inputs.")
-        if len(priors) != len(values):  # pragma: no cover
-            raise ValueError("Number of priors does not match number of values")
-
-        n_values = len(values)
-        n_samples = x.shape[0]
-
-        # Will contain the model's predictions for each value
-        pred_values = []
-        # Will contain the probability of each value
-        prob_values = []
-
-        for i, value in enumerate(values):
-            # prepare data with the given value in the attacked feature
-            v_full = np.full((n_samples, 1), value).astype(x.dtype)
-            x_value = np.concatenate((x[:, : self.attack_feature], v_full), axis=1)
-            x_value = np.concatenate((x_value, x[:, self.attack_feature :]), axis=1)
-
-            # Obtain the model's prediction for each possible value of the attacked feature
-            pred_value = [np.argmax(arr) for arr in self.estimator.predict_proba(x_value)]
-            pred_values.append(pred_value)
-
-            # find the relative probability of this value for all samples being attacked
-            prob_value = [
-                (
-                    (self.estimator.get_samples_at_node(self.estimator.get_decision_path([row])[-1]) / n_samples)
-                    * priors[i]
-                )
-                for row in x_value
-            ]
-            prob_values.append(prob_value)
-
-        # Find the single value that coincides with the real prediction for the sample (if it exists)
-        pred_rows = zip(*pred_values)
-        predicted_pred = []
-        for row_index, row in enumerate(pred_rows):
-            if y is not None:
-                matches = [1 if row[value_index] == y[row_index] else 0 for value_index in range(n_values)]
-                match_values = [
-                    values[value_index] if row[value_index] == y[row_index] else 0 for value_index in range(n_values)
-                ]
-            else:
-                matches = [0 for _ in range(n_values)]
-                match_values = [0 for _ in range(n_values)]
-            predicted_pred.append(sum(match_values) if sum(matches) == 1 else None)
-
-        # Choose the value with highest probability for each sample
-        predicted_prob = [np.argmax(list(prob)) for prob in zip(*prob_values)]
-
-        return np.array(
-            [
-                value if value is not None else values[predicted_prob[index]]
-                for index, value in enumerate(predicted_pred)
-            ]
-        )
-
-    def _check_params(self) -> None:
-        if self.attack_feature < 0:
-            raise ValueError("Attack feature must be positive.")
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/utils/__init__.py b/src/holisticai/security/attackers/attribute_inference/mitigation/utils/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/utils/exceptions.py b/src/holisticai/security/attackers/attribute_inference/mitigation/utils/exceptions.py
deleted file mode 100644
index 34568691..00000000
--- a/src/holisticai/security/attackers/attribute_inference/mitigation/utils/exceptions.py
+++ /dev/null
@@ -1,68 +0,0 @@
-# MIT License
-#
-# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2018
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
-# Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
-# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-"""
-Module containing ART's exceptions.
-"""
-
-from __future__ import annotations
-
-from typing import Union
-
-
-class EstimatorError(TypeError):
-    """
-    Basic exception for errors raised by unexpected estimator types.
-
-    Parameters
-    ----------
-    this_class : type
-        The class that raised the error.
-    class_expected_list : list[type]
-        The list of expected classes.
-    classifier_given : object
-        The classifier that was given.
-    """
-
-    def __init__(self, this_class, class_expected_list: list[Union[type, tuple[type]]], classifier_given) -> None:
-        super().__init__()
-        self.this_class = this_class
-        self.class_expected_list = class_expected_list
-        self.classifier_given = classifier_given
-
-        classes_expected_message = ""
-        for idx, class_expected in enumerate(class_expected_list):
-            if idx != 0:
-                classes_expected_message += " and "
-            if isinstance(class_expected, type):
-                classes_expected_message += f"{class_expected}"
-            else:
-                classes_expected_message += "("
-                for or_idx, or_class in enumerate(class_expected):
-                    if or_idx != 0:
-                        classes_expected_message += " or "
-                    classes_expected_message += f"{or_class}"
-                classes_expected_message += ")"
-
-        self.message = (
-            f"{this_class.__name__} requires an estimator derived from {classes_expected_message}, "
-            f"the provided classifier is an instance of {type(classifier_given)} "
-            f"and is derived from {classifier_given.__class__.__bases__}."
-        )
-
-    def __str__(self) -> str:
-        return self.message
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/utils/formatting.py b/src/holisticai/security/attackers/attribute_inference/mitigation/utils/formatting.py
deleted file mode 100644
index 67be3d32..00000000
--- a/src/holisticai/security/attackers/attribute_inference/mitigation/utils/formatting.py
+++ /dev/null
@@ -1,50 +0,0 @@
-# # MIT License
-# #
-# # Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2018
-# #
-# # Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-# # documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
-# # rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
-# # persons to whom the Software is furnished to do so, subject to the following conditions:
-# #
-# # The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
-# # Software.
-# #
-# # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
-# # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-# # TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# # SOFTWARE.
-# """
-# Module providing convenience functions.
-# """
-
-from __future__ import annotations
-
-from typing import Optional, Union
-
-import numpy as np
-
-
-def to_categorical(labels: Union[np.ndarray, list[float]], nb_classes: Optional[int] = None) -> np.ndarray:
-    """
-    Convert an array of labels to binary class matrix.
-
-    Parameters
-    ----------
-    labels : Union[np.ndarray, list[float]]
-        An array of integer labels of shape `(nb_samples,)`.
-    nb_classes : Optional[int]
-        The number of classes (possible labels).
-
-    Returns
-    -------
-    np.ndarray
-        A binary matrix representation of `y` in the shape `(nb_samples, nb_classes)`.
-    """
-    labels = np.array(labels, dtype=int)
-    if nb_classes is None:
-        nb_classes = np.max(labels) + 1
-    categorical = np.zeros((labels.shape[0], nb_classes), dtype=np.float32)
-    categorical[np.arange(labels.shape[0]), np.squeeze(labels)] = 1
-    return categorical
diff --git a/src/holisticai/security/attackers/attribute_inference/mitigation/verification_decisions_trees.py b/src/holisticai/security/attackers/attribute_inference/mitigation/verification_decisions_trees.py
deleted file mode 100644
index 05fd7f72..00000000
--- a/src/holisticai/security/attackers/attribute_inference/mitigation/verification_decisions_trees.py
+++ /dev/null
@@ -1,152 +0,0 @@
-# MIT License
-#
-# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2018
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
-# Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
-# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-"""
-This module implements robustness verifications for decision-tree-based models.
-"""
-# from __future__ import absolute_import, division, print_function, unicode_literals
-
-from __future__ import annotations
-
-from typing import Optional
-
-
-class Interval:
-    """
-    Representation of an intervals bound.
-    """
-
-    def __init__(self, lower_bound: float, upper_bound: float) -> None:
-        """
-        An interval of a feature.
-
-        :param lower_bound: The lower boundary of the feature.
-        :param upper_bound: The upper boundary of the feature.
-        """
-        self.lower_bound = lower_bound
-        self.upper_bound = upper_bound
-
-
-class Box:
-    """
-    Representation of a box of intervals bounds.
-    """
-
-    def __init__(self, intervals: Optional[dict[int, Interval]] = None) -> None:
-        """
-        A box of intervals.
-
-        :param intervals: A dictionary of intervals with features as keys.
-        """
-        if intervals is None:
-            self.intervals = {}
-        else:
-            self.intervals = intervals
-
-    def intersect_with_box(self, box: Box) -> None:
-        """
-        Get the intersection of two interval boxes. This function modifies this box instance.
-
-        :param box: Interval box to intersect with this box.
-        """
-        for key, value in box.intervals.items():
-            if key not in self.intervals:
-                self.intervals[key] = value
-            else:
-                lower_bound = max(self.intervals[key].lower_bound, value.lower_bound)
-                upper_bound = min(self.intervals[key].upper_bound, value.upper_bound)
-
-                if lower_bound >= upper_bound:  # pragma: no cover
-                    self.intervals.clear()
-                    break
-
-                self.intervals[key] = Interval(lower_bound, upper_bound)
-
-    def get_intersection(self, box: Box) -> Box:
-        """
-        Get the intersection of two interval boxes. This function creates a new box instance.
-
-        :param box: Interval box to intersect with this box.
-        """
-        box_new = Box(intervals=self.intervals.copy())
-
-        for key, value in box.intervals.items():
-            if key not in box_new.intervals:
-                box_new.intervals[key] = value
-            else:
-                lower_bound = max(box_new.intervals[key].lower_bound, value.lower_bound)
-                upper_bound = min(box_new.intervals[key].upper_bound, value.upper_bound)
-
-                if lower_bound >= upper_bound:
-                    box_new.intervals.clear()
-                    return box_new
-
-                box_new.intervals[key] = Interval(lower_bound, upper_bound)
-
-        return box_new
-
-    def __repr__(self):
-        return self.__class__.__name__ + f"({self.intervals})"
-
-
-class LeafNode:
-    """
-    Representation of a leaf node of a decision tree.
-    """
-
-    def __init__(
-        self,
-        tree_id: Optional[int],
-        class_label: int,
-        node_id: Optional[int],
-        box: Box,
-        value: float,
-    ) -> None:
-        """
-        Create a leaf node representation.
-
-        :param tree_id: ID of the decision tree.
-        :param class_label: ID of class to which this leaf node is contributing.
-        :param box: A box representing the n_feature-dimensional bounding intervals that reach this leaf node.
-        :param value: Prediction value at this leaf node.
-        """
-        self.tree_id = tree_id
-        self.class_label = class_label
-        self.node_id = node_id
-        self.box = box
-        self.value = value
-
-    def __repr__(self):
-        return (
-            self.__class__.__name__ + f"({self.tree_id}, {self.class_label}, {self.node_id}, {self.box}, {self.value})"
-        )
-
-
-class Tree:
-    """
-    Representation of a decision tree.
-    """
-
-    def __init__(self, class_id: Optional[int], leaf_nodes: list[LeafNode]) -> None:
-        """
-        Create a decision tree representation.
-
-        :param class_id: ID of the class to which this decision tree contributes.
-        :param leaf_nodes: A list of leaf nodes of this decision tree.
-        """
-        self.class_id = class_id
-        self.leaf_nodes = leaf_nodes
diff --git a/src/holisticai/security/attackers/attribute_inference/wrappers/__init__.py b/src/holisticai/security/attackers/attribute_inference/wrappers/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/holisticai/security/attackers/attribute_inference/wrappers/classification/__init__.py b/src/holisticai/security/attackers/attribute_inference/wrappers/classification/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/holisticai/security/attackers/attribute_inference/wrappers/classification/classifier.py b/src/holisticai/security/attackers/attribute_inference/wrappers/classification/classifier.py
deleted file mode 100644
index af70174a..00000000
--- a/src/holisticai/security/attackers/attribute_inference/wrappers/classification/classifier.py
+++ /dev/null
@@ -1,254 +0,0 @@
-# MIT License
-#
-# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2018
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
-# Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
-# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-"""
-This module implements mixin abstract base classes defining properties for all classifiers in ART.
-"""
-
-from __future__ import annotations
-
-from abc import ABC, ABCMeta, abstractmethod
-from typing import Optional, Union
-
-import numpy as np
-from holisticai.security.attackers.attribute_inference.wrappers.estimator import (
-    BaseEstimator,
-    DecisionTreeMixin,
-    LossGradientsMixin,
-)
-
-
-class InputFilter(ABCMeta):
-    """
-    Metaclass to ensure that inputs are ndarray for all of the subclass generate and extract calls.
-
-    This metaclass is used to ensure that the input to all generate and extract methods is an ndarray. This is
-    necessary because the input to these methods is often a list or a pandas DataFrame, and the methods themselves
-    are not always implemented to handle these types of inputs. This metaclass overrides the generate and extract
-    methods with new methods that ensure the input is an ndarray.
-
-    Parameters
-    ----------
-    name : str
-        The name of the class.
-    bases : tuple
-        The base classes of the class.
-    clsdict : dict
-        The class dictionary.
-    """
-
-    def __init__(cls, name, bases, clsdict):  # noqa: ARG003
-        def make_replacement(fdict, func_name, has_y):
-            """
-            This function overrides creates replacement functions dynamically.
-
-            Parameters
-            ----------
-            fdict : dict
-                The class dictionary.
-            func_name : str
-                The name of the function to override.
-            has_y : bool
-                Whether the function has a y parameter.
-
-            Returns
-            -------
-            replacement_function : function
-                The replacement function.
-            """
-
-            def replacement_function(self, *args, **kwargs):
-                """
-                Replacement function.
-
-                Parameters
-                ----------
-                self : object
-                    The object.
-                args : list
-                    The arguments.
-                kwargs : dict
-                    The keyword arguments.
-
-                Returns
-                -------
-                result : object
-                    The result.
-                """
-                if len(args) > 0:
-                    lst = list(args)
-
-                if "X" in kwargs:
-                    if not isinstance(kwargs["X"], np.ndarray):
-                        np.array(kwargs["X"])
-                    kwargs["x"] = kwargs["X"].copy()
-                    del kwargs["X"]
-
-                elif "x" in kwargs:  # pragma: no cover
-                    if not isinstance(kwargs["x"], np.ndarray):
-                        kwargs["x"] = np.array(kwargs["x"])
-                elif not isinstance(args[0], np.ndarray):
-                    lst[0] = np.array(args[0])
-
-                if "y" in kwargs:  # pragma: no cover
-                    if kwargs["y"] is not None and not isinstance(kwargs["y"], np.ndarray):
-                        kwargs["y"] = np.array(kwargs["y"])
-                elif has_y:  # pragma: no cover  # noqa: SIM102
-                    if not isinstance(args[1], np.ndarray):
-                        lst[1] = np.array(args[1])
-
-                if len(args) > 0:
-                    args = tuple(lst)
-                return fdict[func_name](self, *args, **kwargs)
-
-            replacement_function.__doc__ = fdict[func_name].__doc__
-            replacement_function.__name__ = "new_" + func_name
-            return replacement_function
-
-        replacement_list_no_y = ["predict"]
-        replacement_list_has_y = ["fit"]
-
-        for item in replacement_list_no_y:
-            if item in clsdict:
-                new_function = make_replacement(clsdict, item, False)
-                setattr(cls, item, new_function)
-        for item in replacement_list_has_y:
-            if item in clsdict:
-                new_function = make_replacement(clsdict, item, True)
-                setattr(cls, item, new_function)
-
-
-class ClassifierMixin(ABC, metaclass=InputFilter):
-    """
-    Mixin abstract base class defining functionality for classifiers.
-
-    This abstract base class defines the properties of a classifier and provides functionality to set and get the number
-    of classes in the data. It also provides an interface to clone the classifier for refitting.
-
-    Parameters
-    ----------
-    nb_classes : int
-        The number of output classes.
-    """
-
-    estimator_params = ["nb_classes"]
-
-    def __init__(self, **kwargs) -> None:
-        super().__init__(**kwargs)  # type: ignore
-        self._nb_classes: int = -1
-
-    @property
-    def nb_classes(self) -> int:
-        """
-        Return the number of output classes.
-
-        Returns
-        -------
-        nb_classes : int
-            Number of classes in the data.
-        """
-        return self._nb_classes  # type: ignore
-
-    @nb_classes.setter
-    def nb_classes(self, nb_classes: int):
-        """
-        Set the number of output classes.
-
-        Parameters
-        ----------
-        nb_classes : int
-            Number of classes in the data.
-
-        Raises
-        ------
-        ValueError
-            If `nb_classes` is less than 2.
-        """
-        if nb_classes is None or nb_classes < 2:
-            raise ValueError("nb_classes must be greater than or equal to 2.")
-
-        self._nb_classes = nb_classes
-
-    def clone_for_refitting(self):
-        """
-        Clone classifier for refitting.
-        """
-        raise NotImplementedError
-
-
-class ClassGradientsMixin(ABC):
-    """
-    Mixin abstract base class defining classifiers providing access to class gradients. A classifier of this type can
-    be combined with certain white-box attacks. This mixin abstract base class has to be mixed in with
-    class `Classifier`.
-    """
-
-    @abstractmethod
-    def class_gradient(self, x: np.ndarray, label: Optional[Union[int, list[int]]] = None, **kwargs) -> np.ndarray:
-        """
-        Compute per-class derivatives w.r.t. `x`.
-
-        Parameters
-        ----------
-        x : np.ndarray
-            Samples.
-        label : int, list of int, or None
-            Index of a specific per-class derivative. If an integer is provided, the gradient of that class output is
-            computed for all samples. If multiple values as provided, the first dimension should match the batch size of
-            `x`, and each value will be used as target for its corresponding sample in `x`. If `None`, then gradients
-            for all classes will be computed for each sample.
-
-        Returns
-        -------
-        np.ndarray
-            Gradients of input features w.r.t. each class in the form `(batch_size, nb_classes, input_shape)` when
-            computing for all classes, otherwise shape becomes `(batch_size, 1, input_shape)` when `label` parameter is
-            specified.
-        """
-        raise NotImplementedError
-
-
-class Classifier(ClassifierMixin, BaseEstimator, ABC):
-    """
-    Typing variable definition.
-    """
-
-    estimator_params = BaseEstimator.estimator_params + ClassifierMixin.estimator_params
-
-
-class ClassifierLossGradients(ClassifierMixin, LossGradientsMixin, BaseEstimator, ABC):
-    """
-    Typing variable definition.
-    """
-
-    estimator_params = BaseEstimator.estimator_params + ClassifierMixin.estimator_params
-
-
-class ClassifierClassLossGradients(ClassGradientsMixin, ClassifierMixin, LossGradientsMixin, BaseEstimator, ABC):
-    """
-    Typing variable definition.
-    """
-
-    estimator_params = BaseEstimator.estimator_params + ClassifierMixin.estimator_params
-
-
-class ClassifierDecisionTree(DecisionTreeMixin, ClassifierMixin, BaseEstimator, ABC):
-    """
-    Typing variable definition.
-    """
-
-    estimator_params = BaseEstimator.estimator_params + ClassifierMixin.estimator_params
diff --git a/src/holisticai/security/attackers/attribute_inference/wrappers/classification/scikitlearn.py b/src/holisticai/security/attackers/attribute_inference/wrappers/classification/scikitlearn.py
deleted file mode 100644
index c93fdadf..00000000
--- a/src/holisticai/security/attackers/attribute_inference/wrappers/classification/scikitlearn.py
+++ /dev/null
@@ -1,1627 +0,0 @@
-# MIT License
-#
-# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2018
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
-# Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
-# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-"""
-This module implements the classifiers for scikit-learn models.
-"""
-
-from __future__ import annotations
-
-import importlib
-import logging
-import os
-import pickle
-from copy import deepcopy
-from typing import Callable, Optional, Union
-
-import numpy as np
-from holisticai.security.attackers.attribute_inference.mitigation import config
-from holisticai.security.attackers.attribute_inference.mitigation.utils.formatting import to_categorical
-from holisticai.security.attackers.attribute_inference.wrappers.classification.classifier import (
-    ClassGradientsMixin,
-    ClassifierMixin,
-)
-from holisticai.security.attackers.attribute_inference.wrappers.estimator import DecisionTreeMixin, LossGradientsMixin
-from holisticai.security.attackers.attribute_inference.wrappers.regression.scikitlearn import (
-    ScikitlearnDecisionTreeRegressor,
-)
-from holisticai.security.attackers.attribute_inference.wrappers.scikitlearn import ScikitlearnEstimator
-
-logger = logging.getLogger(__name__)
-
-
-def SklearnClassifier(  # noqa: N802
-    model,
-    clip_values=None,
-    preprocessing_defences=None,
-    postprocessing_defences=None,
-    preprocessing=(0.0, 1.0),
-    use_logits: bool = False,
-):
-    """
-    Create a `Classifier` instance from a scikit-learn Classifier model. This is a convenience function that
-    instantiates the correct class for the given scikit-learn model.
-
-    Parameters
-    ----------
-    model : scikit-learn Classifier model
-        The scikit-learn Classifier model.
-    clip_values : tuple
-        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
-    preprocessing_defences : `Preprocessor` or `list`
-        Preprocessing defence(s) to be applied by the classifier.
-    postprocessing_defences : `Postprocessor` or `list`
-        Postprocessing defence(s) to be applied by the classifier.
-    preprocessing : tuple
-        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data
-        preprocessing. The first value will be subtracted from the input. The input will then be divided by the
-        second one.
-
-    Returns
-    -------
-    Classifier
-        The `Classifier` instance.
-    """
-    if model.__class__.__module__.split(".")[0] != "sklearn":  # pragma: no cover
-        raise TypeError(f"Model is not an sklearn model. Received '{model.__class__}'")
-
-    sklearn_name = model.__class__.__name__
-    module = importlib.import_module(
-        "holisticai.security.attackers.attribute_inference.wrappers.classification.scikitlearn"
-    )
-    if hasattr(module, f"Scikitlearn{sklearn_name}"):
-        return getattr(module, f"Scikitlearn{sklearn_name}")(
-            model=model,
-            clip_values=clip_values,
-            preprocessing_defences=preprocessing_defences,
-            postprocessing_defences=postprocessing_defences,
-            preprocessing=preprocessing,
-        )
-
-    # This basic class at least generically handles `fit`, `predict` and `save`
-    return ScikitlearnClassifier(
-        model,
-        clip_values,
-        preprocessing_defences,
-        postprocessing_defences,
-        preprocessing,
-        use_logits,
-    )
-
-
-class ScikitlearnClassifier(ClassifierMixin, ScikitlearnEstimator):  # lgtm [py/missing-call-to-init]
-    """
-    Class for scikit-learn classifier models. Create a `Classifier` instance from a scikit-learn classifier model.
-
-    Parameters
-    ----------
-    model : scikit-learn classifier model
-        The scikit-learn classifier model.
-    clip_values : tuple
-        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
-    preprocessing_defences : `Preprocessor` or `list`
-        Preprocessing defence(s) to be applied by the classifier.
-    postprocessing_defences : `Postprocessor` or `list`
-        Postprocessing defence(s) to be applied by the classifier.
-    preprocessing : tuple
-        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data
-        preprocessing. The first value will be subtracted from the input. The input will then be divided by the
-        second one.
-    use_logits : bool
-        Determines whether predict() returns logits instead of probabilities if available. Some adversarial attacks
-        (DeepFool) may perform better if logits are used.
-    """
-
-    estimator_params = ClassifierMixin.estimator_params + ScikitlearnEstimator.estimator_params + ["use_logits"]
-
-    def __init__(
-        self,
-        model,
-        clip_values=None,
-        preprocessing_defences=None,
-        postprocessing_defences=None,
-        preprocessing=(0.0, 1.0),
-        use_logits: bool = False,
-    ) -> None:
-        super().__init__(
-            model=model,
-            clip_values=clip_values,
-            preprocessing_defences=preprocessing_defences,
-            postprocessing_defences=postprocessing_defences,
-            preprocessing=preprocessing,
-        )
-        self._input_shape = self._get_input_shape(model)
-        nb_classes = self._get_nb_classes()
-        if nb_classes is not None:
-            self.nb_classes = nb_classes
-        self._use_logits = use_logits
-
-    @property
-    def input_shape(self) -> tuple[int, ...]:
-        """
-        Return the shape of one input sample.
-
-        Returns
-        -------
-        tuple
-            Shape of one input sample.
-        """
-        return self._input_shape  # type: ignore
-
-    @property
-    def use_logits(self) -> bool:
-        """
-        Return the Boolean for using logits.
-
-        Returns
-        -------
-        bool
-            Boolean for using logits.
-        """
-        return self._use_logits  # type: ignore
-
-    def fit(self, x: np.ndarray, y: np.ndarray, **kwargs) -> None:
-        """
-        Fit the classifier on the training set `(x, y)`.
-
-        Parameters
-        ----------
-        x : `np.ndarray`
-            Training data.
-        y : `np.ndarray`
-            Target values (class labels) one-hot-encoded of shape `(nb_samples, nb_classes)`.
-        kwargs : `dict`
-            Dictionary of framework-specific arguments. These should be parameters supported by the `fit` function in
-            `sklearn` classifier and will be passed to this function as such.
-        """
-        # Apply preprocessing
-        x_preprocessed, y_preprocessed = self._apply_preprocessing(x, y, fit=True)
-
-        self.model.fit(x_preprocessed, y_preprocessed, **kwargs)
-        self._input_shape = self._get_input_shape(self.model)
-        self.nb_classes = self._get_nb_classes()
-
-    def predict_proba(self, x: np.ndarray, **kwargs) -> np.ndarray:  # noqa: ARG002
-        """
-        Perform prediction for a batch of inputs.
-
-        Parameters
-        ----------
-        x : `np.ndarray`
-            Input samples.
-        kwargs : `dict`
-            Dictionary of framework-specific arguments. These should be parameters supported by the `predict_proba`
-            function in `sklearn` classifier and will be passed to this function as such.
-
-        Raises
-        ------
-        ValueError
-            If the model does not have methods `predict_proba` or `predict`.
-
-        Returns
-        -------
-        `np.ndarray`
-            Array of predictions of shape `(nb_inputs, nb_classes)`.
-        """
-        # Apply defences
-        x_preprocessed, _ = self._apply_preprocessing(x, y=None, fit=False)
-
-        if self._use_logits:
-            if callable(getattr(self.model, "predict_log_proba", None)):
-                y_pred = self.model.predict_log_proba(x_preprocessed)
-            else:  # pragma: no cover
-                logger.warning(
-                    "use_logits was True but classifier did not have callable predict_log_proba member. Falling back to"
-                    " probabilities"
-                )
-        elif callable(getattr(self.model, "predict_proba", None)):
-            y_pred = self.model.predict_proba(x_preprocessed)
-        elif callable(getattr(self.model, "predict", None)):
-            y_pred = to_categorical(
-                self.model.predict(x_preprocessed),
-                nb_classes=self.model.classes_.shape[0],
-            )
-        else:  # pragma: no cover
-            raise ValueError("The provided model does not have methods `predict_proba` or `predict`.")
-
-        # Apply postprocessing
-        predictions = self._apply_postprocessing(preds=y_pred, fit=False)
-
-        return predictions
-
-    def predict(self, x: np.ndarray, **kwargs) -> np.ndarray:
-        """
-        Perform prediction for a batch of inputs.
-
-        Parameters
-        ----------
-        x : `np.ndarray`
-            Input samples.
-        kwargs : `dict`
-            Dictionary of framework-specific arguments. These should be parameters supported by the `predict` function in
-            `sklearn` classifier and will be passed to this function as such.
-
-        Returns
-        -------
-        `np.ndarray`
-            Array of predictions of shape `(nb_inputs, nb_classes)`.
-        """
-        predictions = self.predict_proba(x=x, **kwargs)
-        predictions = np.argmax(predictions, axis=1)
-        return predictions
-
-    def save(self, filename: str, path: Optional[str] = None) -> None:
-        """
-        Save a model to file in the format specific to the backend framework.
-
-        Parameters
-        ----------
-        filename : str
-            Name of the file where to store the model.
-        path : str, optional
-            Path of the folder where to store the model. If no path is specified, the model will be stored in the default
-            data location of the library `ART_DATA_PATH`.
-        """
-        full_path = os.path.join(config.ART_DATA_PATH, filename) if path is None else os.path.join(path, filename)
-        folder = os.path.split(full_path)[0]
-        if not os.path.exists(folder):  # pragma: no cover
-            os.makedirs(folder)
-
-        with open(full_path + ".pickle", "wb") as file_pickle:
-            pickle.dump(self.model, file=file_pickle)
-
-    def clone_for_refitting(self):
-        """
-        Create a copy of the classifier that can be refit from scratch.
-
-        Returns
-        -------
-        `Classifier`
-            New estimator.
-        """
-        import sklearn  # lgtm [py/repeated-import]
-
-        clone = type(self)(sklearn.base.clone(self.model))
-        params = self.get_params()
-        del params["model"]
-        clone.set_params(**params)
-        return clone
-
-    def reset(self) -> None:
-        """
-        Resets the weights of the classifier so that it can be refit from scratch.
-
-        """
-        # No need to do anything since scikitlearn models start from scratch each time fit() is called
-
-    def _get_nb_classes(self) -> int:
-        if hasattr(self.model, "n_classes_"):
-            _nb_classes = self.model.n_classes_
-        elif hasattr(self.model, "classes_"):
-            _nb_classes = self.model.classes_.shape[0]
-        elif hasattr(self.model, "steps"):
-            _nb_classes = self.model.steps[-1][1].obj.nb_classes
-        else:
-            logger.warning("Number of classes not recognised. The model might not have been fitted.")
-            _nb_classes = None
-        return _nb_classes
-
-
-class ScikitlearnDecisionTreeClassifier(ScikitlearnClassifier):
-    """
-    Create a `Classifier` instance from a scikit-learn Decision Tree Classifier model.
-
-    Parameters
-    ----------
-    model : scikit-learn Decision Tree Classifier model
-        The scikit-learn Decision Tree Classifier model.
-    clip_values : tuple
-        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
-    preprocessing_defences : `Preprocessor` or `list`
-        Preprocessing defence(s) to be applied by the classifier.
-    postprocessing_defences : `Postprocessor` or `list`
-        Postprocessing defence(s) to be applied by the classifier.
-    preprocessing : tuple
-        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data
-        preprocessing. The first value will be subtracted from the input. The input will then be divided by the
-        second one.
-    """
-
-    def __init__(
-        self,
-        model,
-        clip_values=None,
-        preprocessing_defences=None,
-        postprocessing_defences=None,
-        preprocessing=(0.0, 1.0),
-    ) -> None:
-        import sklearn  # lgtm [py/repeated-import]
-        from holisticai.pipeline import Pipeline
-
-        if isinstance(model, Pipeline):
-            if not isinstance(model.estimator_hdl.estimator, sklearn.tree.DecisionTreeClassifier) and model is not None:
-                raise TypeError("Model must be of type sklearn.tree.DecisionTreeClassifier.")
-
-        elif not isinstance(model, sklearn.tree.DecisionTreeClassifier) and model is not None:
-            raise TypeError("Model must be of type sklearn.tree.DecisionTreeClassifier.")
-
-        super().__init__(
-            model=model,
-            clip_values=clip_values,
-            preprocessing_defences=preprocessing_defences,
-            postprocessing_defences=postprocessing_defences,
-            preprocessing=preprocessing,
-        )
-
-    def get_classes_at_node(self, node_id: int) -> np.ndarray:
-        """
-        Returns the classification for a given node.
-
-        Parameters
-        ----------
-        node_id : int
-            Node id.
-
-        Returns
-        -------
-        np.ndarray
-            Classification for the node.
-        """
-        return np.argmax(self.model.tree_.value[node_id])  # type: ignore
-
-    def get_threshold_at_node(self, node_id: int) -> float:
-        """
-        Returns the threshold of given id for a node.
-
-        Parameters
-        ----------
-        node_id : int
-            Node id.
-
-        Returns
-        -------
-        float
-            Threshold value of feature split in this node.
-        """
-        return self.model.tree_.threshold[node_id]
-
-    def get_feature_at_node(self, node_id: int) -> int:
-        """
-        Returns the feature of given id for a node.
-
-        Parameters
-        ----------
-        node_id : int
-            Node id.
-
-        Returns
-        -------
-        int
-            Feature index of feature split in this node.
-        """
-        return self.model.tree_.feature[node_id]
-
-    def get_samples_at_node(self, node_id: int) -> int:
-        """
-        Returns the number of training samples mapped to a node.
-
-        Parameters
-        ----------
-        node_id : int
-            Node id.
-
-        Returns
-        -------
-        int
-            Number of samples mapped this node.
-        """
-        return self.model.tree_.n_node_samples[node_id]
-
-    def get_left_child(self, node_id: int) -> int:
-        """
-        Returns the id of the left child node of node_id.
-
-        Parameters
-        ----------
-        node_id : int
-            Node id.
-
-        Returns
-        -------
-        int
-            The indices of the left child in the tree.
-        """
-        return self.model.tree_.children_left[node_id]
-
-    def get_right_child(self, node_id: int) -> int:
-        """
-        Returns the id of the right child node of node_id.
-
-        Parameters
-        ----------
-        node_id : int
-            Node id.
-
-        Returns
-        -------
-        int
-            The indices of the right child in the tree.
-        """
-        return self.model.tree_.children_right[node_id]
-
-    def get_decision_path(self, x: np.ndarray) -> np.ndarray:
-        """
-        Returns the path through nodes in the tree when classifying x. Last one is leaf, first one root node.
-
-        Parameters
-        ----------
-        x : np.ndarray
-            Input sample.
-
-        Returns
-        -------
-        np.ndarray
-            The indices of the nodes in the array structure of the tree.
-        """
-        if len(np.shape(x)) == 1:
-            return self.model.decision_path(x.reshape(1, -1)).indices
-
-        return self.model.decision_path(x).indices
-
-    def get_values_at_node(self, node_id: int) -> np.ndarray:
-        """
-        Returns the feature of given id for a node.
-
-        Parameters
-        ----------
-        node_id : int
-            Node id.
-
-        Returns
-        -------
-        np.ndarray
-            Normalized values at node node_id.
-        """
-        return self.model.tree_.value[node_id] / np.linalg.norm(self.model.tree_.value[node_id])
-
-    def _get_leaf_nodes(self, node_id, i_tree, class_label, box):
-        from holisticai.security.attackers.attribute_inference.mitigation.verification_decisions_trees import (
-            Box,
-            Interval,
-            LeafNode,
-        )
-
-        leaf_nodes = []
-
-        if self.get_left_child(node_id) != self.get_right_child(node_id):
-            node_left = self.get_left_child(node_id)
-            node_right = self.get_right_child(node_id)
-
-            box_left = deepcopy(box)
-            box_right = deepcopy(box)
-
-            feature = self.get_feature_at_node(node_id)
-            box_split_left = Box(intervals={feature: Interval(-np.inf, self.get_threshold_at_node(node_id))})
-            box_split_right = Box(intervals={feature: Interval(self.get_threshold_at_node(node_id), np.inf)})
-
-            if box.intervals:
-                box_left.intersect_with_box(box_split_left)
-                box_right.intersect_with_box(box_split_right)
-            else:
-                box_left = box_split_left
-                box_right = box_split_right
-
-            leaf_nodes += self._get_leaf_nodes(node_left, i_tree, class_label, box_left)
-            leaf_nodes += self._get_leaf_nodes(node_right, i_tree, class_label, box_right)
-
-        else:
-            leaf_nodes.append(
-                LeafNode(
-                    tree_id=i_tree,
-                    class_label=class_label,
-                    node_id=node_id,
-                    box=box,
-                    value=self.get_values_at_node(node_id)[0, class_label],
-                )
-            )
-
-        return leaf_nodes
-
-
-class ScikitlearnExtraTreeClassifier(ScikitlearnDecisionTreeClassifier):
-    """
-    Class for scikit-learn Extra TreeClassifier Classifier models.
-
-    Parameters
-    ----------
-    model : scikit-learn Extra TreeClassifier Classifier model
-        The scikit-learn Extra TreeClassifier Classifier model.
-    clip_values : tuple
-        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
-    preprocessing_defences : `Preprocessor` or `list`
-        Preprocessing defence(s) to be applied by the classifier.
-    postprocessing_defences : `Postprocessor` or `list`
-        Postprocessing defence(s) to be applied by the classifier.
-    preprocessing : tuple
-        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data
-        preprocessing. The first value will be subtracted from the input. The input will then be divided by the
-        second one.
-    """
-
-    def __init__(
-        self,
-        model,
-        clip_values=None,
-        preprocessing_defences=None,
-        postprocessing_defences=None,
-        preprocessing=(0.0, 1.0),
-    ) -> None:
-        import sklearn  # lgtm [py/repeated-import]
-
-        if not isinstance(model, sklearn.tree.ExtraTreeClassifier):
-            raise TypeError("Model must be of type sklearn.tree.ExtraTreeClassifier.")
-
-        super().__init__(
-            model=model,
-            clip_values=clip_values,
-            preprocessing_defences=preprocessing_defences,
-            postprocessing_defences=postprocessing_defences,
-            preprocessing=preprocessing,
-        )
-
-
-class ScikitlearnAdaBoostClassifier(ScikitlearnClassifier):
-    """
-    Class for scikit-learn AdaBoost Classifier models.
-
-    Parameters
-    ----------
-    model : scikit-learn AdaBoost Classifier model
-        The scikit-learn AdaBoost Classifier model.
-    clip_values : tuple
-        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
-    preprocessing_defences : `Preprocessor` or `list`
-        Preprocessing defence(s) to be applied by the classifier.
-    postprocessing_defences : `Postprocessor` or `list`
-        Postprocessing defence(s) to be applied by the classifier.
-    preprocessing : tuple
-        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data
-        preprocessing. The first value will be subtracted from the input. The input will then be divided by the
-        second one.
-    """
-
-    def __init__(
-        self,
-        model,
-        clip_values=None,
-        preprocessing_defences=None,
-        postprocessing_defences=None,
-        preprocessing=(0.0, 1.0),
-    ) -> None:
-        import sklearn  # lgtm [py/repeated-import]
-
-        if not isinstance(model, sklearn.ensemble.AdaBoostClassifier):
-            raise TypeError("Model must be of type sklearn.ensemble.AdaBoostClassifier.")
-
-        super().__init__(
-            model=model,
-            clip_values=clip_values,
-            preprocessing_defences=preprocessing_defences,
-            postprocessing_defences=postprocessing_defences,
-            preprocessing=preprocessing,
-        )
-
-
-class ScikitlearnBaggingClassifier(ScikitlearnClassifier):
-    """
-    Class for scikit-learn Bagging Classifier models.
-
-    Parameters
-    ----------
-    model : scikit-learn Bagging Classifier model
-        The scikit-learn Bagging Classifier model.
-    clip_values : tuple
-        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
-    preprocessing_defences : `Preprocessor` or `list`
-        Preprocessing defence(s) to be applied by the classifier.
-    postprocessing_defences : `Postprocessor` or `list`
-        Postprocessing defence(s) to be applied by the classifier.
-    preprocessing : tuple
-        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data
-        preprocessing. The first value will be subtracted from the input. The input will then be divided by the
-        second one.
-    """
-
-    def __init__(
-        self,
-        model,
-        clip_values=None,
-        preprocessing_defences=None,
-        postprocessing_defences=None,
-        preprocessing=(0.0, 1.0),
-    ) -> None:
-        import sklearn  # lgtm [py/repeated-import]
-
-        if not isinstance(model, sklearn.ensemble.BaggingClassifier):
-            raise TypeError("Model must be of type sklearn.ensemble.BaggingClassifier.")
-
-        super().__init__(
-            model=model,
-            clip_values=clip_values,
-            preprocessing_defences=preprocessing_defences,
-            postprocessing_defences=postprocessing_defences,
-            preprocessing=preprocessing,
-        )
-
-
-class ScikitlearnExtraTreesClassifier(ScikitlearnClassifier, DecisionTreeMixin):
-    """
-    Class for scikit-learn Extra Trees Classifier models.
-
-    Parameters
-    ----------
-    model : scikit-learn Extra Trees Classifier model
-        The scikit-learn Extra Trees Classifier model.
-    clip_values : tuple
-        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
-    preprocessing_defences : `Preprocessor` or `list`
-        Preprocessing defence(s) to be applied by the classifier.
-    postprocessing_defences : `Postprocessor` or `list`
-        Postprocessing defence(s) to be applied by the classifier.
-    preprocessing : tuple
-        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data
-        preprocessing. The first value will be subtracted from the input. The input will then be divided by the
-        second one.
-    """
-
-    def __init__(
-        self,
-        model,
-        clip_values=None,
-        preprocessing_defences=None,
-        postprocessing_defences=None,
-        preprocessing=(0.0, 1.0),
-    ):
-        import sklearn  # lgtm [py/repeated-import]
-
-        if not isinstance(model, sklearn.ensemble.ExtraTreesClassifier):
-            raise TypeError("Model must be of type sklearn.ensemble.ExtraTreesClassifier.")
-
-        super().__init__(
-            model=model,
-            clip_values=clip_values,
-            preprocessing_defences=preprocessing_defences,
-            postprocessing_defences=postprocessing_defences,
-            preprocessing=preprocessing,
-        )
-
-    def get_trees(self):  # lgtm [py/similar-function]
-        """
-        Get the decision trees.
-
-        Returns
-        -------
-        list
-            A list of decision trees.
-        """
-        from holisticai.security.attackers.attribute_inference.mitigation.verification_decisions_trees import Box, Tree
-
-        trees = []
-
-        for i_tree, decision_tree_model in enumerate(self.model.estimators_):
-            box = Box()
-
-            extra_tree_classifier = ScikitlearnExtraTreeClassifier(model=decision_tree_model)
-
-            for i_class in range(self.model.n_classes_):
-                class_label = i_class
-
-                trees.append(
-                    Tree(
-                        class_id=class_label,
-                        leaf_nodes=extra_tree_classifier._get_leaf_nodes(0, i_tree, class_label, box),  # noqa: SLF001
-                    )
-                )
-
-        return trees
-
-
-class ScikitlearnGradientBoostingClassifier(ScikitlearnClassifier, DecisionTreeMixin):
-    """
-    Class for scikit-learn Gradient Boosting Classifier models.
-
-    Parameters
-    ----------
-    model : scikit-learn Gradient Boosting Classifier model
-        The scikit-learn Gradient Boosting Classifier model.
-    clip_values : tuple
-        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
-    preprocessing_defences : `Preprocessor` or `list`
-        Preprocessing defence(s) to be applied by the classifier.
-    postprocessing_defences : `Postprocessor` or `list`
-        Postprocessing defence(s) to be applied by the classifier.
-    preprocessing : tuple
-        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data
-        preprocessing. The first value will be subtracted from the input. The input will then be divided by the
-        second one.
-    """
-
-    def __init__(
-        self,
-        model,
-        clip_values=None,
-        preprocessing_defences=None,
-        postprocessing_defences=None,
-        preprocessing=(0.0, 1.0),
-    ) -> None:
-        import sklearn
-
-        if not isinstance(model, sklearn.ensemble.GradientBoostingClassifier):
-            raise TypeError("Model must be of type sklearn.ensemble.GradientBoostingClassifier.")
-
-        super().__init__(
-            model=model,
-            clip_values=clip_values,
-            preprocessing_defences=preprocessing_defences,
-            postprocessing_defences=postprocessing_defences,
-            preprocessing=preprocessing,
-        )
-
-    def get_trees(self):
-        """
-        Get the decision trees.
-
-        Returns
-        -------
-        list
-            A list of decision trees.
-        """
-        from holisticai.security.attackers.attribute_inference.mitigation.verification_decisions_trees import Box, Tree
-
-        trees = []
-        num_trees, num_classes = self.model.estimators_.shape
-
-        for i_tree in range(num_trees):
-            box = Box()
-
-            for i_class in range(num_classes):
-                decision_tree_classifier = ScikitlearnDecisionTreeRegressor(
-                    model=self.model.estimators_[i_tree, i_class]
-                )
-
-                class_label = None if num_classes == 2 else i_class
-
-                trees.append(
-                    Tree(
-                        class_id=class_label,
-                        leaf_nodes=decision_tree_classifier._get_leaf_nodes(0, i_tree, class_label, box),  # noqa: SLF001
-                    )
-                )
-
-        return trees
-
-
-class ScikitlearnRandomForestClassifier(ScikitlearnClassifier):
-    """
-    Class for scikit-learn Random Forest Classifier models.
-
-    Parameters
-    ----------
-    model : scikit-learn Random Forest Classifier model
-        The scikit-learn Random Forest Classifier model.
-    clip_values : tuple of float
-        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
-    preprocessing_defences : `Preprocessor` or `list`
-        Preprocessing defence(s) to be applied by the classifier.
-    postprocessing_defences : `Postprocessor` or `list`
-        Postprocessing defence(s) to be applied by the classifier.
-    preprocessing : tuple of float
-        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data
-        preprocessing. The first value will be subtracted from the input. The input will then be divided by the
-        second one.
-    """
-
-    def __init__(
-        self,
-        model,
-        clip_values=None,
-        preprocessing_defences=None,
-        postprocessing_defences=None,
-        preprocessing=(0.0, 1.0),
-    ) -> None:
-        import sklearn
-
-        if not isinstance(model, sklearn.ensemble.RandomForestClassifier):
-            raise TypeError("Model must be of type sklearn.ensemble.RandomForestClassifier.")
-
-        super().__init__(
-            model=model,
-            clip_values=clip_values,
-            preprocessing_defences=preprocessing_defences,
-            postprocessing_defences=postprocessing_defences,
-            preprocessing=preprocessing,
-        )
-
-    def get_trees(self):  # lgtm [py/similar-function]
-        """
-        Get the decision trees.
-
-        :return: A list of decision trees.
-        """
-        from holisticai.security.attackers.attribute_inference.mitigation.verification_decisions_trees import Box, Tree
-
-        trees = []
-
-        for i_tree, decision_tree_model in enumerate(self.model.estimators_):
-            box = Box()
-
-            decision_tree_classifier = ScikitlearnDecisionTreeClassifier(model=decision_tree_model)
-
-            for i_class in range(self.model.n_classes_):
-                class_label = i_class
-
-                trees.append(
-                    Tree(
-                        class_id=class_label,
-                        leaf_nodes=decision_tree_classifier._get_leaf_nodes(0, i_tree, class_label, box),  # noqa: SLF001
-                    )
-                )
-
-        return trees
-
-
-class ScikitlearnLogisticRegression(ClassGradientsMixin, LossGradientsMixin, ScikitlearnClassifier):
-    """
-    Class for scikit-learn Logistic Regression models.
-
-    Parameters
-    ----------
-    model : scikit-learn Logistic Regression model
-        The scikit-learn Logistic Regression model.
-    clip_values : tuple
-        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
-    preprocessing_defences : `Preprocessor` or `list`
-        Preprocessing defence(s) to be applied by the classifier.
-    postprocessing_defences : `Postprocessor` or `list`
-        Postprocessing defence(s) to be applied by the classifier.
-    preprocessing : tuple
-        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data
-        preprocessing. The first value will be subtracted from the input. The input will then be divided by the
-        second one.
-    """
-
-    def __init__(
-        self,
-        model,
-        clip_values=None,
-        preprocessing_defences=None,
-        postprocessing_defences=None,
-        preprocessing=(0.0, 1.0),
-    ) -> None:
-        import sklearn
-
-        if not isinstance(model, sklearn.linear_model.LogisticRegression):
-            raise TypeError("Model must be of type sklearn.linear_model.LogisticRegression).")
-
-        super().__init__(
-            model=model,
-            clip_values=clip_values,
-            preprocessing_defences=preprocessing_defences,
-            postprocessing_defences=postprocessing_defences,
-            preprocessing=preprocessing,
-        )
-
-    def class_gradient(self, x: np.ndarray, label: Union[int, list[int], None] = None, **kwargs) -> np.ndarray:  # noqa: ARG002
-        """
-        Compute per-class derivatives w.r.t. `x`.
-
-        | Paper link: http://cs229.stanford.edu/proj2016/report/ItkinaWu-AdversarialAttacksonImageRecognition-report.pdf
-        | Typo in https://arxiv.org/abs/1605.07277 (equation 6)
-
-        Parameters
-        ----------
-        x : `np.ndarray`
-            Sample input with shape as expected by the model.
-        label : `int`, `list` of `int` or `None`
-            Index of a specific per-class derivative. If an integer is provided, the gradient of that class output is
-            computed for all samples. If multiple values as provided, the first dimension should match the batch size
-            of `x`, and each value will be used as target for its corresponding sample in `x`. If `None`, then gradients
-            for all classes will be computed for each sample.
-
-        Returns
-        -------
-        `np.ndarray`
-            Array of gradients of input features w.r.t. each class in the form `(batch_size, nb_classes, input_shape)`
-
-        Raises
-        ------
-        ValueError
-            If the model has not been fitted prior to calling this method or if the number of classes in the classifier
-            is not known.
-        TypeError
-            If the requested label cannot be processed.
-        """
-        if not hasattr(self.model, "coef_"):  # pragma: no cover
-            raise ValueError(
-                """Model has not been fitted. Run function `fit(x, y)` of classifier first or provide a
-            fitted model."""
-            )
-        if self.nb_classes is None:  # pragma: no cover
-            raise ValueError("Unknown number of classes in classifier.")
-        nb_samples = x.shape[0]
-
-        # Apply preprocessing
-        x_preprocessed, _ = self._apply_preprocessing(x, y=None, fit=False)
-
-        y_pred = self.model.predict_proba(X=x_preprocessed)
-        weights = self.model.coef_
-
-        if self.nb_classes > 2:  # type: ignore
-            w_weighted = np.matmul(y_pred, weights)
-
-        def _f_class_gradient(i_class, i_sample):
-            if self.nb_classes == 2:
-                return (-1.0) ** (i_class + 1.0) * y_pred[i_sample, 0] * y_pred[i_sample, 1] * weights[0, :]
-
-            return weights[i_class, :] - w_weighted[i_sample, :]
-
-        if label is None:
-            # Compute the gradients w.r.t. all classes
-            class_gradients = []
-
-            for i_class in range(self.nb_classes):  # type: ignore
-                class_gradient = np.zeros(x.shape)
-                for i_sample in range(nb_samples):
-                    class_gradient[i_sample, :] += _f_class_gradient(i_class, i_sample)
-                class_gradients.append(class_gradient)
-
-            gradients = np.swapaxes(np.array(class_gradients), 0, 1)
-
-        elif isinstance(label, int):
-            # Compute the gradients only w.r.t. the provided label
-            class_gradient = np.zeros(x.shape)
-            for i_sample in range(nb_samples):
-                class_gradient[i_sample, :] += _f_class_gradient(label, i_sample)
-
-            gradients = np.swapaxes(np.array([class_gradient]), 0, 1)
-
-        elif (
-            (isinstance(label, list) and len(label) == nb_samples)
-            or isinstance(label, np.ndarray)
-            and label.shape == (nb_samples,)
-        ):
-            # For each sample, compute the gradients w.r.t. the indicated target class (possibly distinct)
-            class_gradients = []
-            unique_labels = list(np.unique(label))
-
-            for unique_label in unique_labels:
-                class_gradient = np.zeros(x.shape)
-                for i_sample in range(nb_samples):
-                    # class_gradient[i_sample, :] += label[i_sample, unique_label] * (weights[unique_label, :]
-                    # - w_weighted[i_sample, :])
-                    class_gradient[i_sample, :] += _f_class_gradient(unique_label, i_sample)
-
-                class_gradients.append(class_gradient)
-
-            gradients = np.swapaxes(np.array(class_gradients), 0, 1)
-            lst = [unique_labels.index(i) for i in label]
-            gradients = np.expand_dims(gradients[np.arange(len(gradients)), lst], axis=1)
-
-        else:
-            raise TypeError("Unrecognized type for argument `label` with type " + str(type(label)))
-
-        gradients = self._apply_preprocessing_gradient(x, gradients)
-
-        return gradients
-
-    def loss_gradient(self, x: np.ndarray, y: np.ndarray, **kwargs) -> np.ndarray:  # noqa: ARG002
-        """
-        Compute the gradient of the loss function w.r.t. `x`.
-
-        Parameters
-        ----------
-        x : `np.ndarray`
-            Sample input with shape as expected by the model.
-        y : `np.ndarray`
-            Target values (class labels) one-hot-encoded of shape `(nb_samples, nb_classes)`.
-        kwargs : `dict`
-            Dictionary of framework-specific arguments. These should be parameters supported by the `loss_gradient`
-            function in `sklearn` classifier and will be passed to this function as such.
-
-        Returns
-        -------
-        `np.ndarray`
-            Array of gradients of the same shape as `x`.
-
-        Raises
-        ------
-        ValueError
-            If the model has not been fitted prior to calling this method.
-        """
-        from sklearn.utils.class_weight import compute_class_weight
-
-        if not hasattr(self.model, "coef_"):  # pragma: no cover
-            raise ValueError(
-                """Model has not been fitted. Run function `fit(x, y)` of classifier first or provide a
-            fitted model."""
-            )
-
-        # Apply preprocessing
-        x_preprocessed, y_preprocessed = self._apply_preprocessing(x, y, fit=False)
-
-        y_index = np.argmax(y_preprocessed, axis=1)
-        if self.model.class_weight is None or self.model.class_weight == "balanced":
-            class_weight = np.ones(self.nb_classes)
-        else:
-            class_weight = compute_class_weight(
-                class_weight=self.model.class_weight,
-                classes=self.model.classes_,
-                y=y_index,
-            )
-
-        y_pred = self.predict(x=x_preprocessed)
-        weights = self.model.coef_
-
-        errors = class_weight * (y_pred - y)
-
-        if weights.shape[0] == 1:
-            weights = np.append(-weights, weights, axis=0)
-
-        gradients = (errors @ weights) / self.model.classes_.size
-
-        gradients = self._apply_preprocessing_gradient(x, gradients)
-
-        return gradients
-
-    @staticmethod
-    def get_trainable_attribute_names() -> tuple[str, str]:
-        """
-        Get the names of trainable attributes.
-
-        Returns
-        -------
-        `tuple`
-            A tuple of trainable attributes.
-        """
-        return "intercept_", "coef_"
-
-
-class ScikitlearnGaussianNB(ScikitlearnClassifier):
-    """
-    Class for scikit-learn Gaussian Naive Bayes models.
-
-    Parameters
-    ----------
-    model : scikit-learn Gaussian Naive Bayes model
-        The scikit-learn Gaussian Naive Bayes model.
-    clip_values : tuple
-        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
-    preprocessing_defences : `Preprocessor` or `list`
-        Preprocessing defence(s) to be applied by the classifier.
-    postprocessing_defences : `Postprocessor` or `list`
-        Postprocessing defence(s) to be applied by the classifier.
-    preprocessing : tuple
-        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data
-        preprocessing. The first value will be subtracted from the input. The input will then be divided by the
-        second one.
-    """
-
-    def __init__(
-        self,
-        model,
-        clip_values=None,
-        preprocessing_defences=None,
-        postprocessing_defences=None,
-        preprocessing=(0.0, 1.0),
-    ) -> None:
-        import sklearn  # lgtm [py/repeated-import]
-
-        if not isinstance(model, sklearn.naive_bayes.GaussianNB):  # pragma: no cover
-            raise TypeError(f"Model must be of type sklearn.naive_bayes.GaussianNB. Found type {type(model)}")
-
-        super().__init__(
-            model=model,
-            clip_values=clip_values,
-            preprocessing_defences=preprocessing_defences,
-            postprocessing_defences=postprocessing_defences,
-            preprocessing=preprocessing,
-        )
-
-    @staticmethod
-    def get_trainable_attribute_names() -> tuple[str, str]:
-        """
-        Get the names of trainable attributes.
-
-        Returns
-        -------
-        `tuple`
-            A tuple of trainable attributes.
-        """
-        return "sigma_", "theta_"
-
-
-class ScikitlearnSVC(ClassGradientsMixin, LossGradientsMixin, ScikitlearnClassifier):
-    """
-    Class for scikit-learn C-Support Vector Classification models.
-
-    Parameters
-    ----------
-    model : scikit-learn C-Support Vector Classification model
-        The scikit-learn C-Support Vector Classification model.
-    clip_values : tuple
-        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
-    preprocessing_defences : `Preprocessor` or `list`
-        Preprocessing defence(s) to be applied by the classifier.
-    postprocessing_defences : `Postprocessor` or `list`
-        Postprocessing defence(s) to be applied by the classifier.
-    preprocessing : tuple
-        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data
-        preprocessing. The first value will be subtracted from the input. The input will then be divided by the
-        second one.
-    """
-
-    def __init__(
-        self,
-        model,
-        clip_values=None,
-        preprocessing_defences=None,
-        postprocessing_defences=None,
-        preprocessing=(0.0, 1.0),
-    ) -> None:
-        import sklearn  # lgtm [py/repeated-import]
-
-        if not isinstance(model, sklearn.svm.SVC) and not isinstance(model, sklearn.svm.LinearSVC):
-            raise TypeError(f"Model must be of type sklearn.svm.SVC or sklearn.svm.LinearSVC. Found type {type(model)}")
-
-        super().__init__(
-            model=model,
-            clip_values=clip_values,
-            preprocessing_defences=preprocessing_defences,
-            postprocessing_defences=postprocessing_defences,
-            preprocessing=preprocessing,
-        )
-        self._kernel = self._kernel_func()
-
-    def class_gradient(self, x: np.ndarray, label: Union[int, list[int], None] = None, **kwargs) -> np.ndarray:  # noqa: ARG002
-        """
-        Compute per-class derivatives w.r.t. `x`.
-
-        Parameters
-        ----------
-        x : `np.ndarray`
-            Sample input with shape as expected by the model.
-        label : `int`, `list` of `int` or `None`
-            Index of a specific per-class derivative. If an integer is provided, the gradient of that class output is
-            computed for all samples. If multiple values as provided, the first dimension should match the batch size
-            of `x`, and each value will be used as target for its corresponding sample in `x`. If `None`, then gradients
-            for all classes will be computed for each sample.
-
-        Returns
-        -------
-        `np.ndarray`
-            Array of gradients of input features w.r.t. each class in the form `(batch_size, nb_classes, input_shape)`
-        """
-        import sklearn  # lgtm [py/repeated-import]
-
-        # Apply preprocessing
-        x_preprocessed, _ = self._apply_preprocessing(x, y=None, fit=False)
-
-        num_samples, _ = x_preprocessed.shape
-
-        if isinstance(self.model, sklearn.svm.SVC):
-            if self.model.fit_status_:  # pragma: no cover
-                raise AssertionError("Model has not been fitted correctly.")
-
-            support_indices = [0, *list(np.cumsum(self.model.n_support_))]
-
-            sign_multiplier = -1 if self.nb_classes == 2 else 1
-
-            if label is None:
-                gradients = np.zeros(
-                    (
-                        x_preprocessed.shape[0],
-                        self.nb_classes,
-                        x_preprocessed.shape[1],
-                    )
-                )
-
-                for i_label in range(self.nb_classes):  # type: ignore
-                    for i_sample in range(num_samples):
-                        for not_label in range(self.nb_classes):  # type: ignore
-                            if i_label != not_label:
-                                label_multiplier = -1 if not_label < i_label else 1
-
-                                for label_sv in range(
-                                    support_indices[i_label],
-                                    support_indices[i_label + 1],
-                                ):
-                                    alpha_i_k_y_i = self.model.dual_coef_[
-                                        not_label if not_label < i_label else not_label - 1,
-                                        label_sv,
-                                    ]
-                                    grad_kernel = self._get_kernel_gradient_sv(label_sv, x_preprocessed[i_sample])
-                                    gradients[i_sample, i_label] += label_multiplier * alpha_i_k_y_i * grad_kernel
-
-                                for not_label_sv in range(
-                                    support_indices[not_label],
-                                    support_indices[not_label + 1],
-                                ):
-                                    alpha_i_k_y_i = self.model.dual_coef_[
-                                        i_label if i_label < not_label else i_label - 1,
-                                        not_label_sv,
-                                    ]
-                                    grad_kernel = self._get_kernel_gradient_sv(not_label_sv, x_preprocessed[i_sample])
-                                    gradients[i_sample, i_label] += label_multiplier * alpha_i_k_y_i * grad_kernel
-
-            elif isinstance(label, int):
-                gradients = np.zeros((x_preprocessed.shape[0], 1, x_preprocessed.shape[1]))
-
-                for i_sample in range(num_samples):
-                    for not_label in range(self.nb_classes):  # type: ignore
-                        if label != not_label:
-                            label_multiplier = -1 if not_label < label else 1
-
-                            for label_sv in range(support_indices[label], support_indices[label + 1]):
-                                alpha_i_k_y_i = self.model.dual_coef_[
-                                    not_label if not_label < label else not_label - 1,
-                                    label_sv,
-                                ]
-                                grad_kernel = self._get_kernel_gradient_sv(label_sv, x_preprocessed[i_sample])
-                                gradients[i_sample, 0] += label_multiplier * alpha_i_k_y_i * grad_kernel
-
-                            for not_label_sv in range(
-                                support_indices[not_label],
-                                support_indices[not_label + 1],
-                            ):
-                                alpha_i_k_y_i = self.model.dual_coef_[
-                                    label if label < not_label else label - 1,
-                                    not_label_sv,
-                                ]
-                                grad_kernel = self._get_kernel_gradient_sv(not_label_sv, x_preprocessed[i_sample])
-                                gradients[i_sample, 0] += label_multiplier * alpha_i_k_y_i * grad_kernel
-
-            elif (
-                (isinstance(label, list) and len(label) == num_samples)
-                or isinstance(label, np.ndarray)
-                and label.shape == (num_samples,)
-            ):
-                gradients = np.zeros((x_preprocessed.shape[0], 1, x_preprocessed.shape[1]))
-
-                for i_sample in range(num_samples):
-                    for not_label in range(self.nb_classes):  # type: ignore
-                        if label[i_sample] != not_label:
-                            label_multiplier = -1 if not_label < label[i_sample] else 1
-
-                            for label_sv in range(
-                                support_indices[label[i_sample]],
-                                support_indices[label[i_sample] + 1],
-                            ):
-                                alpha_i_k_y_i = self.model.dual_coef_[
-                                    not_label if not_label < label[i_sample] else not_label - 1,
-                                    label_sv,
-                                ]
-                                grad_kernel = self._get_kernel_gradient_sv(label_sv, x_preprocessed[i_sample])
-                                gradients[i_sample, 0] += label_multiplier * alpha_i_k_y_i * grad_kernel
-
-                            for not_label_sv in range(
-                                support_indices[not_label],
-                                support_indices[not_label + 1],
-                            ):
-                                alpha_i_k_y_i = self.model.dual_coef_[
-                                    label[i_sample] if label[i_sample] < not_label else label[i_sample] - 1,
-                                    not_label_sv,
-                                ]
-                                grad_kernel = self._get_kernel_gradient_sv(not_label_sv, x_preprocessed[i_sample])
-                                gradients[i_sample, 0] += label_multiplier * alpha_i_k_y_i * grad_kernel
-
-            else:
-                raise TypeError("Unrecognized type for argument `label` with type " + str(type(label)))
-
-            gradients = self._apply_preprocessing_gradient(x, gradients * sign_multiplier)
-
-        elif isinstance(self.model, sklearn.svm.LinearSVC):
-            if label is None:
-                gradients = np.zeros(
-                    (
-                        x_preprocessed.shape[0],
-                        self.nb_classes,
-                        x_preprocessed.shape[1],
-                    )
-                )
-
-                for i in range(self.nb_classes):  # type: ignore
-                    for i_sample in range(num_samples):
-                        if self.nb_classes == 2:
-                            gradients[i_sample, i] = self.model.coef_[0] * (2 * i - 1)
-                        else:
-                            gradients[i_sample, i] = self.model.coef_[i]
-
-            elif isinstance(label, int):
-                gradients = np.zeros((x_preprocessed.shape[0], 1, x_preprocessed.shape[1]))
-
-                for i_sample in range(num_samples):
-                    if self.nb_classes == 2:
-                        gradients[i_sample, 0] = self.model.coef_[0] * (2 * label - 1)
-                    else:
-                        gradients[i_sample, 0] = self.model.coef_[label]
-
-            elif (
-                (isinstance(label, list) and len(label) == num_samples)
-                or isinstance(label, np.ndarray)
-                and label.shape == (num_samples,)
-            ):
-                gradients = np.zeros((x_preprocessed.shape[0], 1, x_preprocessed.shape[1]))
-
-                for i_sample in range(num_samples):
-                    if self.nb_classes == 2:
-                        gradients[i_sample, 0] = self.model.coef_[0] * (2 * label[i_sample] - 1)
-                    else:
-                        gradients[i_sample, 0] = self.model.coef_[label[i_sample]]
-
-            else:
-                raise TypeError("Unrecognized type for argument `label` with type " + str(type(label)))
-
-            gradients = self._apply_preprocessing_gradient(x, gradients)
-
-        return gradients
-
-    def _kernel_grad(self, sv: np.ndarray, x_sample: np.ndarray) -> np.ndarray:
-        """
-        Applies the kernel gradient to a support vector.
-
-        Parameters
-        ----------
-        sv : `np.ndarray`
-            A support vector.
-        x_sample : `np.ndarray`
-            The sample the gradient is taken with respect to.
-
-        Returns
-        -------
-        `np.ndarray`
-            The kernel gradient.
-        """
-        if self.model.kernel == "linear":
-            grad = sv
-        elif self.model.kernel == "poly":
-            grad = (
-                self.model.degree
-                * (self.model._gamma * np.sum(x_sample * sv) + self.model.coef0) ** (self.model.degree - 1)  # noqa: SLF001
-                * sv
-            )
-        elif self.model.kernel == "rbf":
-            grad = (
-                2
-                * self.model._gamma  # noqa: SLF001
-                * (-1)
-                * np.exp(-self.model._gamma * np.linalg.norm(x_sample - sv, ord=2) ** 2)  # noqa: SLF001
-                * (x_sample - sv)
-            )
-        elif self.model.kernel == "sigmoid":
-            raise NotImplementedError
-        else:
-            raise NotImplementedError(f"Loss gradients for kernel '{self.model.kernel}' are not implemented.")
-        return grad
-
-    def _get_kernel_gradient_sv(self, i_sv: int, x_sample: np.ndarray) -> np.ndarray:
-        """
-        Applies the kernel gradient to all of a model's support vectors.
-
-        Parameters
-        ----------
-        i_sv : `int`
-            A support vector index.
-        x_sample : `np.ndarray`
-            The sample the gradient is taken with respect to.
-
-        Returns
-        -------
-        `np.ndarray`
-            The kernel gradient.
-        """
-        x_i = self.model.support_vectors_[i_sv, :]
-        return self._kernel_grad(x_i, x_sample)
-
-    def loss_gradient(self, x: np.ndarray, y: np.ndarray, **kwargs) -> np.ndarray:  # noqa: ARG002
-        """
-        Compute the gradient of the loss function w.r.t. `x`.
-        Following equation (1) with lambda=0.
-
-        | Paper link: https://pralab.diee.unica.it/sites/default/files/biggio14-svm-chapter.pdf
-
-        Parameters
-        ----------
-        x : `np.ndarray`
-            Sample input with shape as expected by the model.
-        y : `np.ndarray`
-            Target values (class labels) one-hot-encoded of shape `(nb_samples, nb_classes)`.
-        kwargs : `dict`
-            Dictionary of framework-specific arguments. These should be parameters supported by the `loss_gradient`
-            function in `sklearn` classifier and will be passed to this function as such.
-
-        Returns
-        -------
-        `np.ndarray`
-            Array of gradients of the same shape as `x`.
-
-        Raises
-        ------
-        ValueError
-            If the model has not been fitted prior to calling this method.
-
-        """
-        import sklearn  # lgtm [py/repeated-import]
-
-        # Apply preprocessing
-        x_preprocessed, y_preprocessed = self._apply_preprocessing(x, y, fit=False)
-
-        num_samples, _ = x_preprocessed.shape
-        gradients = np.zeros_like(x_preprocessed)
-        y_index = np.argmax(y_preprocessed, axis=1)
-
-        if isinstance(self.model, sklearn.svm.SVC):
-            if self.model.fit_status_:
-                raise AssertionError("Model has not been fitted correctly.")
-
-            sign_multiplier = 1 if y_preprocessed.shape[1] == 2 else -1
-
-            i_not_label_i = None
-            label_multiplier = None
-            support_indices = [0, *list(np.cumsum(self.model.n_support_))]
-
-            for i_sample in range(num_samples):
-                i_label = y_index[i_sample]
-
-                for i_not_label in range(self.nb_classes):  # type: ignore
-                    if i_label != i_not_label:
-                        if i_not_label < i_label:
-                            i_not_label_i = i_not_label
-                            label_multiplier = -1
-                        elif i_not_label > i_label:
-                            i_not_label_i = i_not_label - 1
-                            label_multiplier = 1
-
-                        for i_label_sv in range(support_indices[i_label], support_indices[i_label + 1]):
-                            alpha_i_k_y_i = self.model.dual_coef_[i_not_label_i, i_label_sv] * label_multiplier
-                            grad_kernel = self._get_kernel_gradient_sv(i_label_sv, x_preprocessed[i_sample])
-                            gradients[i_sample, :] += sign_multiplier * alpha_i_k_y_i * grad_kernel
-
-                        for i_not_label_sv in range(
-                            support_indices[i_not_label],
-                            support_indices[i_not_label + 1],
-                        ):
-                            alpha_i_k_y_i = self.model.dual_coef_[i_not_label_i, i_not_label_sv] * label_multiplier
-                            grad_kernel = self._get_kernel_gradient_sv(i_not_label_sv, x_preprocessed[i_sample])
-                            gradients[i_sample, :] += sign_multiplier * alpha_i_k_y_i * grad_kernel
-
-        elif isinstance(self.model, sklearn.svm.LinearSVC):
-            for i_sample in range(num_samples):
-                i_label = y_index[i_sample]
-                if self.nb_classes == 2:
-                    i_label_i = 0
-                    if i_label == 0:
-                        label_multiplier = 1
-                    elif i_label == 1:
-                        label_multiplier = -1
-                    else:
-                        raise ValueError("Label index not recognized because it is not 0 or 1.")
-                else:
-                    i_label_i = i_label
-                    label_multiplier = -1
-
-                gradients[i_sample] = label_multiplier * self.model.coef_[i_label_i]
-        else:
-            raise TypeError("Model not recognized.")
-
-        gradients = self._apply_preprocessing_gradient(x, gradients)
-        return gradients
-
-    def _kernel_func(self) -> Callable:
-        """
-        Return the function for the kernel of this SVM.
-
-        Returns
-        -------
-        `Callable`
-            A callable kernel function.
-        """
-        import sklearn  # lgtm [py/repeated-import]
-        from sklearn.metrics.pairwise import (
-            linear_kernel,
-            polynomial_kernel,
-            rbf_kernel,
-        )
-
-        if isinstance(self.model, sklearn.svm.LinearSVC):
-            kernel = "linear"
-        elif isinstance(self.model, sklearn.svm.SVC):
-            kernel = self.model.kernel
-        else:
-            raise NotImplementedError("SVM model not yet supported.")
-
-        if kernel == "linear":
-            kernel_func = linear_kernel
-        elif kernel == "poly":
-            kernel_func = polynomial_kernel
-        elif kernel == "rbf":
-            kernel_func = rbf_kernel
-        elif callable(kernel):
-            kernel_func = kernel
-        else:
-            raise NotImplementedError(f"Kernel '{kernel}' not yet supported.")
-
-        return kernel_func
-
-    def q_submatrix(self, rows: np.ndarray, cols: np.ndarray) -> np.ndarray:
-        """
-        Returns the q submatrix of this SVM indexed by the arrays at rows and columns.
-
-        Parameters
-        ----------
-        rows : `np.ndarray`
-            The row vectors.
-        cols : `np.ndarray`
-            The column vectors.
-
-        Returns
-        -------
-        `np.ndarray`
-            A submatrix of Q.
-        """
-        submatrix_shape = (rows.shape[0], cols.shape[0])
-        y_row = self.model.predict(rows)
-        y_col = self.model.predict(cols)
-        y_row[y_row == 0] = -1
-        y_col[y_col == 0] = -1
-        q_rc = np.zeros(submatrix_shape)
-        for row in range(q_rc.shape[0]):
-            for col in range(q_rc.shape[1]):
-                q_rc[row][col] = self._kernel([rows[row]], [cols[col]])[0][0] * y_row[row] * y_col[col]
-
-        return q_rc
-
-    def predict(self, x: np.ndarray, **kwargs) -> np.ndarray:  # noqa: ARG002
-        """
-        Perform prediction for a batch of inputs.
-
-        Parameters
-        ----------
-        x : `np.ndarray`
-            Input samples.
-
-        Returns
-        -------
-        `np.ndarray`
-            Array of predictions of shape `(nb_inputs, nb_classes)`.
-        """
-        import sklearn  # lgtm [py/repeated-import]
-
-        # Apply defences
-        x_preprocessed, _ = self._apply_preprocessing(x, y=None, fit=False)
-
-        if isinstance(self.model, sklearn.svm.SVC) and self.model.probability:
-            y_pred = self.model.predict_proba(X=x_preprocessed)
-        else:
-            y_pred_label = self.model.predict(X=x_preprocessed)
-            targets = np.array(y_pred_label).reshape(-1)
-            one_hot_targets = np.eye(self.nb_classes)[targets]
-            y_pred = one_hot_targets
-
-        return y_pred
-
-
-ScikitlearnLinearSVC = ScikitlearnSVC
diff --git a/src/holisticai/security/attackers/attribute_inference/wrappers/estimator.py b/src/holisticai/security/attackers/attribute_inference/wrappers/estimator.py
deleted file mode 100644
index 225cdde5..00000000
--- a/src/holisticai/security/attackers/attribute_inference/wrappers/estimator.py
+++ /dev/null
@@ -1,468 +0,0 @@
-"""
-This module implements abstract base and mixin classes for estimators in ART.
-"""
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from typing import Any
-
-import numpy as np
-from holisticai.security.attackers.attribute_inference.mitigation.config import ART_NUMPY_DTYPE
-
-
-class BaseEstimator(ABC):
-    """
-    The abstract base class `BaseEstimator` defines the basic requirements of an estimator in ART. The BaseEstimator is
-    is the highest abstraction of a machine learning model in ART.
-
-    Parameters
-    ----------
-    model : object
-        The model to be wrapped.
-    clip_values : tuple
-        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
-    preprocessing_defences : `Preprocessor` or `List[Preprocessor]`
-        Preprocessing defence(s) to be applied by the estimator.
-    postprocessing_defences : `Postprocessor` or `List[Postprocessor]`
-        Postprocessing defence(s) to be applied by the estimator.
-    preprocessing : tuple
-        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data preprocessing.
-        The first value will be subtracted from the input and the results will be divided by the second value.
-    """
-
-    estimator_params = [
-        "model",
-        "clip_values",
-        "preprocessing_defences",
-        "postprocessing_defences",
-        "preprocessing",
-    ]
-
-    def __init__(
-        self,
-        model,
-        clip_values,
-        preprocessing_defences=None,
-        postprocessing_defences=None,
-        preprocessing=(0.0, 1.0),
-    ):
-        self._model = model
-        self._clip_values = clip_values
-
-        self.preprocessing = self._set_preprocessing(preprocessing)
-        self.preprocessing_defences = self._set_preprocessing_defences(preprocessing_defences)
-        self.postprocessing_defences = self._set_postprocessing_defences(postprocessing_defences)
-        self.preprocessing_operations = []
-        BaseEstimator._update_preprocessing_operations(self)
-        BaseEstimator._check_params(self)
-
-    def _update_preprocessing_operations(self):
-        from holisticai.security.attackers.attribute_inference.mitigation.defences.preprocessor.preprocessor import (
-            Preprocessor,
-        )
-
-        self.preprocessing_operations.clear()
-
-        if self.preprocessing_defences is None:
-            pass
-        elif isinstance(self.preprocessing_defences, Preprocessor):
-            self.preprocessing_operations.append(self.preprocessing_defences)
-        else:
-            self.preprocessing_operations += self.preprocessing_defences
-
-        if self.preprocessing is None:
-            pass
-        elif isinstance(self.preprocessing, tuple):
-            from holisticai.security.attackers.attribute_inference.mitigation.preprocessing.standardisation.numpy import (
-                StandardisationMeanStd,
-            )
-
-            self.preprocessing_operations.append(
-                StandardisationMeanStd(mean=self.preprocessing[0], std=self.preprocessing[1])
-            )
-        elif isinstance(self.preprocessing, Preprocessor):
-            self.preprocessing_operations.append(self.preprocessing)
-        else:  # pragma: no cover
-            raise ValueError("Preprocessing argument not recognised.")
-
-    @staticmethod
-    def _set_preprocessing(preprocessing):
-        from holisticai.security.attackers.attribute_inference.mitigation.defences.preprocessor.preprocessor import (
-            Preprocessor,
-        )
-
-        if preprocessing is None:
-            return None
-        if isinstance(preprocessing, tuple):
-            from holisticai.security.attackers.attribute_inference.mitigation.preprocessing.standardisation.numpy import (
-                StandardisationMeanStd,
-            )
-
-            return StandardisationMeanStd(mean=preprocessing[0], std=preprocessing[1])  # type: ignore
-        if isinstance(preprocessing, Preprocessor):
-            return preprocessing
-
-        raise ValueError("Preprocessing argument not recognised.")  # pragma: no cover
-
-    @staticmethod
-    def _set_preprocessing_defences(preprocessing_defences):
-        from holisticai.security.attackers.attribute_inference.mitigation.defences.preprocessor.preprocessor import (
-            Preprocessor,
-        )
-
-        if isinstance(preprocessing_defences, Preprocessor):
-            return [preprocessing_defences]
-
-        return preprocessing_defences
-
-    @staticmethod
-    def _set_postprocessing_defences(postprocessing_defences):
-        from holisticai.security.attackers.attribute_inference.mitigation.defences.postprocessor.postprocessor import (
-            Postprocessor,
-        )
-
-        if isinstance(postprocessing_defences, Postprocessor):
-            return [postprocessing_defences]
-
-        return postprocessing_defences
-
-    def set_params(self, **kwargs) -> None:
-        """
-        Take a dictionary of parameters and apply checks before setting them as attributes.
-
-        Parameters
-        ----------
-        **kwargs
-            A dictionary of attributes.
-        """
-        for key, value in kwargs.items():
-            if key in self.estimator_params:
-                if hasattr(type(self), key) and isinstance(getattr(type(self), key), property):
-                    if getattr(type(self), key).fset is not None:
-                        setattr(self, key, value)
-                    else:
-                        setattr(self, "_" + key, value)
-                elif hasattr(self, "_" + key):
-                    setattr(self, "_" + key, value)
-                elif key == "preprocessing":
-                    setattr(self, key, self._set_preprocessing(value))
-                elif key == "preprocessing_defences":
-                    setattr(self, key, self._set_preprocessing_defences(value))
-                elif key == "postprocessing_defences":
-                    setattr(self, key, self._set_postprocessing_defences(value))
-                else:
-                    setattr(self, key, value)
-            else:  # pragma: no cover
-                raise ValueError(f"Unexpected parameter `{key}` found in kwargs.")
-        self._update_preprocessing_operations()
-        self._check_params()
-
-    def get_params(self) -> dict[str, Any]:
-        """
-        Get all parameters and their values of this estimator.
-
-        Returns
-        -------
-        dict
-            A dictionary of string parameter names to their value.
-        """
-        params = {}
-        for key in self.estimator_params:
-            params[key] = getattr(self, key)
-        return params
-
-    def _check_params(self) -> None:
-        from holisticai.security.attackers.attribute_inference.mitigation.defences.postprocessor.postprocessor import (
-            Postprocessor,
-        )
-        from holisticai.security.attackers.attribute_inference.mitigation.defences.preprocessor.preprocessor import (
-            Preprocessor,
-        )
-
-        if self._clip_values is not None:
-            if len(self._clip_values) != 2:  # pragma: no cover
-                raise ValueError(
-                    "`clip_values` should be a tuple of 2 floats or arrays containing the allowed data range."
-                )
-            if np.array(self._clip_values[0] >= self._clip_values[1]).any():  # pragma: no cover
-                raise ValueError("Invalid `clip_values`: min >= max.")
-
-            if isinstance(self._clip_values, np.ndarray):
-                self._clip_values = self._clip_values.astype(ART_NUMPY_DTYPE)
-            else:
-                self._clip_values = np.array(self._clip_values, dtype=ART_NUMPY_DTYPE)  # type: ignore
-
-        if isinstance(self.preprocessing_operations, list):
-            for preprocess in self.preprocessing_operations:
-                if not isinstance(preprocess, Preprocessor):  # pragma: no cover
-                    raise TypeError(
-                        "All preprocessing defences have to be instance of "
-                        "holisticai.security.attackers.attribute_inference.mitigation.defences.preprocessor.preprocessor.Preprocessor."
-                    )
-        else:  # pragma: no cover
-            raise TypeError(
-                "All preprocessing defences have to be instance of "
-                "holisticai.security.attackers.attribute_inference.mitigation.defences.preprocessor.preprocessor.Preprocessor."
-            )
-
-        if isinstance(self.postprocessing_defences, list):
-            for postproc_defence in self.postprocessing_defences:
-                if not isinstance(postproc_defence, Postprocessor):  # pragma: no cover
-                    raise TypeError(
-                        "All postprocessing defences have to be instance of "
-                        "art.defences.postprocessor.postprocessor.Postprocessor."
-                    )
-        elif self.postprocessing_defences is None:
-            pass
-        else:  # pragma: no cover
-            raise ValueError(
-                "All postprocessing defences have to be instance of "
-                "art.defences.postprocessor.postprocessor.Postprocessor."
-            )
-
-    @abstractmethod
-    def predict(self, x, **kwargs) -> Any:  # lgtm [py/inheritance/incorrect-overridden-signature]
-        """
-        Perform prediction of the estimator for input `x`.
-
-        Parameters
-        ----------
-        x : array-like
-            Input samples.
-
-        Returns
-        -------
-        array-like
-            Predictions by the model.
-        """
-        raise NotImplementedError
-
-    @abstractmethod
-    def fit(self, x, y, **kwargs) -> None:  # lgtm [py/inheritance/incorrect-overridden-signature]
-        """
-        Fit the estimator using the training data `(x, y)`.
-
-        Parameters
-        ----------
-        x : array-like
-            Training data.
-        y : array-like
-            Target values.
-        """
-        raise NotImplementedError
-
-    @property
-    def model(self):
-        """
-        Return the model.
-
-        Returns
-        -------
-        model
-            The model.
-        """
-        return self._model
-
-    @property
-    @abstractmethod
-    def input_shape(self) -> tuple[int, ...]:
-        """
-        Return the shape of one input sample.
-
-        Returns
-        -------
-        tuple
-            Shape of one input sample.
-        """
-        raise NotImplementedError
-
-    @property
-    def clip_values(self):
-        """
-        Return the clip values of the input samples.
-
-        Returns
-        -------
-        tuple
-            Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
-        """
-        return self._clip_values
-
-    def _apply_preprocessing(self, x, y, fit: bool) -> tuple[Any, Any]:
-        """
-        Apply all defences and preprocessing operations on the inputs `x` and `y`. This function has to be applied to
-        all raw inputs `x` and `y` provided to the estimator.
-
-        Parameters
-        ----------
-        x : array-like
-            Input samples.
-        y : array-like
-            Target values.
-        fit : bool
-            `True` if the defences are applied during training.
-
-        Returns
-        -------
-        tuple
-            Tuple of `x` and `y` after applying the defences and standardisation.
-        """
-        if self.preprocessing_operations:
-            for preprocess in self.preprocessing_operations:
-                if fit:
-                    if preprocess.apply_fit:
-                        x, y = preprocess(x, y)
-                elif preprocess.apply_predict:
-                    x, y = preprocess(x, y)
-
-        return x, y
-
-    def _apply_postprocessing(self, preds, fit: bool) -> np.ndarray:
-        """
-        Apply all postprocessing defences on model predictions.
-
-        Parameters
-        ----------
-        preds : array-like
-            Model output to be post-processed.
-        fit : bool
-            `True` if the defences are applied during training.
-
-        Returns
-        -------
-        array-like
-            Post-processed model predictions.
-        """
-        post_preds = preds.copy()
-        if self.postprocessing_defences is not None:
-            for defence in self.postprocessing_defences:
-                if fit:
-                    if defence.apply_fit:
-                        post_preds = defence(post_preds)
-                elif defence.apply_predict:
-                    post_preds = defence(post_preds)
-
-        return post_preds
-
-    def compute_loss(self, x: np.ndarray, y: Any, **kwargs) -> np.ndarray:
-        """
-        Compute the loss of the estimator for samples `x`.
-
-        Parameters
-        ----------
-        x : array-like
-            Input samples.
-        y : array-like
-            Target values.
-
-        Returns
-        -------
-        array-like
-            Loss values.
-        """
-        raise NotImplementedError
-
-    def compute_loss_from_predictions(self, pred: np.ndarray, y: np.ndarray, **kwargs) -> np.ndarray:
-        """
-        Compute the loss of the estimator for predictions `pred`.
-
-        Parameters
-        ----------
-        pred : array-like
-            Model predictions.
-        y : array-like
-            Target values.
-
-        Returns
-        -------
-        array-like
-            Loss values.
-        """
-        raise NotImplementedError
-
-    def __repr__(self):
-        class_name = self.__class__.__name__
-        attributes = {}
-        for k, value in self.__dict__.items():
-            k = k[1:] if k[0] == "_" else k  # noqa: PLW2901
-            attributes[k] = value
-        attributes = [f"{k}={v}" for k, v in attributes.items()]
-        repr_string = class_name + "(" + ", ".join(attributes) + ")"
-        return repr_string
-
-
-class LossGradientsMixin(ABC):
-    """
-    Mixin abstract base class defining additional functionality for estimators providing loss gradients. An estimator
-    of this type can be combined with white-box attacks. This mixin abstract base class has to be mixed in with
-    class `BaseEstimator`.
-    """
-
-    @abstractmethod
-    def loss_gradient(self, x, y, **kwargs):
-        """
-        Compute the gradient of the loss function w.r.t. `x`.
-
-        Parameters
-        ----------
-        x : array-like
-            Input samples.
-        y : array-like
-            Target values.
-
-        Returns
-        -------
-        array-like
-            Loss gradients w.r.t. `x`.
-        """
-        raise NotImplementedError
-
-    def _apply_preprocessing_gradient(self, x, gradients, fit=False):
-        """
-        Apply the backward pass to the gradients through all normalization and preprocessing defences that have been
-        applied to `x` and `y` in the forward pass. This function has to be applied to all gradients w.r.t. `x`
-        calculated by the estimator.
-
-        Parameters
-        ----------
-        x : array-like
-            Input samples.
-        gradients : array-like
-            Gradients w.r.t. `x`.
-        fit : bool
-            `True` if the defences are applied during training.
-
-        Returns
-        -------
-        array-like
-            Gradients after backward pass through normalization and preprocessing defences.
-        """
-        if self.preprocessing_operations:
-            for preprocess in self.preprocessing_operations[::-1]:
-                if fit:
-                    if preprocess.apply_fit:
-                        gradients = preprocess.estimate_gradient(x, gradients)
-                elif preprocess.apply_predict:
-                    gradients = preprocess.estimate_gradient(x, gradients)
-
-        return gradients
-
-
-class DecisionTreeMixin(ABC):
-    """
-    Mixin abstract base class defining additional functionality for decision-tree-based estimators. This mixin abstract
-    base class has to be mixed in with class `BaseEstimator`.
-    """
-
-    @abstractmethod
-    def get_trees(self):
-        """
-        Get the decision trees.
-
-        Returns
-        -------
-        list
-            A list of decision trees.
-        """
-        raise NotImplementedError
diff --git a/src/holisticai/security/attackers/attribute_inference/wrappers/regression/__init__.py b/src/holisticai/security/attackers/attribute_inference/wrappers/regression/__init__.py
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/holisticai/security/attackers/attribute_inference/wrappers/regression/regressor.py b/src/holisticai/security/attackers/attribute_inference/wrappers/regression/regressor.py
deleted file mode 100644
index e665e730..00000000
--- a/src/holisticai/security/attackers/attribute_inference/wrappers/regression/regressor.py
+++ /dev/null
@@ -1,28 +0,0 @@
-# MIT License
-#
-# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2020
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
-# Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
-# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-"""
-This module implements mixin abstract base class for all regressors in ART.
-"""
-
-from abc import ABC
-
-
-class RegressorMixin(ABC):  # noqa: B024
-    """
-    Mixin abstract Base class for ART regressors.
-    """
diff --git a/src/holisticai/security/attackers/attribute_inference/wrappers/regression/scikitlearn.py b/src/holisticai/security/attackers/attribute_inference/wrappers/regression/scikitlearn.py
deleted file mode 100644
index b983069c..00000000
--- a/src/holisticai/security/attackers/attribute_inference/wrappers/regression/scikitlearn.py
+++ /dev/null
@@ -1,417 +0,0 @@
-# MIT License
-#
-# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2021
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
-# Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
-# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-"""
-This module implements the regressors for scikit-learn models.
-"""
-
-from __future__ import annotations
-
-import logging
-import os
-import pickle
-from copy import deepcopy
-from typing import Optional
-
-import numpy as np
-from holisticai.security.attackers.attribute_inference.mitigation import config
-from holisticai.security.attackers.attribute_inference.wrappers.regression.regressor import RegressorMixin
-from holisticai.security.attackers.attribute_inference.wrappers.scikitlearn import ScikitlearnEstimator
-
-logger = logging.getLogger(__name__)
-
-
-class ScikitlearnRegressor(RegressorMixin, ScikitlearnEstimator):  # lgtm [py/missing-call-to-init]
-    """
-    Wrapper class for scikit-learn regression models.
-
-    This class supports all regression models from scikit-learn.
-
-    Parameters
-    ----------
-    model : object
-        scikit-learn regression model.
-    clip_values : tuple(float, float)
-        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
-    preprocessing_defences : `Preprocessor` or `List[Preprocessor]`
-        Preprocessing defence(s) to be applied by the classifier.
-    postprocessing_defences : `Postprocessor` or `List[Postprocessor]`
-        Postprocessing defence(s) to be applied by the classifier.
-    preprocessing : `tuple(float, float)` or `np.ndarray`
-        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data preprocessing.
-        The first value will be subtracted from the input. The input will then be divided by the second one.
-    """
-
-    estimator_params = ScikitlearnEstimator.estimator_params
-
-    def __init__(
-        self,
-        model,
-        clip_values=None,
-        preprocessing_defences=None,
-        postprocessing_defences=None,
-        preprocessing=(0.0, 1.0),
-    ) -> None:
-        super().__init__(
-            model=model,
-            clip_values=clip_values,
-            preprocessing_defences=preprocessing_defences,
-            postprocessing_defences=postprocessing_defences,
-            preprocessing=preprocessing,
-        )
-        self._input_shape = self._get_input_shape(model)
-
-    @property
-    def input_shape(self) -> tuple[int, ...]:
-        """
-        Return the shape of one input sample.
-
-        Returns
-        -------
-        np.ndarray
-            Shape of one input sample.
-        """
-        return self._input_shape  # type: ignore
-
-    def fit(self, x: np.ndarray, y: np.ndarray, **kwargs) -> None:
-        """
-        Fit the regressor on the training set `(x, y)`.
-
-        Parameters
-        ----------
-        x : `np.ndarray`
-            Training data.
-        y : `np.ndarray`
-            Target values.
-        kwargs : `dict`
-            Dictionary of framework-specific arguments. These should be parameters supported by the `fit` function in
-            `sklearn` regressor and will be passed to this function as such.
-        """
-        # Apply preprocessing
-        x_preprocessed, y_preprocessed = self._apply_preprocessing(x, y, fit=True)
-
-        self.model.fit(x_preprocessed, y_preprocessed, **kwargs)
-        self._input_shape = self._get_input_shape(self.model)
-
-    def predict(self, x: np.ndarray, **kwargs) -> np.ndarray:  # noqa: ARG002
-        """
-        Perform prediction for a batch of inputs.
-
-        Parameters
-        ----------
-        x : `np.ndarray`
-            Input samples.
-        kwargs : `dict`
-            Dictionary of framework-specific arguments. These should be parameters supported by the `predict` function in
-            `sklearn` regressor and will be passed to this function as such.
-
-        Returns
-        -------
-        `np.ndarray`
-            Array of predictions.
-        """
-        # Apply defences
-        x_preprocessed, _ = self._apply_preprocessing(x, y=None, fit=False)
-
-        if callable(getattr(self.model, "predict", None)):
-            y_pred = self.model.predict(x_preprocessed)
-        else:
-            raise TypeError("The provided model does not have the method `predict`.")
-
-        # Apply postprocessing
-        predictions = self._apply_postprocessing(preds=y_pred, fit=False)
-
-        return predictions
-
-    def save(self, filename: str, path: Optional[str] = None) -> None:
-        """
-        Save a model to file in the format specific to the backend framework.
-
-        Parameters
-        ----------
-        filename : str
-            Name of the file where to store the model.
-        path : str, optional
-            Path of the folder where to store the model. If no path is specified, the model will be stored in the default
-            data location of the library `ART_DATA_PATH`.
-        """
-        full_path = os.path.join(config.ART_DATA_PATH, filename) if path is None else os.path.join(path, filename)
-        folder = os.path.split(full_path)[0]
-        if not os.path.exists(folder):
-            os.makedirs(folder)
-
-        with open(full_path + ".pickle", "wb") as file_pickle:
-            pickle.dump(self.model, file=file_pickle)
-
-    def clone_for_refitting(self):  # lgtm [py/inheritance/incorrect-overridden-signature]
-        """
-        Create a copy of the classifier that can be refit from scratch.
-
-        Returns
-        -------
-        `Regressor`
-            New estimator.
-        """
-        import sklearn  # lgtm [py/repeated-import]
-
-        clone = type(self)(sklearn.base.clone(self.model))
-        params = self.get_params()
-        del params["model"]
-        clone.set_params(**params)
-        return clone
-
-    def reset(self) -> None:
-        """
-        Resets the weights of the classifier so that it can be refit from scratch.
-
-        """
-        # No need to do anything since scikitlearn models start from scratch each time fit() is called
-
-    def compute_loss(self, x: np.ndarray, y: np.ndarray, **kwargs) -> np.ndarray:  # noqa: ARG002
-        """
-        Compute the MSE loss of the regressor for samples `x`.
-
-        Parameters
-        ----------
-        x : `np.ndarray`
-            Input samples.
-        y : `np.ndarray`
-            Target values.
-
-        Returns
-        -------
-        `np.ndarray`
-            Loss values.
-        """
-
-        return (y - self.predict(x)) ** 2
-
-    def compute_loss_from_predictions(self, pred: np.ndarray, y: np.ndarray, **kwargs) -> np.ndarray:  # noqa: ARG002
-        """
-        Compute the MSE loss of the regressor for predictions `pred`.
-
-        Parameters
-        ----------
-        pred : `np.ndarray`
-            Model predictions.
-        y : `np.ndarray`
-            Target values.
-
-        Returns
-        -------
-        `np.ndarray`
-            Loss values.
-        """
-
-        return (y - pred) ** 2
-
-
-class ScikitlearnDecisionTreeRegressor(ScikitlearnRegressor):
-    """
-    Wrapper class for scikit-learn Decision Tree Regressor models.
-
-    This class supports all Decision Tree Regressor models from scikit-learn.
-
-    Parameters
-    ----------
-    model : object
-        scikit-learn Decision Tree Regressor model.
-    clip_values : tuple(float, float)
-        Tuple of the form `(min, max)` representing the minimum and maximum values allowed for features.
-    preprocessing_defences : `Preprocessor` or `List[Preprocessor]`
-        Preprocessing defence(s) to be applied by the classifier.
-    postprocessing_defences : `Postprocessor` or `List[Postprocessor]`
-        Postprocessing defence(s) to be applied by the classifier.
-    preprocessing : `tuple(float, float)` or `np.ndarray`
-        Tuple of the form `(subtrahend, divisor)` of floats or `np.ndarray` of values to be used for data preprocessing.
-        The first value will be subtracted from the input. The input will then be divided by the second one.
-    """
-
-    def __init__(
-        self,
-        model,
-        clip_values=None,
-        preprocessing_defences=None,
-        postprocessing_defences=None,
-        preprocessing=(0.0, 1.0),
-    ) -> None:
-        super().__init__(
-            model=model,
-            clip_values=clip_values,
-            preprocessing_defences=preprocessing_defences,
-            postprocessing_defences=postprocessing_defences,
-            preprocessing=preprocessing,
-        )
-        self._model = model
-
-    def get_values_at_node(self, node_id: int) -> np.ndarray:
-        """
-        Returns the feature of given id for a node.
-
-        Parameters
-        ----------
-        node_id : int
-            Node id.
-
-        Returns
-        -------
-        np.ndarray
-            Normalized values at node node_id.
-        """
-        return self.model.tree_.value[node_id]
-
-    def get_left_child(self, node_id: int) -> int:
-        """
-        Returns the id of the left child node of node_id.
-
-        Parameters
-        ----------
-        node_id : int
-            Node id.
-
-        Returns
-        -------
-        int
-            The indices of the left child in the tree.
-        """
-        return self.model.tree_.children_left[node_id]
-
-    def get_right_child(self, node_id: int) -> int:
-        """
-        Returns the id of the right child node of node_id.
-
-        Parameters
-        ----------
-        node_id : int
-            Node id.
-
-        Returns
-        -------
-        int
-            The indices of the right child in the tree.
-        """
-        return self.model.tree_.children_right[node_id]
-
-    def get_decision_path(self, x: np.ndarray) -> np.ndarray:
-        """
-        Returns the path through nodes in the tree when classifying x. Last one is leaf, first one root node.
-
-        Parameters
-        ----------
-        x : `np.ndarray`
-            Input sample.
-
-        Returns
-        -------
-        np.ndarray
-            The indices of the nodes in the array structure of the tree.
-        """
-        if len(np.shape(x)) == 1:
-            return self.model.decision_path(x.reshape(1, -1)).indices
-
-        return self.model.decision_path(x).indices
-
-    def get_threshold_at_node(self, node_id: int) -> float:
-        """
-        Returns the threshold of given id for a node.
-
-        Parameters
-        ----------
-        node_id : int
-            Node id.
-
-        Returns
-        -------
-        float
-            Threshold value of feature split in this node.
-        """
-        return self.model.tree_.threshold[node_id]
-
-    def get_feature_at_node(self, node_id: int) -> int:
-        """
-        Returns the feature of given id for a node.
-
-        Parameters
-        ----------
-        node_id : int
-            Node id.
-
-        Returns
-        -------
-        int
-            Feature index of feature split in this node.
-        """
-        return self.model.tree_.feature[node_id]
-
-    def get_samples_at_node(self, node_id: int) -> int:
-        """
-        Returns the number of training samples mapped to a node.
-
-        Parameters
-        ----------
-        node_id : int
-            Node id.
-
-        Returns
-        -------
-        int
-            Number of samples mapped this node.
-        """
-        return self.model.tree_.n_node_samples[node_id]
-
-    def _get_leaf_nodes(self, node_id, i_tree, class_label, box):
-        from holisticai.security.attackers.attribute_inference.mitigation.verification_decisions_trees import (
-            Box,
-            Interval,
-            LeafNode,
-        )
-
-        leaf_nodes: list[LeafNode] = []
-
-        if self.get_left_child(node_id) != self.get_right_child(node_id):
-            node_left = self.get_left_child(node_id)
-            node_right = self.get_right_child(node_id)
-
-            box_left = deepcopy(box)
-            box_right = deepcopy(box)
-
-            feature = self.get_feature_at_node(node_id)
-            box_split_left = Box(intervals={feature: Interval(-np.inf, self.get_threshold_at_node(node_id))})
-            box_split_right = Box(intervals={feature: Interval(self.get_threshold_at_node(node_id), np.inf)})
-
-            if box.intervals:
-                box_left.intersect_with_box(box_split_left)
-                box_right.intersect_with_box(box_split_right)
-            else:
-                box_left = box_split_left
-                box_right = box_split_right
-
-            leaf_nodes += self._get_leaf_nodes(node_left, i_tree, class_label, box_left)
-            leaf_nodes += self._get_leaf_nodes(node_right, i_tree, class_label, box_right)
-
-        else:
-            leaf_nodes.append(
-                LeafNode(
-                    tree_id=i_tree,
-                    class_label=class_label,
-                    node_id=node_id,
-                    box=box,
-                    value=self.get_values_at_node(node_id)[0, 0],
-                )
-            )
-
-        return leaf_nodes
diff --git a/src/holisticai/security/attackers/attribute_inference/wrappers/scikitlearn.py b/src/holisticai/security/attackers/attribute_inference/wrappers/scikitlearn.py
deleted file mode 100644
index dfa328ec..00000000
--- a/src/holisticai/security/attackers/attribute_inference/wrappers/scikitlearn.py
+++ /dev/null
@@ -1,54 +0,0 @@
-# MIT License
-#
-# Copyright (C) The Adversarial Robustness Toolbox (ART) Authors 2020
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
-# documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
-# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit
-# persons to whom the Software is furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
-# Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
-# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-"""
-This module implements the abstract estimator for scikit-learn models.
-"""
-
-from __future__ import annotations
-
-import logging
-from typing import Optional
-
-from holisticai.security.attackers.attribute_inference.wrappers.estimator import BaseEstimator
-
-logger = logging.getLogger(__name__)
-
-
-class ScikitlearnEstimator(BaseEstimator):
-    """
-    Estimator class for scikit-learn models.
-    """
-
-    def _get_input_shape(self, model) -> Optional[tuple[int, ...]]:
-        _input_shape: Optional[tuple[int, ...]]
-        if hasattr(model, "n_features_"):
-            _input_shape = (model.n_features_,)
-        elif hasattr(model, "n_features_in_"):
-            _input_shape = (model.n_features_in_,)
-        elif hasattr(model, "feature_importances_"):
-            _input_shape = (len(model.feature_importances_),)
-        elif hasattr(model, "coef_"):
-            _input_shape = (model.coef_.shape[0],) if len(model.coef_.shape) == 1 else (model.coef_.shape[1],)
-        elif hasattr(model, "support_vectors_"):
-            _input_shape = (model.support_vectors_.shape[1],)
-        elif hasattr(model, "steps"):
-            _input_shape = self._get_input_shape(model.steps[-1][1].obj)
-        else:
-            logger.warning("Input shape not recognised. The model might not have been fitted.")
-            _input_shape = None
-        return _input_shape

From 1ff41af73c96a6b99b705bbddfcb5305af776d76 Mon Sep 17 00:00:00 2001
From: franklincf <fracarfer5@gmail.com>
Date: Wed, 7 May 2025 19:47:11 -0300
Subject: [PATCH 33/34] refactor: updating tutorials

---
 .../classification/baseline.ipynb             |  4 +-
 .../classification/black_box.ipynb            | 41 ++++++++++-------
 .../classification/white_box.ipynb            | 40 ++++++++---------
 .../classification/white_box_lifestyle.ipynb  | 30 ++++++-------
 .../regression/baseline.ipynb                 | 32 +++++++-------
 .../regression/black_box.ipynb                | 41 ++++++++---------
 .../regression/true_label.ipynb               | 44 +++++++++----------
 .../regression/white_box.ipynb                | 12 ++---
 8 files changed, 116 insertions(+), 128 deletions(-)

diff --git a/tutorials/security/attribute_inference_attacks/classification/baseline.ipynb b/tutorials/security/attribute_inference_attacks/classification/baseline.ipynb
index 8afb6ce7..9c10a107 100644
--- a/tutorials/security/attribute_inference_attacks/classification/baseline.ipynb
+++ b/tutorials/security/attribute_inference_attacks/classification/baseline.ipynb
@@ -520,7 +520,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -541,7 +541,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
diff --git a/tutorials/security/attribute_inference_attacks/classification/black_box.ipynb b/tutorials/security/attribute_inference_attacks/classification/black_box.ipynb
index 6d67bda1..09775eb7 100644
--- a/tutorials/security/attribute_inference_attacks/classification/black_box.ipynb
+++ b/tutorials/security/attribute_inference_attacks/classification/black_box.ipynb
@@ -13,12 +13,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
     "import numpy as np\n",
-    "from holisticai.security.attackers.attribute_inference.wrappers.classification.scikitlearn import SklearnClassifier\n",
     "from holisticai.datasets import load_dataset\n",
     "from holisticai.security.attackers.attribute_inference.black_box import AttributeInferenceBlackBox"
    ]
@@ -305,15 +304,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/franklin/.local/share/hatch/env/virtual/holisticai/Rsz3flyg/testing/lib/python3.10/site-packages/sklearn/neural_network/_multilayer_perceptron.py:690: ConvergenceWarning: Stochastic Optimizer: Maximum iterations (2000) reached and the optimization hasn't converged yet.\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
    "source": [
     "from sklearn.tree import DecisionTreeClassifier\n",
     "\n",
     "classifier = DecisionTreeClassifier()\n",
     "classifier.fit(x_train, y_train)\n",
-    "classifier = SklearnClassifier(classifier)\n",
     "\n",
     "attack = AttributeInferenceBlackBox(estimator=classifier, attack_feature=attack_feature)\n",
     "\n",
@@ -340,7 +347,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -376,27 +383,27 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>Accuracy</th>\n",
-       "      <td>0.915000</td>\n",
+       "      <td>0.930000</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>Balanced Accuracy</th>\n",
-       "      <td>0.845709</td>\n",
+       "      <td>0.893563</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>Precision</th>\n",
-       "      <td>0.920245</td>\n",
+       "      <td>0.948718</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>Recall</th>\n",
-       "      <td>0.974026</td>\n",
+       "      <td>0.961039</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>F1-Score</th>\n",
-       "      <td>0.946372</td>\n",
+       "      <td>0.954839</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
@@ -406,14 +413,14 @@
       "text/plain": [
        "                      Value  Reference\n",
        "Metric                                \n",
-       "Accuracy           0.915000          1\n",
-       "Balanced Accuracy  0.845709          1\n",
-       "Precision          0.920245          1\n",
-       "Recall             0.974026          1\n",
-       "F1-Score           0.946372          1"
+       "Accuracy           0.930000          1\n",
+       "Balanced Accuracy  0.893563          1\n",
+       "Precision          0.948718          1\n",
+       "Recall             0.961039          1\n",
+       "F1-Score           0.954839          1"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
diff --git a/tutorials/security/attribute_inference_attacks/classification/white_box.ipynb b/tutorials/security/attribute_inference_attacks/classification/white_box.ipynb
index dd882762..0f7ceadf 100644
--- a/tutorials/security/attribute_inference_attacks/classification/white_box.ipynb
+++ b/tutorials/security/attribute_inference_attacks/classification/white_box.ipynb
@@ -19,10 +19,7 @@
    "source": [
     "import numpy as np\n",
     "from holisticai.datasets import load_dataset\n",
-    "from holisticai.security.attackers.attribute_inference.wrappers.classification.scikitlearn import ScikitlearnDecisionTreeClassifier\n",
-    "from holisticai.security.attackers.attribute_inference.mitigation.scikitlearn import (\n",
-    "    AttributeInferenceWhiteBoxDecisionTree,\n",
-    ")"
+    "from holisticai.security.attackers.attribute_inference.white_box import AttributeInferenceWhiteBoxDecisionTree"
    ]
   },
   {
@@ -260,7 +257,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
@@ -269,7 +266,7 @@
        "((array([0, 1]), array([ 46, 154])), 200)"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -288,7 +285,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -308,7 +305,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -328,7 +325,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -336,7 +333,6 @@
     "\n",
     "classifier = DecisionTreeClassifier()\n",
     "classifier.fit(x_train, y_train)\n",
-    "classifier = ScikitlearnDecisionTreeClassifier(classifier)\n",
     "\n",
     "attack = AttributeInferenceWhiteBoxDecisionTree(classifier=classifier, attack_feature=attack_feature)\n",
     "\n",
@@ -361,7 +357,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
@@ -397,27 +393,27 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>Accuracy</th>\n",
-       "      <td>0.710000</td>\n",
+       "      <td>0.715000</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>Balanced Accuracy</th>\n",
-       "      <td>0.476285</td>\n",
+       "      <td>0.479531</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>Precision</th>\n",
-       "      <td>0.760870</td>\n",
+       "      <td>0.762162</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>Recall</th>\n",
-       "      <td>0.909091</td>\n",
+       "      <td>0.915584</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>F1-Score</th>\n",
-       "      <td>0.828402</td>\n",
+       "      <td>0.831858</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
@@ -427,14 +423,14 @@
       "text/plain": [
        "                      Value  Reference\n",
        "Metric                                \n",
-       "Accuracy           0.710000          1\n",
-       "Balanced Accuracy  0.476285          1\n",
-       "Precision          0.760870          1\n",
-       "Recall             0.909091          1\n",
-       "F1-Score           0.828402          1"
+       "Accuracy           0.715000          1\n",
+       "Balanced Accuracy  0.479531          1\n",
+       "Precision          0.762162          1\n",
+       "Recall             0.915584          1\n",
+       "F1-Score           0.831858          1"
       ]
      },
-     "execution_count": 11,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     }
diff --git a/tutorials/security/attribute_inference_attacks/classification/white_box_lifestyle.ipynb b/tutorials/security/attribute_inference_attacks/classification/white_box_lifestyle.ipynb
index 8190fec3..089f0a8c 100644
--- a/tutorials/security/attribute_inference_attacks/classification/white_box_lifestyle.ipynb
+++ b/tutorials/security/attribute_inference_attacks/classification/white_box_lifestyle.ipynb
@@ -13,16 +13,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "import numpy as np\n",
     "from holisticai.datasets import load_dataset\n",
-    "from holisticai.security.attackers.attribute_inference.wrappers.classification.scikitlearn import ScikitlearnDecisionTreeClassifier\n",
-    "from holisticai.security.attackers.attribute_inference.mitigation.attacks.white_box_lifestyle_decision_tree import (\n",
-    "    AttributeInferenceWhiteBoxLifestyleDecisionTree\n",
-    ")"
+    "from holisticai.security.attackers.attribute_inference.white_box_lifestyle import AttributeInferenceWhiteBoxLifestyleDecisionTree"
    ]
   },
   {
@@ -328,7 +325,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -336,7 +333,6 @@
     "\n",
     "classifier = DecisionTreeClassifier()\n",
     "classifier.fit(x_train, y_train)\n",
-    "classifier = ScikitlearnDecisionTreeClassifier(classifier)\n",
     "\n",
     "attack = AttributeInferenceWhiteBoxLifestyleDecisionTree(estimator=classifier, attack_feature=attack_feature)\n",
     "\n",
@@ -397,27 +393,27 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>Accuracy</th>\n",
-       "      <td>0.735000</td>\n",
+       "      <td>0.730000</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>Balanced Accuracy</th>\n",
-       "      <td>0.500141</td>\n",
+       "      <td>0.496894</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>Precision</th>\n",
-       "      <td>0.770053</td>\n",
+       "      <td>0.768817</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>Recall</th>\n",
-       "      <td>0.935065</td>\n",
+       "      <td>0.928571</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>F1-Score</th>\n",
-       "      <td>0.844575</td>\n",
+       "      <td>0.841176</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
@@ -427,11 +423,11 @@
       "text/plain": [
        "                      Value  Reference\n",
        "Metric                                \n",
-       "Accuracy           0.735000          1\n",
-       "Balanced Accuracy  0.500141          1\n",
-       "Precision          0.770053          1\n",
-       "Recall             0.935065          1\n",
-       "F1-Score           0.844575          1"
+       "Accuracy           0.730000          1\n",
+       "Balanced Accuracy  0.496894          1\n",
+       "Precision          0.768817          1\n",
+       "Recall             0.928571          1\n",
+       "F1-Score           0.841176          1"
       ]
      },
      "execution_count": 8,
diff --git a/tutorials/security/attribute_inference_attacks/regression/baseline.ipynb b/tutorials/security/attribute_inference_attacks/regression/baseline.ipynb
index 7e61457c..d3b96047 100644
--- a/tutorials/security/attribute_inference_attacks/regression/baseline.ipynb
+++ b/tutorials/security/attribute_inference_attacks/regression/baseline.ipynb
@@ -456,7 +456,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -469,7 +469,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -482,7 +482,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -526,7 +526,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
@@ -562,27 +562,27 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>Accuracy</th>\n",
-       "      <td>0.977444</td>\n",
+       "      <td>0.974937</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>Balanced Accuracy</th>\n",
-       "      <td>0.945575</td>\n",
+       "      <td>0.950959</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>Precision</th>\n",
-       "      <td>0.982456</td>\n",
+       "      <td>0.985251</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>Recall</th>\n",
-       "      <td>0.991150</td>\n",
+       "      <td>0.985251</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>F1-Score</th>\n",
-       "      <td>0.986784</td>\n",
+       "      <td>0.985251</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
@@ -592,14 +592,14 @@
       "text/plain": [
        "                      Value  Reference\n",
        "Metric                                \n",
-       "Accuracy           0.977444          1\n",
-       "Balanced Accuracy  0.945575          1\n",
-       "Precision          0.982456          1\n",
-       "Recall             0.991150          1\n",
-       "F1-Score           0.986784          1"
+       "Accuracy           0.974937          1\n",
+       "Balanced Accuracy  0.950959          1\n",
+       "Precision          0.985251          1\n",
+       "Recall             0.985251          1\n",
+       "F1-Score           0.985251          1"
       ]
      },
-     "execution_count": 10,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -614,7 +614,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "As we can see, our attack achieved an accuracy of 0.977, which means that the attack was able to infer the 'group_a' attribute with an accuracy of 97.7%. This high accuracy indicates that the target model is leaking information about the 'group_a' attribute, which can be a privacy concern."
+    "As we can see, our attack achieved an accuracy around of 0.97, which means that the attack was able to infer the 'group_a' attribute with an accuracy of 97%. This high accuracy indicates that the target model is leaking information about the 'group_a' attribute, which can be a privacy concern."
    ]
   },
   {
diff --git a/tutorials/security/attribute_inference_attacks/regression/black_box.ipynb b/tutorials/security/attribute_inference_attacks/regression/black_box.ipynb
index 1511c581..58b90e4b 100644
--- a/tutorials/security/attribute_inference_attacks/regression/black_box.ipynb
+++ b/tutorials/security/attribute_inference_attacks/regression/black_box.ipynb
@@ -18,15 +18,13 @@
    "outputs": [],
    "source": [
     "import numpy as np\n",
-    "from holisticai.security.attackers.attribute_inference.dataset_utils import AttackDataset\n",
-    "from holisticai.security.attackers.attribute_inference.wrappers.regression.scikitlearn import ScikitlearnRegressor\n",
     "from holisticai.datasets import load_dataset\n",
     "from holisticai.security.attackers.attribute_inference.black_box import AttributeInferenceBlackBox"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
@@ -218,7 +216,7 @@
        "{\"dtype\":\"Dataset\",\"attributes\":{\"Instances\":1594,\"Features\":[\"X , y , p_attrs , group_a , group_b\"]},\"metadata\":\"race: {'group_a': 'racePctWhite>0.5', 'group_b': 'racePctWhite<=0.5'}\"}"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 2,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -233,7 +231,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
@@ -438,7 +436,7 @@
        "[5 rows x 101 columns]"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -458,7 +456,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -471,7 +469,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -484,7 +482,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -502,7 +500,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -515,9 +513,6 @@
     "\n",
     "regressor.fit(x_train, y_train)\n",
     "\n",
-    "# regressor = train_holisticai_regressor(x_train, y_train)\n",
-    "regressor = ScikitlearnRegressor(regressor)\n",
-    "\n",
     "attack = AttributeInferenceBlackBox(estimator=regressor, attack_feature=attack_feature, scale_range=(0,1))\n",
     "\n",
     "pred = regressor.predict(x_train)\n",
@@ -545,7 +540,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
@@ -586,22 +581,22 @@
        "    </tr>\n",
        "    <tr>\n",
        "      <th>Balanced Accuracy</th>\n",
-       "      <td>0.927434</td>\n",
+       "      <td>0.913717</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>Precision</th>\n",
-       "      <td>0.976676</td>\n",
+       "      <td>0.971182</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>Recall</th>\n",
-       "      <td>0.988201</td>\n",
+       "      <td>0.994100</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>F1-Score</th>\n",
-       "      <td>0.982405</td>\n",
+       "      <td>0.982507</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
@@ -612,13 +607,13 @@
        "                      Value  Reference\n",
        "Metric                                \n",
        "Accuracy           0.969925          1\n",
-       "Balanced Accuracy  0.927434          1\n",
-       "Precision          0.976676          1\n",
-       "Recall             0.988201          1\n",
-       "F1-Score           0.982405          1"
+       "Balanced Accuracy  0.913717          1\n",
+       "Precision          0.971182          1\n",
+       "Recall             0.994100          1\n",
+       "F1-Score           0.982507          1"
       ]
      },
-     "execution_count": 13,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     }
diff --git a/tutorials/security/attribute_inference_attacks/regression/true_label.ipynb b/tutorials/security/attribute_inference_attacks/regression/true_label.ipynb
index 0869d352..ec588feb 100644
--- a/tutorials/security/attribute_inference_attacks/regression/true_label.ipynb
+++ b/tutorials/security/attribute_inference_attacks/regression/true_label.ipynb
@@ -18,15 +18,13 @@
    "outputs": [],
    "source": [
     "import numpy as np\n",
-    "from holisticai.security.attackers.attribute_inference.dataset_utils import AttackDataset\n",
-    "from holisticai.security.attackers.attribute_inference.wrappers.regression.scikitlearn import ScikitlearnRegressor\n",
     "from holisticai.datasets import load_dataset\n",
     "from holisticai.security.attackers.attribute_inference.true_label_baseline import AttributeInferenceBaselineTrueLabel"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
@@ -218,7 +216,7 @@
        "{\"dtype\":\"Dataset\",\"attributes\":{\"Instances\":1594,\"Features\":[\"X , y , p_attrs , group_a , group_b\"]},\"metadata\":\"race: {'group_a': 'racePctWhite>0.5', 'group_b': 'racePctWhite<=0.5'}\"}"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 2,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -233,7 +231,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
@@ -438,7 +436,7 @@
        "[5 rows x 101 columns]"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -458,7 +456,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -471,7 +469,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -484,7 +482,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -502,7 +500,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -529,7 +527,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
@@ -565,27 +563,27 @@
        "  <tbody>\n",
        "    <tr>\n",
        "      <th>Accuracy</th>\n",
-       "      <td>0.977444</td>\n",
+       "      <td>0.967419</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>Balanced Accuracy</th>\n",
-       "      <td>0.952434</td>\n",
+       "      <td>0.939676</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>Precision</th>\n",
-       "      <td>0.985294</td>\n",
+       "      <td>0.982249</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>Recall</th>\n",
-       "      <td>0.988201</td>\n",
+       "      <td>0.979351</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>F1-Score</th>\n",
-       "      <td>0.986745</td>\n",
+       "      <td>0.980798</td>\n",
        "      <td>1</td>\n",
        "    </tr>\n",
        "  </tbody>\n",
@@ -595,14 +593,14 @@
       "text/plain": [
        "                      Value  Reference\n",
        "Metric                                \n",
-       "Accuracy           0.977444          1\n",
-       "Balanced Accuracy  0.952434          1\n",
-       "Precision          0.985294          1\n",
-       "Recall             0.988201          1\n",
-       "F1-Score           0.986745          1"
+       "Accuracy           0.967419          1\n",
+       "Balanced Accuracy  0.939676          1\n",
+       "Precision          0.982249          1\n",
+       "Recall             0.979351          1\n",
+       "F1-Score           0.980798          1"
       ]
      },
-     "execution_count": 13,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -617,7 +615,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "As we can see, our attack achieved an accuracy of 0.977, which means that the attack was able to infer the 'group_a' attribute with an accuracy of 97.7%. This high accuracy indicates that the target model is leaking information about the 'group_a' attribute, which can be a privacy concern."
+    "As we can see, our attack achieved an accuracy of 0.967, which means that the attack was able to infer the 'group_a' attribute with an accuracy of 96.7%. This high accuracy indicates that the target model is leaking information about the 'group_a' attribute, which can be a privacy concern."
    ]
   },
   {
diff --git a/tutorials/security/attribute_inference_attacks/regression/white_box.ipynb b/tutorials/security/attribute_inference_attacks/regression/white_box.ipynb
index a257285f..e52f89dd 100644
--- a/tutorials/security/attribute_inference_attacks/regression/white_box.ipynb
+++ b/tutorials/security/attribute_inference_attacks/regression/white_box.ipynb
@@ -19,10 +19,7 @@
    "source": [
     "import numpy as np\n",
     "from holisticai.datasets import load_dataset\n",
-    "from holisticai.security.attackers.attribute_inference.wrappers.regression.scikitlearn import ScikitlearnDecisionTreeRegressor\n",
-    "from holisticai.security.attackers.attribute_inference.mitigation.attacks.white_box_lifestyle_decision_tree import (\n",
-    "    AttributeInferenceWhiteBoxLifestyleDecisionTree\n",
-    ")"
+    "from holisticai.security.attackers.attribute_inference.white_box_lifestyle import AttributeInferenceWhiteBoxLifestyleDecisionTree"
    ]
   },
   {
@@ -459,7 +456,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -492,7 +489,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -505,7 +502,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -534,7 +531,6 @@
     "regressor = DecisionTreeRegressor()\n",
     "regressor.fit(x_train, y_train)\n",
     "\n",
-    "regressor = ScikitlearnDecisionTreeRegressor(regressor)\n",
     "attack = AttributeInferenceWhiteBoxLifestyleDecisionTree(estimator=regressor, attack_feature=attack_feature)\n",
     "\n",
     "attack_x_test = np.delete(x_test, attack_feature, axis=1)\n",

From 28c08b11ab7f5c21cafbc650f4c8d2285baf857b Mon Sep 17 00:00:00 2001
From: franklincf <fracarfer5@gmail.com>
Date: Wed, 7 May 2025 19:48:13 -0300
Subject: [PATCH 34/34] refactor: updating attribute inference attackers

---
 .../attackers/attribute_inference/__init__.py |  13 +-
 .../attackers/attribute_inference/baseline.py |  57 ++----
 .../attribute_inference/black_box.py          |  31 +---
 .../true_label_baseline.py                    |  62 ++-----
 .../attribute_inference/white_box.py          | 169 +++++++++++++++++
 .../white_box_lifestyle.py                    | 171 ++++++++++++++++++
 6 files changed, 384 insertions(+), 119 deletions(-)
 create mode 100644 src/holisticai/security/attackers/attribute_inference/white_box.py
 create mode 100644 src/holisticai/security/attackers/attribute_inference/white_box_lifestyle.py

diff --git a/src/holisticai/security/attackers/attribute_inference/__init__.py b/src/holisticai/security/attackers/attribute_inference/__init__.py
index 5417c02c..9212499f 100644
--- a/src/holisticai/security/attackers/attribute_inference/__init__.py
+++ b/src/holisticai/security/attackers/attribute_inference/__init__.py
@@ -1,6 +1,9 @@
-from holisticai.security.attackers.attribute_inference.baseline import (
-    AttributeInferenceAttack,
-    AttributeInferenceBaseline,
-)
+from holisticai.security.attackers.attribute_inference.baseline import AttributeInferenceBaseline
+from holisticai.security.attackers.attribute_inference.black_box import AttributeInferenceBlackBox
+from holisticai.security.attackers.attribute_inference.white_box_lifestyle import AttributeInferenceWhiteBoxLifestyleDecisionTree
+from holisticai.security.attackers.attribute_inference.white_box import AttributeInferenceWhiteBoxDecisionTree
 
-__all__ = ["AttributeInferenceAttack", "AttributeInferenceBaseline"]
+__all__ = ["AttributeInferenceBaseline", 
+           "AttributeInferenceBlackBox",
+           "AttributeInferenceWhiteBoxDecisionTree",
+           "AttributeInferenceWhiteBoxLifestyleDecisionTree"]
diff --git a/src/holisticai/security/attackers/attribute_inference/baseline.py b/src/holisticai/security/attackers/attribute_inference/baseline.py
index c6cf3e80..35d9fd23 100644
--- a/src/holisticai/security/attackers/attribute_inference/baseline.py
+++ b/src/holisticai/security/attackers/attribute_inference/baseline.py
@@ -1,54 +1,44 @@
-# from typing import Optional, Union, TYPE_CHECKING
 import numpy as np
-from holisticai.security.attackers.attribute_inference.attack import AttributeInferenceAttack
 from holisticai.security.attackers.attribute_inference.dataset_utils import AttributeInferenceDataPreprocessor
 from holisticai.security.attackers.attribute_inference.utils import get_attack_model, get_feature_index
-from sklearn.base import ClassifierMixin
 
 
-class AttributeInferenceBaseline(AttributeInferenceAttack):
+class AttributeInferenceBaseline():
     """
-    Implementation of a baseline attribute inference, not using a model.
-
-    The idea is to train a simple neural network to learn the attacked feature from the rest of the features. Should
-    be used to compare with other attribute inference results.
-
+    Attribute Inference Attack using a baseline model.
+    
+    This attack uses a baseline model to infer the value of a specific feature in the dataset.
+    The attack model is trained on the remaining features in the dataset.
+    
     Parameters
     ----------
-    attack_model_type : str
-        The type of default attack model to train, optional. Should be one of `nn` (for neural network, default) or `rf`
-        (for random forest). If `attack_model` is supplied, this option will be ignored.
-    attack_model : object
-        The attack model to train, optional. If none is provided, a default model will be created.
-    attack_feature : int or slice
-        The index of the feature to be attacked or a slice representing multiple indexes in case of a one-hot encoded
-        feature.
+    attack_model_type : str, default="nn"
+        The type of model to use for the attack. Options are "nn" for neural network or "tree" for decision tree.
+    attack_feature : int or slice, default=0
+        The index or slice of the feature to attack. If a slice is provided, it should be of size 1.
     """
-
-    _estimator_requirements = ()
-
     def __init__(
         self,
         attack_model_type="nn",
-        attack_model=None,
         attack_feature=0,
     ):
-        super().__init__(estimator=None, attack_feature=attack_feature)
-
         self._values = None
         self._nb_classes = None
 
-        if attack_model:
-            if ClassifierMixin not in type(attack_model).__mro__:
-                raise ValueError("Attack model must be of type Classifier.")
-            self.attack_model = attack_model
-        else:
-            self.attack_model = get_attack_model(attack_model_type)
+        self.attack_model = get_attack_model(attack_model_type)
+        self.attack_feature = attack_feature
 
         self._check_params()
         self.attack_feature = get_feature_index(self.attack_feature)
         self.ai_preprocessor = AttributeInferenceDataPreprocessor(attack_feature=attack_feature)
 
+    def _check_params(self) -> None:
+        if not isinstance(self.attack_feature, int) and not isinstance(self.attack_feature, slice):
+            raise TypeError("Attack feature must be either an integer or a slice object.")
+
+        if isinstance(self.attack_feature, int) and self.attack_feature < 0:
+            raise ValueError("Attack feature index must be non-negative.")
+        
     def fit(self, x: np.ndarray) -> None:
         """
         Train the attack model.
@@ -95,11 +85,4 @@ def infer(self, x: np.ndarray, **kwargs) -> np.ndarray:
                 for value, column in zip(values, predictions.T):
                     for index in range(len(value)):
                         np.place(column, [column == index], value[index])
-        return np.array(predictions)
-
-    def _check_params(self) -> None:
-        if not isinstance(self.attack_feature, int) and not isinstance(self.attack_feature, slice):
-            raise TypeError("Attack feature must be either an integer or a slice object.")
-
-        if isinstance(self.attack_feature, int) and self.attack_feature < 0:
-            raise ValueError("Attack feature index must be non-negative.")
+        return np.array(predictions)
\ No newline at end of file
diff --git a/src/holisticai/security/attackers/attribute_inference/black_box.py b/src/holisticai/security/attackers/attribute_inference/black_box.py
index e5a401c9..9b775738 100644
--- a/src/holisticai/security/attackers/attribute_inference/black_box.py
+++ b/src/holisticai/security/attackers/attribute_inference/black_box.py
@@ -8,17 +8,13 @@
 from typing import Optional, Union
 
 import numpy as np
-from holisticai.security.attackers.attribute_inference.attack import AttributeInferenceAttack
 from holisticai.security.attackers.attribute_inference.dataset_utils import AttributeInferenceDataPreprocessor
 from holisticai.security.attackers.attribute_inference.utils import get_attack_model, get_feature_index
-from holisticai.security.attackers.attribute_inference.wrappers.classification.classifier import ClassifierMixin
-from holisticai.security.attackers.attribute_inference.wrappers.estimator import BaseEstimator
-from holisticai.security.attackers.attribute_inference.wrappers.regression.regressor import RegressorMixin
 
 logger = logging.getLogger(__name__)
 
 
-class AttributeInferenceBlackBox(AttributeInferenceAttack):
+class AttributeInferenceBlackBox():
     """
     Implementation of a simple black-box attribute inference attack.
 
@@ -47,14 +43,6 @@ class AttributeInferenceBlackBox(AttributeInferenceAttack):
         attack-model. Only applicable when `estimator` is a regressor and if `scale_range` is not supplied.
     """
 
-    attack_params = [
-        *AttributeInferenceAttack.attack_params,
-        "prediction_normal_factor",
-        "scale_range",
-        "attack_model_type",
-    ]
-    _estimator_requirements = (BaseEstimator, (ClassifierMixin, RegressorMixin))
-
     def __init__(
         self,
         estimator,
@@ -64,27 +52,20 @@ def __init__(
         scale_range: Optional[tuple[float, float]] = None,
         prediction_normal_factor: Optional[float] = 1,
     ):
-        super().__init__(estimator=estimator, attack_feature=attack_feature)
 
         self._values: Optional[list] = None
         self._nb_classes: Optional[int] = None
         self._attack_model_type = attack_model_type
         self._attack_model = attack_model
-
-        if attack_model:
-            if ClassifierMixin not in type(attack_model).__mro__:
-                raise ValueError("Attack model must be of type Classifier.")
-            self.attack_model = attack_model
-        else:
-            self.attack_model = get_attack_model(attack_model_type)
+        self.estimator = estimator
+        self.attack_feature = attack_feature
+        self.attack_model = get_attack_model(attack_model_type)
 
         self.prediction_normal_factor = prediction_normal_factor
         self.scale_range = scale_range
-        is_regression = ClassifierMixin not in type(self.estimator).__mro__
         self._check_params()
         self.attack_feature = get_feature_index(self.attack_feature)
         self.ai_preprocessor = AttributeInferenceDataPreprocessor(
-            is_regression=is_regression,
             scale_range=scale_range,
             prediction_normal_factor=prediction_normal_factor,
             attack_feature=attack_feature,
@@ -104,7 +85,6 @@ def fit(self, x: np.ndarray, y: Optional[np.ndarray] = None, pred: Optional[np.n
             Predictions of the original model for x.
         """
 
-        # train attack model
         attack_x, attack_y = self.ai_preprocessor.fit_transform(x, y, pred)
         self._values = self.ai_preprocessor._values  # noqa: SLF001
         self.attack_model.fit(attack_x, attack_y)
@@ -164,6 +144,3 @@ def _check_params(self) -> None:
 
         if self._attack_model_type not in ["nn", "rf"]:
             raise ValueError("Illegal value for parameter `attack_model_type`.")
-
-        if RegressorMixin not in type(self.estimator).__mro__ and self.prediction_normal_factor != 1:
-            raise ValueError("Prediction normal factor is only applicable to regressor models.")
diff --git a/src/holisticai/security/attackers/attribute_inference/true_label_baseline.py b/src/holisticai/security/attackers/attribute_inference/true_label_baseline.py
index 5ec1d363..8a48e513 100644
--- a/src/holisticai/security/attackers/attribute_inference/true_label_baseline.py
+++ b/src/holisticai/security/attackers/attribute_inference/true_label_baseline.py
@@ -8,67 +8,29 @@
 from typing import Optional, Union
 
 import numpy as np
-from holisticai.security.attackers.attribute_inference.attack import AttributeInferenceAttack
 from holisticai.security.attackers.attribute_inference.dataset_utils import AttributeInferenceDataPreprocessor
 from holisticai.security.attackers.attribute_inference.utils import get_attack_model, get_feature_index
-from sklearn.base import ClassifierMixin
 
 logger = logging.getLogger(__name__)
 
 
-class AttributeInferenceBaselineTrueLabel(AttributeInferenceAttack):
-    """
-    Implementation of a baseline attribute inference, not using a model.
-
-    The idea is to train a simple neural network to learn the attacked feature from the rest of the features, and the
-    true label. Should be used to compare with other attribute inference results.
-
-    Parameters
-    ----------
-    attack_model_type : str
-        The type of default attack model to train, optional. Should be one of `nn` (for neural network, default) or `rf`
-        (for random forest). If `attack_model` is supplied, this option will be ignored.
-    attack_model : object
-        The attack model to train, optional. If none is provided, a default model will be created.
-    attack_feature : int or slice
-        The index of the feature to be attacked or a slice representing multiple indexes in case of a one-hot encoded
-        feature.
-    is_regression : bool
-        Whether the model is a regression model. Default is False (classification).
-    scale_range : tuple
-        If supplied, the class labels (both true and predicted) will be scaled to the given range. Only applicable when
-        `is_regression` is True.
-    prediction_normal_factor : float
-        If supplied, the class labels (both true and predicted) are multiplied by the factor when used as inputs to the
-        attack-model. Only applicable when `is_regression` is True and if `scale_range` is not supplied.
-    """
-
-    _estimator_requirements = ()
-
+class AttributeInferenceBaselineTrueLabel():
     def __init__(
         self,
         attack_model_type: str = "nn",
-        attack_model=None,
         attack_feature: Union[int, slice] = 0,
         is_regression: Optional[bool] = False,
         scale_range: Optional[tuple[float, float]] = None,
         prediction_normal_factor: float = 1,
     ):
-        super().__init__(estimator=None, attack_feature=attack_feature)
-
+        
         self._values: Optional[list] = None
         self._nb_classes: Optional[int] = None
-
-        if attack_model:
-            if ClassifierMixin not in type(attack_model).__mro__:
-                raise ValueError("Attack model must be of type Classifier.")
-            self.attack_model = attack_model
-        else:
-            self.attack_model = get_attack_model(attack_model_type)
-
+        self.attack_model = get_attack_model(attack_model_type)
         self.prediction_normal_factor = prediction_normal_factor
         self.scale_range = scale_range
         self.is_regression = is_regression
+        self.attack_feature = attack_feature
         self._check_params()
         self.attack_feature = get_feature_index(self.attack_feature)
         self.ai_preprocessor = AttributeInferenceDataPreprocessor(
@@ -78,6 +40,13 @@ def __init__(
             attack_feature=attack_feature,
         )
 
+    def _check_params(self) -> None:
+        if not isinstance(self.attack_feature, int) and not isinstance(self.attack_feature, slice):
+            raise TypeError("Attack feature must be either an integer or a slice object.")
+
+        if isinstance(self.attack_feature, int) and self.attack_feature < 0:
+            raise ValueError("Attack feature index must be positive.")
+        
     def fit(self, x: np.ndarray, y: np.ndarray) -> None:
         """
         Train the attack model.
@@ -135,11 +104,4 @@ def infer(self, x: np.ndarray, y: np.ndarray, **kwargs) -> np.ndarray:
                     for index in range(len(self._values[i])):
                         np.place(column, [column == index], self._values[i][index])
                     i += 1
-        return np.array(predictions)
-
-    def _check_params(self) -> None:
-        if not isinstance(self.attack_feature, int) and not isinstance(self.attack_feature, slice):
-            raise TypeError("Attack feature must be either an integer or a slice object.")
-
-        if isinstance(self.attack_feature, int) and self.attack_feature < 0:
-            raise ValueError("Attack feature index must be positive.")
+        return np.array(predictions)
\ No newline at end of file
diff --git a/src/holisticai/security/attackers/attribute_inference/white_box.py b/src/holisticai/security/attackers/attribute_inference/white_box.py
new file mode 100644
index 00000000..17c450a4
--- /dev/null
+++ b/src/holisticai/security/attackers/attribute_inference/white_box.py
@@ -0,0 +1,169 @@
+"""
+This module implements attribute inference attacks.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+import numpy as np
+
+
+logger = logging.getLogger(__name__)
+
+
+class AttributeInferenceWhiteBoxDecisionTree():
+    """
+    A variation of the method proposed by of Fredrikson et al. in:
+    https://dl.acm.org/doi/10.1145/2810103.2813677
+
+    Assumes the availability of the attacked model's predictions for the samples under attack, in addition to access to
+    the model itself and the rest of the feature values. If this is not available, the true class label of the samples
+    may be used as a proxy. Also assumes that the attacked feature is discrete or categorical, with limited number of
+    possible values. For example: a boolean feature.
+
+    Parameters
+    ----------
+    classifier : ScikitlearnDecisionTreeClassifier
+        Target classifier.
+    attack_feature : int
+        The index of the feature to be attacked.
+
+    References
+    ----------
+    .. [1] Fredrikson, M., Jha, S., & Ristenpart, T. (2015, August). Model inversion attacks that exploit confidence
+           information and basic countermeasures. In Proceedings of the 22nd ACM SIGSAC Conference on Computer and
+           Communications Security (pp. 1322-1333).
+    """
+    def __init__(self, classifier, attack_feature: int = 0):
+        self.attack_feature: int
+        self.attack_feature = attack_feature
+        self._check_params()
+        self.estimator = classifier
+
+    def _check_params(self) -> None:
+        if self.attack_feature < 0:
+            raise ValueError("Attack feature must be positive.")
+        
+    def infer(self, x: np.ndarray, y: np.ndarray, **kwargs) -> np.ndarray:
+        """
+        Infer the attacked feature.
+
+        If the model's prediction coincides with the real prediction for the sample for a single value, choose it as the
+        predicted value. If not, fall back to the Fredrikson method (without phi)
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Input to attack. Includes all features except the attacked feature.
+        y : np.ndarray
+            Original model's predictions for x.
+        values : list
+            Possible values for attacked feature.
+        priors : list
+            Prior distributions of attacked feature values. Same size array as `values`.
+
+        Returns
+        -------
+        np.ndarray
+            The inferred feature values.
+        """
+        if "priors" not in kwargs:  # pragma: no cover
+            raise ValueError("Missing parameter `priors`.")
+        if "values" not in kwargs:  # pragma: no cover
+            raise ValueError("Missing parameter `values`.")
+        priors: Optional[list] = kwargs.get("priors")
+        values: Optional[list] = kwargs.get("values")
+
+        if priors is None or values is None:  # pragma: no cover
+            raise ValueError("`priors` and `values` are required as inputs.")
+        if len(priors) != len(values):  # pragma: no cover
+            raise ValueError("Number of priors does not match number of values")
+
+        n_values = len(values)
+        n_samples = x.shape[0]
+
+        # Will contain the model's predictions for each value
+        pred_values = []
+        # Will contain the probability of each value
+        prob_values = []
+
+        for i, value in enumerate(values):
+            # prepare data with the given value in the attacked feature
+            v_full = np.full((n_samples, 1), value).astype(x.dtype)
+            x_value = np.concatenate((x[:, : self.attack_feature], v_full), axis=1)
+            x_value = np.concatenate((x_value, x[:, self.attack_feature :]), axis=1)
+
+            # Obtain the model's prediction for each possible value of the attacked feature
+            pred_value = [np.argmax(arr) for arr in self.estimator.predict_proba(x_value)]
+            pred_values.append(pred_value)
+
+            # find the relative probability of this value for all samples being attacked
+            prob_value = [
+                (
+                    (self.get_samples_at_node(self.get_decision_path([row])[-1]) / n_samples)
+                    * priors[i]
+                )
+                for row in x_value
+            ]
+            prob_values.append(prob_value)
+
+        # Find the single value that coincides with the real prediction for the sample (if it exists)
+        pred_rows = zip(*pred_values)
+        predicted_pred = []
+        for row_index, row in enumerate(pred_rows):
+            if y is not None:
+                matches = [1 if row[value_index] == y[row_index] else 0 for value_index in range(n_values)]
+                match_values = [
+                    values[value_index] if row[value_index] == y[row_index] else 0 for value_index in range(n_values)
+                ]
+            else:
+                matches = [0 for _ in range(n_values)]
+                match_values = [0 for _ in range(n_values)]
+            predicted_pred.append(sum(match_values) if sum(matches) == 1 else None)
+
+        # Choose the value with highest probability for each sample
+        predicted_prob = [np.argmax(list(prob)) for prob in zip(*prob_values)]
+
+        return np.array(
+            [
+                value if value is not None else values[predicted_prob[index]]
+                for index, value in enumerate(predicted_pred)
+            ]
+        )
+    
+    def get_decision_path(self, x: np.ndarray) -> np.ndarray:
+        """
+        Returns the path through nodes in the tree when classifying x. Last one is leaf, first one root node.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Input sample.
+
+        Returns
+        -------
+        np.ndarray
+            The indices of the nodes in the array structure of the tree.
+        """
+        if len(np.shape(x)) == 1:
+            return self.estimator.decision_path(x.reshape(1, -1)).indices
+
+        return self.estimator.decision_path(x).indices
+    
+    def get_samples_at_node(self, node_id: int) -> int:
+        """
+        Returns the number of training samples mapped to a node.
+
+        Parameters
+        ----------
+        node_id : int
+            Node id.
+
+        Returns
+        -------
+        int
+            Number of samples mapped this node.
+        """
+        return self.estimator.tree_.n_node_samples[node_id]
\ No newline at end of file
diff --git a/src/holisticai/security/attackers/attribute_inference/white_box_lifestyle.py b/src/holisticai/security/attackers/attribute_inference/white_box_lifestyle.py
new file mode 100644
index 00000000..fd551db9
--- /dev/null
+++ b/src/holisticai/security/attackers/attribute_inference/white_box_lifestyle.py
@@ -0,0 +1,171 @@
+"""
+This module implements attribute inference attacks.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+
+class AttributeInferenceWhiteBoxLifestyleDecisionTree():
+    """
+    Implementation of Fredrikson et al. white box inference attack for decision trees.
+
+    Assumes that the attacked feature is discrete or categorical, with limited number of possible values. For example:
+    a boolean feature.
+
+    Parameters
+    ----------
+    estimator : object
+        Target estimator.
+    attack_feature : int
+        The index of the feature to be attacked.
+
+    References
+    ----------
+    .. [1] Fredrikson, M., Jha, S., & Ristenpart, T. (2015, August). Model inversion attacks that exploit confidence\\
+          information and basic countermeasures. In Proceedings of the 22nd ACM SIGSAC Conference on Computer and\\
+              Communications Security (pp. 1322-1333).
+
+    | Paper link: https://dl.acm.org/doi/10.1145/2810103.2813677
+    """
+    def __init__(self, estimator, attack_feature: int = 0):
+        self.attack_feature: int
+        self.attack_feature = attack_feature
+        self._check_params()
+        self.estimator = estimator
+
+    def _check_params(self) -> None:
+        if self.attack_feature < 0:
+            raise ValueError("Attack feature must be positive.")
+        
+    def infer(self, x: np.ndarray, **kwargs) -> np.ndarray:
+        """
+        Infer the attacked feature.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Input to attack. Includes all features except the attacked feature.
+        kwargs : dict
+            Possible values for attacked feature and prior distributions of attacked feature values.
+
+        Returns
+        -------
+        np.ndarray
+            The inferred feature values.
+        """
+        priors: Optional[list] = kwargs.get("priors")
+        values: Optional[list] = kwargs.get("values")
+
+        # Checks:
+        if priors is None or values is None:  # pragma: no cover
+            raise ValueError("`priors` and `values` are required as inputs.")
+        if len(priors) != len(values):  # pragma: no cover
+            raise ValueError("Number of priors does not match number of values")
+
+        n_samples = x.shape[0]
+
+        # Calculate phi for each possible value of the attacked feature
+        # phi is the total number of samples in all tree leaves corresponding to this value
+        phi = self._calculate_phi(x, values, n_samples)
+
+        # Will contain the probability of each value
+        prob_values = []
+
+        for i, value in enumerate(values):
+            # prepare data with the given value in the attacked feature
+            v_full = np.full((n_samples, 1), value).astype(x.dtype)
+            x_value = np.concatenate((x[:, : self.attack_feature], v_full), axis=1)
+            x_value = np.concatenate((x_value, x[:, self.attack_feature :]), axis=1)
+
+            # find the relative probability of this value for all samples being attacked
+            prob_value = [
+                (
+                    (self.get_samples_at_node(self.get_decision_path([row])[-1]) / n_samples)
+                    * priors[i]
+                    / phi[i]
+                )
+                for row in x_value
+            ]
+            prob_values.append(prob_value)
+
+        # Choose the value with highest probability for each sample
+        return np.array([values[np.argmax(list(prob))] for prob in zip(*prob_values)])
+    
+    def _calculate_phi(self, x, values, n_samples):
+        phi = []
+        for value in values:
+            v_full = np.full((n_samples, 1), value).astype(x.dtype)
+            x_value = np.concatenate((x[:, : self.attack_feature], v_full), axis=1)
+            x_value = np.concatenate((x_value, x[:, self.attack_feature :]), axis=1)
+            nodes_value = {}
+
+            for row in x_value:
+                # get leaf ids (no duplicates)
+                node_id = self.get_decision_path([row])[-1]
+                nodes_value[node_id] = self.get_samples_at_node(node_id)
+            # sum sample numbers
+            num_value = sum(nodes_value.values()) / n_samples
+            phi.append(num_value)
+
+        return phi
+    
+    def get_decision_path(self, x: np.ndarray) -> np.ndarray:
+        """
+        Returns the path through nodes in the tree when classifying x. Last one is leaf, first one root node.
+
+        Parameters
+        ----------
+        x : np.ndarray
+            Input sample.
+
+        Returns
+        -------
+        np.ndarray
+            The indices of the nodes in the array structure of the tree.
+        """
+        if len(np.shape(x)) == 1:
+            return self.estimator.decision_path(x.reshape(1, -1)).indices
+
+        return self.estimator.decision_path(x).indices
+    
+    def get_samples_at_node(self, node_id: int) -> int:
+        """
+        Returns the number of training samples mapped to a node.
+
+        Parameters
+        ----------
+        node_id : int
+            Node id.
+
+        Returns
+        -------
+        int
+            Number of samples mapped this node.
+        """
+        return self.estimator.tree_.n_node_samples[node_id]
+    
+    def _get_input_shape(self, model) -> Optional[tuple[int, ...]]:
+        _input_shape: Optional[tuple[int, ...]]
+        if hasattr(model, "n_features_"):
+            _input_shape = (model.n_features_,)
+        elif hasattr(model, "n_features_in_"):
+            _input_shape = (model.n_features_in_,)
+        elif hasattr(model, "feature_importances_"):
+            _input_shape = (len(model.feature_importances_),)
+        elif hasattr(model, "coef_"):
+            _input_shape = (model.coef_.shape[0],) if len(model.coef_.shape) == 1 else (model.coef_.shape[1],)
+        elif hasattr(model, "support_vectors_"):
+            _input_shape = (model.support_vectors_.shape[1],)
+        elif hasattr(model, "steps"):
+            _input_shape = self._get_input_shape(model.steps[-1][1].obj)
+        else:
+            logger.warning("Input shape not recognised. The model might not have been fitted.")
+            _input_shape = None
+        return _input_shape
\ No newline at end of file