groups-pm2.5-covariances.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "cfa43e4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8fee6eb6",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import itertools\n",
    "from tqdm.auto import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "987bede4",
   "metadata": {},
   "outputs": [],
   "source": [
    "import data\n",
    "import utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2c55c367",
   "metadata": {},
   "outputs": [],
   "source": [
    "readerTypes = [data.FccPmData]\n",
    "targets = ['PM']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a71d1bd2",
   "metadata": {},
   "outputs": [],
   "source": [
    "!mkdir -p models_clean_randgroup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a0c87757",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_group_constraints(groups):\n",
    "    interaction_constraints = []\n",
    "    i=0\n",
    "    for g in groups:\n",
    "        interaction_constraints.append(list(range(i, i+len(g))))\n",
    "        i += len(g)\n",
    "    return interaction_constraints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "fd729936",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---------\n",
      "Dataset: PM2.5 Data of Five Chinese Cities\n",
      "Calculating full model mse...\n",
      "Calculating E^r model mse...\n",
      "Calculating random group 2 E^r mse...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5c353977f5964f579a1a847849e7855f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating random group 3 E^r mse...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "24527b33b68b4e3d802f48dac4b4319c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mse_collector = {}\n",
    "\n",
    "for ReaderType, target in zip(readerTypes, targets):\n",
    "    reader = ReaderType('data/UCI/archive.ics.uci.edu/ml/machine-learning-databases')\n",
    "    reader.readAndCache()\n",
    "    print(\"---------\")\n",
    "    print(\"Dataset:\", reader.name)\n",
    "    cols = reader.cols\n",
    "    ncols = len(cols)\n",
    "\n",
    "    trainer = utils.Trainer(\n",
    "        cache_dir='models_clean',\n",
    "        default_params={\n",
    "            'objective': 'regression',\n",
    "            'metric': 'mse',\n",
    "            'boosting': 'gbdt',\n",
    "            'num_leaves': 31,\n",
    "            'learning_rate': 0.05,\n",
    "            'verbose': -1,\n",
    "            'device': 'cpu',\n",
    "            'lambda_l2': 0.003,\n",
    "            'early_stopping_round': 10,\n",
    "            'num_boost_round': 100,\n",
    "        },\n",
    "        nocache_params={\n",
    "            'num_threads': 20,\n",
    "        }\n",
    "    )\n",
    "    evaluator = utils.Evaluator(reader, target)\n",
    "    \n",
    "    data_mse = {}\n",
    "    \n",
    "    print(\"Calculating full model mse...\")\n",
    "    trainData = utils.TrainingData(reader, target, columns=cols)\n",
    "    booster = trainer.train_model(trainData)\n",
    "    new_mse = evaluator.get_model_mse(booster)\n",
    "    data_mse['base_mse'] = evaluator.base_mse\n",
    "    data_mse['features_e'] = {'ngroups': 1, 'mse':new_mse}\n",
    "    \n",
    "    print(\"Calculating E^r model mse...\")\n",
    "    booster = trainer.train_model(trainData, {\n",
    "        'interaction_constraints': [[i] for i in range(len(reader.cols))]\n",
    "    })\n",
    "    new_mse = evaluator.get_model_mse(booster)\n",
    "    data_mse['features_er'] = {'ngroups': len(reader.cols), 'mse':new_mse}\n",
    "    mse_collector[reader.name] = data_mse\n",
    "    \n",
    "    #e_r semantic groups\n",
    "    if reader.groups is not None:\n",
    "        print(\"Calculating semantic group E^r mse...\")\n",
    "        trainData = utils.TrainingData(reader, target, columns=[i for g in reader.groups.values() for i in g])\n",
    "        booster = trainer.train_model(trainData, {\n",
    "            'interaction_constraints': get_group_constraints(reader.groups),\n",
    "        })\n",
    "        new_mse = evaluator.get_model_mse(booster)\n",
    "        data_mse['semantic_groups'] = {'ngroups': len(reader.groups), 'mse':new_mse}\n",
    "    \n",
    "    for groupsize in [2,3,5,6]:\n",
    "        np.random.seed(reader.seed)\n",
    "        ngroups = len(cols)//groupsize\n",
    "        if ngroups <= 2:\n",
    "            continue\n",
    "        mses = []\n",
    "        print(\"Calculating random group\", groupsize, \"E^r mse...\")\n",
    "        for i in tqdm(range(100)):\n",
    "            feature_perm = np.random.permutation(cols)\n",
    "            groups = np.array_split(feature_perm, ngroups)[::-1] # array split puts longer groups first, lets switch the order\n",
    "            trainData = utils.TrainingData(reader, target, columns=[i for g in groups for i in g])\n",
    "            booster = trainer.train_model(trainData, {\n",
    "                'interaction_constraints': get_group_constraints(groups),\n",
    "            })\n",
    "            new_mse = evaluator.get_model_mse(booster)\n",
    "            mses.append(new_mse)\n",
    "        data_mse['random_groups_'+str(groupsize)] = {'ngroups': ngroups, 'mse':np.mean(mses)}\n",
    "    mse_collector[reader.name] = data_mse"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87beacea",
   "metadata": {},
   "source": [
    "#### Prediction power with groupings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6de8a4c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PM2.5 Data of Five Chinese Cities\n",
      "- features_e 1 0.733870131667314\n",
      "- features_er 10 0.9067550226094799\n",
      "- random_groups_2 5 0.8445026480042132\n",
      "- random_groups_3 3 0.8021512055150327\n"
     ]
    }
   ],
   "source": [
    "for name, data_mse in mse_collector.items():\n",
    "    print(name)\n",
    "    for kind, mse in data_mse.items():\n",
    "        if kind == \"base_mse\":\n",
    "            continue\n",
    "        print(\"-\", kind, mse['ngroups'], mse['mse']/data_mse['base_mse'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "87de16f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\midrule\n",
      "\\multicolumn{3}{l}{PM2.5 Data of Five Chinese Cities}\\\\\n",
      "\\midrule\n",
      "Base features ($E$)&1&0.7339\\\\\n",
      "Base features ($E^r$)&10&0.9068\\\\\n",
      "Random groups (2)&5&0.8445\\\\\n",
      "Random groups (3)&3&0.8022\\\\\n"
     ]
    }
   ],
   "source": [
    "# latex translate dict\n",
    "ltd = {\n",
    "    'features_e': 'Base features ($E$)',\n",
    "    'features_er': 'Base features ($E^r$)',\n",
    "    'semantic_groups': 'Semantic groups',\n",
    "    'random_groups_2': 'Random groups (2)',\n",
    "    'random_groups_3': 'Random groups (3)',\n",
    "    'random_groups_5': 'Random groups (5)',\n",
    "    'random_groups_6': 'Random groups (6)',\n",
    "}\n",
    "for name, data_mse in mse_collector.items():\n",
    "    print('\\midrule')\n",
    "    print(\"\\multicolumn{3}{l}{%s}\"%name, end=\"\\\\\\\\\\n\")\n",
    "    print('\\midrule')\n",
    "    for kind, mse in data_mse.items():\n",
    "        if kind == \"base_mse\":\n",
    "            continue\n",
    "        print(ltd[kind], mse['ngroups'], \"%.4f\"%(mse['mse']/data_mse['base_mse']), sep=\"&\", end=\"\\\\\\\\\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc90d569",
   "metadata": {},
   "source": [
    "#### Same on barchart"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "def715ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "labels = list(ltd.keys())\n",
    "data = [[(mse_dict[l]['mse']/mse_dict['base_mse'] if l in mse_dict else 0) for l in labels] for mse_dict in mse_collector.values()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "bf586573",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 500x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(5,2))\n",
    "slack = 3\n",
    "width = 1/(len(labels)*(len(data)+slack))\n",
    "pos_0 = np.linspace(0,1,len(data[0])+1)[:-1]\n",
    "for i,d in enumerate(data):\n",
    "    plt.bar(pos_0+i*width, d, width=width)\n",
    "plt.xticks(pos_0+((len(data)-1)*width/2), labels, rotation = 90);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80dddc02",
   "metadata": {},
   "source": [
    "# Contributions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "cf810404",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---------\n",
      "Dataset: PM2.5 Data of Five Chinese Cities\n",
      "Calculating random group 1 E^r mse...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d97bf6598ca741a9be03be3a0e2f306a",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating random group 2 E^r mse...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b72f957d1a844987b7ffcb27e502bbb7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculating random group 3 E^r mse...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1599ae92c9644f10b2153635796fdf40",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mse_collector = {}\n",
    "\n",
    "for ReaderType, target in zip(readerTypes, targets):\n",
    "    reader = ReaderType('/mnt/idms/kdomokos/data/UCI/archive.ics.uci.edu/ml/machine-learning-databases')\n",
    "    reader.readAndCache()\n",
    "    print(\"---------\")\n",
    "    print(\"Dataset:\", reader.name)\n",
    "    cols = reader.cols\n",
    "    ncols = len(cols)\n",
    "\n",
    "    trainer = utils.Trainer(\n",
    "        cache_dir='models_clean',\n",
    "        default_params={\n",
    "            'objective': 'regression',\n",
    "            'metric': 'mse',\n",
    "            'boosting': 'gbdt',\n",
    "            'num_leaves': 31,\n",
    "            'learning_rate': 0.05,\n",
    "            'verbose': -1,\n",
    "            'device': 'cpu',\n",
    "            'lambda_l2': 0.003,\n",
    "            'early_stopping_round': 10,\n",
    "            'num_boost_round': 100,\n",
    "        },\n",
    "        nocache_params={\n",
    "            'num_threads': 20,\n",
    "        }\n",
    "    )\n",
    "    evaluator = utils.Evaluator(reader, target)\n",
    "    \n",
    "    data_mse = {}\n",
    "\n",
    "    for groupsize in [1,2,3,5,6]:\n",
    "        np.random.seed(reader.seed)\n",
    "        ngroups = len(cols)//groupsize\n",
    "        if ngroups <= 2:\n",
    "            continue\n",
    "        mses_e = []\n",
    "        mses_er = []\n",
    "        print(\"Calculating random group\", groupsize, \"E^r mse...\")\n",
    "        for i in tqdm(range(100)):\n",
    "            contribs_e = [evaluator.base_mse]\n",
    "            contribs_er = [evaluator.base_mse]\n",
    "            feature_perm = np.random.permutation(cols)\n",
    "            groups = np.array_split(feature_perm, ngroups)[::-1] # array split puts longer groups first, lets switch the order\n",
    "            groups_sofar = []\n",
    "            for g in groups:\n",
    "                groups_sofar.append(g)\n",
    "                trainData = utils.TrainingData(reader, target, columns=[i for g in groups_sofar for i in g])\n",
    "                \n",
    "                booster = trainer.train_model(trainData)\n",
    "                new_mse = evaluator.get_model_mse(booster)\n",
    "                contribs_e.append(new_mse - np.sum(contribs_e))\n",
    "                \n",
    "                booster = trainer.train_model(trainData, {\n",
    "                    'interaction_constraints': get_group_constraints(groups_sofar),\n",
    "                })\n",
    "                new_mse = evaluator.get_model_mse(booster)\n",
    "                contribs_er.append(new_mse - np.sum(contribs_er))\n",
    "                \n",
    "                if len(contribs_e) > 5:\n",
    "                    break\n",
    "            mses_e.append(contribs_e)\n",
    "            mses_er.append(contribs_er)\n",
    "        data_mse['random_groups_'+str(groupsize)] = {\n",
    "            'ngroups': ngroups,\n",
    "            'mses_e':np.array(mses_e).mean(axis=0),\n",
    "            'mses_er':np.array(mses_er).mean(axis=0),\n",
    "            'base_mse':evaluator.base_mse,\n",
    "        }\n",
    "    mse_collector[reader.name] = data_mse"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "368721b3",
   "metadata": {},
   "source": [
    "## Contributions of random groups in random order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "847a7a04",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PM2.5 Data of Five Chinese Cities\n",
      "random_groups_1\n",
      "[ 1.00000000e+00 -5.22282299e-04 -1.00183439e-02 -3.77411703e-02\n",
      " -5.16210750e-02 -4.41699794e-02]\n",
      "[ 1.00000000e+00 -5.22282299e-04 -3.90890283e-03 -1.27623041e-02\n",
      " -1.68756670e-02 -1.10641070e-02]\n",
      "random_groups_2\n",
      "[ 1.         -0.01054063 -0.08936231 -0.08523114 -0.05696984 -0.02402596]\n",
      "[ 1.         -0.01054063 -0.05150067 -0.04310268 -0.03273801 -0.01761537]\n",
      "random_groups_3\n",
      "[ 1.         -0.04828254 -0.13685175 -0.08099557]\n",
      "[ 1.         -0.04828254 -0.08441696 -0.0651493 ]\n"
     ]
    }
   ],
   "source": [
    "for name, group_setups in mse_collector.items():\n",
    "    print(name)\n",
    "    for group, mse_info in group_setups.items():\n",
    "        print(group)\n",
    "        print(mse_info['mses_e']/mse_info['base_mse'])\n",
    "        print(mse_info['mses_er']/mse_info['base_mse'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "e5509e95",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Grouping&$\\phi_1$&$\\phi_2$&$\\phi_3$&$\\phi_4$&$\\phi_5$\\\\\n",
      "\\midrule\n",
      "\\multicolumn{6}{l}{PM2.5 Data of Five Chinese Cities}\\\\\n",
      "\\midrule\n",
      "Individual features ($E$) & -0.0005 & -0.0100 & -0.0377 & -0.0516 & -0.0442\\\\\n",
      "Individual features ($E^r$) & -0.0005 & -0.0039 & -0.0128 & -0.0169 & -0.0111\\\\\n",
      "Random groups of size 2 ($E$) & -0.0105 & -0.0894 & -0.0852 & -0.0570 & -0.0240\\\\\n",
      "Random groups of size 2 ($E^r$) & -0.0105 & -0.0515 & -0.0431 & -0.0327 & -0.0176\\\\\n",
      "Random groups of size 3 ($E$) & -0.0483 & -0.1369 & -0.0810\\\\\n",
      "Random groups of size 3 ($E^r$) & -0.0483 & -0.0844 & -0.0651\\\\\n"
     ]
    }
   ],
   "source": [
    "# latex translate dict\n",
    "ltd = {\n",
    "    'random_groups_1': 'Individual features',\n",
    "    'random_groups_2': 'Random groups of size 2',\n",
    "    'random_groups_3': 'Random groups of size 3',\n",
    "    'random_groups_5': 'Random groups of size 5',\n",
    "    'random_groups_6': 'Random groups of size 6',\n",
    "}\n",
    "print(\"Grouping\", *[\"$\\phi_%d$\"%i for i in range(1,6)], sep=\"&\", end=\"\\\\\\\\\\n\")\n",
    "for name, group_setups in mse_collector.items():\n",
    "    print('\\midrule')\n",
    "    print(\"\\multicolumn{6}{l}{%s}\"%name, end=\"\\\\\\\\\\n\")\n",
    "    print('\\midrule')\n",
    "    for group, mse_info in group_setups.items():\n",
    "        print(ltd[group]+\" ($E$)\", *[\"%.4f\"%f for f in mse_info['mses_e'][1:]/mse_info['base_mse']], sep=\" & \", end=\"\\\\\\\\\\n\")\n",
    "        print(ltd[group]+\" ($E^r$)\", *[\"%.4f\"%f for f in mse_info['mses_er'][1:]/mse_info['base_mse']], sep=\" & \", end=\"\\\\\\\\\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "3ec21876",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PM2.5 Data of Five Chinese Cities\n",
      "random_groups_1\n",
      "[ 1.00000000e+00 -5.22282299e-04 -1.00183439e-02 -3.77411703e-02\n",
      " -5.16210750e-02 -4.41699794e-02]\n",
      "[ 1.00000000e+00 -5.22282299e-04 -3.90890283e-03 -1.27623041e-02\n",
      " -1.68756670e-02 -1.10641070e-02]\n",
      "random_groups_2\n",
      "[ 1.         -0.01054063 -0.08936231 -0.08523114 -0.05696984 -0.02402596]\n",
      "[ 1.         -0.01054063 -0.05150067 -0.04310268 -0.03273801 -0.01761537]\n",
      "random_groups_3\n",
      "[ 1.         -0.04828254 -0.13685175 -0.08099557]\n",
      "[ 1.         -0.04828254 -0.08441696 -0.0651493 ]\n"
     ]
    }
   ],
   "source": [
    "for name, group_setups in mse_collector.items():\n",
    "    print(name)\n",
    "    for group, mse_info in group_setups.items():\n",
    "        print(group)\n",
    "        print(mse_info['mses_e']/mse_info['base_mse'])\n",
    "        print(mse_info['mses_er']/mse_info['base_mse'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "9e7d05b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# should be monotonically decreasing for random groups in random order!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1eb91d8e",
   "metadata": {},
   "source": [
    "#### Collecting info for oversized contributions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "5775b98a",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "---------\n",
      "Dataset: PM2.5 Data of Five Chinese Cities\n",
      "Calculating random group 2 E^r mse...\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a7f3029b5f9e4fb28ba6b53bd3a75aaf",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-----\n",
      "[['cbwd', 'TEMP'], ['precipitation', 'HUMI']]\n",
      "-0.000753852572431768\n",
      "[[246.93076493 -19.73635563]\n",
      " [-19.73635563 146.69496129]]\n",
      "-----\n",
      "[['DEWP', 'HUMI'], ['Iprec', 'cbwd']]\n",
      "-0.00281304504150727\n",
      "[[240.32378829 -21.71197672]\n",
      " [-21.71197672 200.34539151]]\n",
      "-----\n",
      "[['TEMP', 'DEWP'], ['Iprec', 'cbwd']]\n",
      "-0.009008228661991177\n",
      "[[235.0408762  -20.21351582]\n",
      " [-20.21351582 192.19716903]]\n"
     ]
    }
   ],
   "source": [
    "collector = []\n",
    "collector2 = []\n",
    "collector3 = []\n",
    "for ReaderType, target in zip(readerTypes, targets):\n",
    "    reader = ReaderType('/mnt/idms/kdomokos/data/UCI/archive.ics.uci.edu/ml/machine-learning-databases')\n",
    "    reader.readAndCache()\n",
    "    print(\"---------\")\n",
    "    print(\"Dataset:\", reader.name)\n",
    "    cols = reader.cols\n",
    "    ncols = len(cols)\n",
    "\n",
    "    trainer = utils.Trainer(\n",
    "        cache_dir='models_clean',\n",
    "        default_params={\n",
    "            'objective': 'regression',\n",
    "            'metric': 'mse',\n",
    "            'boosting': 'gbdt',\n",
    "            'num_leaves': 31,\n",
    "            'learning_rate': 0.05,\n",
    "            'verbose': -1,\n",
    "            'device': 'cpu',\n",
    "            'lambda_l2': 0.003,\n",
    "            'early_stopping_round': 10,\n",
    "            'num_boost_round': 100,\n",
    "            'max_depth': 3,\n",
    "        },\n",
    "        nocache_params={\n",
    "            'num_threads': 20,\n",
    "        }\n",
    "    )\n",
    "    evaluator = utils.Evaluator(reader, target)\n",
    "\n",
    "    for groupsize in [2]:\n",
    "        np.random.seed(reader.seed)\n",
    "        ngroups = len(cols)//groupsize\n",
    "        if ngroups <= 2:\n",
    "            continue\n",
    "            \n",
    "        print(\"Calculating random group\", groupsize, \"E^r mse...\")\n",
    "        for i in tqdm(range(100)):\n",
    "            contribs_e = [evaluator.base_mse]\n",
    "            contribs_er = [evaluator.base_mse]\n",
    "            feature_perm = np.random.permutation(cols)\n",
    "            groups = np.array_split(feature_perm, ngroups)[::-1] # array split puts longer groups first, lets switch the order\n",
    "            groups = [list(i) for i in groups[:2]]\n",
    "\n",
    "            trainData = utils.TrainingData(reader, target, columns=groups[0])\n",
    "            booster = trainer.train_model(trainData)\n",
    "            first_mse = evaluator.get_model_mse(booster)\n",
    "\n",
    "            trainData = utils.TrainingData(reader, target, columns=groups[1])\n",
    "            booster = trainer.train_model(trainData)\n",
    "            second_mse = evaluator.get_model_mse(booster)\n",
    "\n",
    "            trainData = utils.TrainingData(reader, target, columns=[i for g in groups for i in g])\n",
    "            booster = trainer.train_model(trainData, {\n",
    "                'interaction_constraints': get_group_constraints(groups),\n",
    "            })\n",
    "            both_mse = evaluator.get_model_mse(booster)\n",
    "\n",
    "            cov = utils.get_group_cov(booster, reader.getTest(), get_group_constraints(groups))\n",
    "    \n",
    "            collector.append(((both_mse - first_mse)/evaluator.base_mse - (second_mse - evaluator.base_mse)/evaluator.base_mse, cov.min()))\n",
    "            collector2.append((\n",
    "                groups,\n",
    "                first_mse-evaluator.base_mse, second_mse-evaluator.base_mse, both_mse-evaluator.base_mse,\n",
    "                (both_mse - first_mse)/evaluator.base_mse - (second_mse - evaluator.base_mse)/evaluator.base_mse,\n",
    "                 cov\n",
    "            ))\n",
    "            \n",
    "            features = pd.Series(booster.feature_name())\n",
    "            groups = [list(features[g].values) for g in get_group_constraints(groups)]\n",
    "            group_masks = utils.get_feature_group_masks(booster, groups)\n",
    "            tree_preds = utils.get_tree_predictions(booster, evaluator.eval)\n",
    "            group_pred_parts = np.array([tree_preds.dot(mask) for mask in group_masks]).T\n",
    "            \n",
    "            second_part_mse = evaluator.get_mse(evaluator.eval_y, group_pred_parts[:, 1]-group_pred_parts[:, 1].mean() + evaluator.train_y.mean())\n",
    "            second_part_mse = min(second_part_mse, second_mse)\n",
    "            \n",
    "            collector3.append(((both_mse - first_mse)/evaluator.base_mse - (second_part_mse - evaluator.base_mse)/evaluator.base_mse, cov.min()))\n",
    "            \n",
    "            if ((both_mse - first_mse)/evaluator.base_mse - (second_part_mse - evaluator.base_mse)/evaluator.base_mse) < 0:\n",
    "                print(\"-----\")\n",
    "                print(groups)\n",
    "                print(((both_mse - first_mse)/evaluator.base_mse - (second_part_mse - evaluator.base_mse)/evaluator.base_mse))\n",
    "                print(cov)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "d488babe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.lines.Line2D at 0x7f2d8c11f220>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAekAAADwCAYAAAAkYJxwAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABWgklEQVR4nO3dd1gU19cH8O+C7C5dehcUVMQKBhWNYu/GGns3lmBsMWqMwZZYEo36i7HHEqOJxliisSAWDAFUNMEGEkSJDRRRQVTqnvcP352wsAvLsgsLns/z8OjO3Jm5d9qZe+fOjIiICIwxxhjTOwYVnQHGGGOMKcdBmjHGGNNTHKQZY4wxPcVBmjHGGNNTHKQZY4wxPcVBmjHGGNNTHKQZY4wxPcVBmjHGGNNTHKQZY4wxPcVBuozOnz+P999/H05OThCLxXB0dMSAAQMQFRVV0Vkr0ejRo+Hh4VHuy/Xw8MDo0aPLfbnqiI2NxcKFC5GUlFSq6dq2bYu2bdsKv5OSkiASibBy5Uqt5m/p0qU4dOhQkeFhYWEQiUQICwvT6vKYdlW17RQeHg6JRIJ///1Xq/MtfDyVxsKFCyESibSaH2VEIhEWLlwo/D59+jTMzMzw4MEDrS6Hg3QZrF27Fq1atcL9+/fx9ddf49SpU1i5ciUePHiAd999F999911FZ7FYwcHBOHjwYEVnQ6/ExsZi0aJFpQ7S69evx/r163WTqQJUBWk/Pz9ERUXBz89P53lgmqtK24mIMH36dIwfPx7u7u5anXdZjqcPPvigQipJHTp0QLNmzfDZZ59pdb7VtDq3t0hERASmT5+O7t274+DBg6hW7b9VOXjwYPTt2xfTpk2Dr68vWrVqVW75ev36NaRSqVpXkp6enuWQo6rt1atXMDExgY+PT4Xmw8LCAi1atKjQPDDVcnNzIRKJqtR2OnHiBP766y/89NNPWpunNo4nV1dXuLq6ai1PpTF58mQMGjQIX375Jdzc3LQyT65Ja2jZsmUQiUTYsGGDQoAGgGrVqmH9+vUQiURYvnw5AODQoUMQiUQ4ffp0kXlt2LABIpEIV69eFYZdunQJ7733HqytrSGVSuHr64tffvlFYbodO3ZAJBLh5MmTGDt2LOzs7GBiYoLs7GykpqZiwoQJcHNzg0QigZ2dHVq1aoVTp04J0xdu7pY3Eyn7K9g8nZOTgy+//BLe3t7CvMeMGYPU1FSF/OXm5mL27NlwdHSEiYkJ3n33XVy8eFHtdZydnY3FixejXr16kEqlsLGxQbt27RAZGSmkycrKwty5c1GzZk2IxWK4uLhg8uTJeP78ucK8PDw80LNnT5w4cQJ+fn4wNjaGt7c3tm3bprA+33//fQBAu3bthLLv2LEDwJsmuAYNGuCPP/5Ay5YtYWJigrFjxwrjlDXPyWQyLFmyBDVq1IBUKsU777xTZB9QdduhcLOdSCTCy5cv8cMPPwh5ky9TVTPq4cOHERAQABMTE5ibm6NTp05Fahny5dy4cQNDhgyBpaUlHBwcMHbsWKSnpxfJV0HTp0+HqakpMjIyiowbNGgQHBwckJubCwA4c+YM2rZtCxsbGxgbG6NGjRro378/Xr16VewyVLlw4QJ69eoFGxsbSKVSeHp6Yvr06Qpp/vzzT3To0AHm5uYwMTFBy5YtcfToUWH8lStXIBKJsHXr1iLzP378OEQiEQ4fPgwAuHXrFsaMGYPatWvDxMQELi4u6NWrF65du6YwnXxb/Pjjj5g5cyZcXFwgkUhw69Ytpdvp0qVLGDx4MDw8PGBsbAwPDw8MGTKkSBOy/Hg/e/YsPvzwQ9ja2sLGxgb9+vXDw4cPi+T/p59+QkBAAMzMzGBmZoYmTZoUKeepU6fQoUMHWFhYwMTEBK1atVJ6jlJmw4YN8Pf3R926dRWGy2QyfP3118L5wd7eHiNHjsT9+/cV0pX2eLp//z4GDBgAc3NzVK9eHcOGDUN0dLTCMQoob+5W5/gHgNTUVAQFBcHHxwdmZmawt7dH+/btER4ertY66dWrF8zMzLBlyxa10quFWKnl5eWRiYkJNW/evNh0zZo1IxMTE8rLy6Pc3Fyyt7enYcOGKU3n5+cn/D5z5gyJxWJq3bo17d27l06cOEGjR48mALR9+3Yh3fbt2wkAubi40IQJE+j48eP066+/Ul5eHnXp0oXs7Oxo8+bNFBYWRocOHaL58+fTnj17hOlHjRpF7u7uwu979+5RVFSUwt+sWbMIAH399ddERJSfn09du3YlU1NTWrRoEYWGhtL3339PLi4u5OPjQ69evVKYv0gkolmzZtHJkydp1apV5OLiQhYWFjRq1Khi111ubi61a9eOqlWrRp988gkdO3aMDh8+TJ999hn9/PPPREQkk8moS5cuVK1aNQoODqaTJ0/SypUrydTUlHx9fSkrK0uYn7u7O7m6upKPjw/t3LmTQkJC6P333ycAdO7cOSIievz4MS1dupQA0Lp164R18PjxYyIiCgwMJGtra3Jzc6O1a9fS2bNnhWkDAwMpMDBQWN6dO3cIALm5udG7775L+/fvp3379pG/vz8ZGRlRZGSkyu0gt2DBAip4iEZFRZGxsTF1795dyNuNGzeIiOjs2bMEgM6ePSuk3717NwGgzp0706FDh2jv3r3UtGlTEovFFB4eXmQ5devWpfnz51NoaCitWrWKJBIJjRkzptjtdOXKFQJAW7ZsURj+7Nkzkkgk9PHHHwvrQyqVUqdOnejQoUMUFhZGu3fvphEjRtCzZ8+KXYYyJ06cICMjI2rUqBHt2LGDzpw5Q9u2baPBgwcLacLCwsjIyIiaNm1Ke/fupUOHDlHnzp1JJBIpHAe+vr7UqlWrIssYOHAg2dvbU25uLhERnTt3jmbOnEm//vornTt3jg4ePEh9+vQhY2NjunnzpjCdfFu4uLjQgAED6PDhw/T7779TWlqa0u20b98+mj9/Ph08eJDOnTtHe/bsocDAQLKzs6PU1FQhnfx4r1WrFk2ZMoVCQkLo+++/JysrK2rXrp1C3oODgwkA9evXj/bt2yccf8HBwUKaH3/8kUQiEfXp04cOHDhAR44coZ49e5KhoSGdOnWq2PWfnZ1NxsbGNHv27CLjJkyYQADoo48+ohMnTtDGjRvJzs6O3NzcFMpTmuMpMzOTvLy8yNramtatW0chISE0Y8YMqlmzZpHzYuHjhki945+I6ObNm/Thhx/Snj17KCwsjH7//XcaN24cGRgYKGwzIiIAtGDBgiLl79atm8L5vKw4SGsgJSWFACicEJQZNGgQAaBHjx4REdHHH39MxsbG9Pz5cyFNbGwsAaC1a9cKw7y9vcnX11c4Ocj17NmTnJycKD8/n4j+O2hHjhxZZNlmZmY0ffr0YvOnKjjIhYeHk1QqpWHDhpFMJiMiop9//pkA0P79+xXSRkdHEwBav349ERHFxcURAJoxY4ZCOnngKClI79y5U+nJv6ATJ04oXEDI7d27lwDQ5s2bhWHu7u4klUrp33//FYa9fv2arK2taeLEicKwffv2FTmJygUGBhIAOn36tNJxyoK0s7MzvX79WhiekZFB1tbW1LFjR2GYukGaiMjU1FTpuit88s/PzydnZ2dq2LChsL8QEb148YLs7e2pZcuWRZZTeD0GBQWRVCoVtr0qfn5+CvMjIlq/fj0BoGvXrhER0a+//koAKCYmpth5qcvT05M8PT0V1m1hLVq0IHt7e3rx4oUwLC8vjxo0aECurq5Cub799lsCQPHx8UK6p0+fkkQioZkzZ6qcf15eHuXk5FDt2rUV9nP5tmjTpk2RaZQFaWXzzczMJFNTU/rf//4nDJcf70FBQQrpv/76awJAycnJRER0+/ZtMjQ0VFohkHv58iVZW1tTr169FIbn5+dT48aNqVmzZiqnJSK6cOECAVC42CH677gvnEd5+s8++0wYVprjad26dQSAjh8/rpBu4sSJagdpdY7/wuQVrA4dOlDfvn0VxqkK0vPmzSMDAwPKzMxUOd/S4OZuHaL//1S3vOll7NixeP36Nfbu3Suk2b59OyQSCYYOHQrgTZPazZs3MWzYMABAXl6e8Ne9e3ckJycjPj5eYTn9+/cvsuxmzZphx44d+PLLL3H+/HmhyVFdcXFxeO+999CyZUts27ZNKMPvv/+O6tWro1evXgp5a9KkCRwdHYVmvLNnzwKAUA65gQMHFrk9oMzx48chlUqF5i9lzpw5AwBFeoq///77MDU1LdJs16RJE9SoUUP4LZVKUadOnVL1TLWyskL79u3VTt+vXz9IpVLht7m5OXr16oU//vgD+fn5as+ntOLj4/Hw4UOMGDECBgb/HeZmZmbo378/zp8/X6SZ+b333lP43ahRI2RlZeHx48fFLmvMmDGIjIxU2C+3b98Of39/NGjQAMCbdS8WizFhwgT88MMPuH37tsZl++eff5CYmIhx48YprNuCXr58iQsXLmDAgAEwMzMThhsaGmLEiBG4f/++kN9hw4ZBIpEoNJn+/PPPyM7OxpgxY4RheXl5WLp0KXx8fCAWi1GtWjWIxWIkJCQgLi6uSB6UHZfKZGZmYs6cOfDy8kK1atVQrVo1mJmZ4eXLl0rnq2w7ARD249DQUOTn52Py5MkqlxkZGYmnT59i1KhRCsexTCZD165dER0djZcvX6qcXt68bm9vrzBcftwXPiabNWuGevXqFTkm1T2ezp07B3Nzc3Tt2lVh+JAhQ0qcVk7d43/jxo3w8/ODVCpFtWrVYGRkhNOnTyvdFsrY29tDJpMhJSVF7bwVh4O0BmxtbWFiYoI7d+4Umy4pKQkmJiawtrYGANSvXx/+/v7Yvn07ACA/Px+7du1C7969hTSPHj0CAHzyyScwMjJS+AsKCgIAPHnyRGE5Tk5ORZa9d+9ejBo1Ct9//z0CAgJgbW2NkSNHqrXjPHz4EF27doWrqysOHDgAsVgsjHv06BGeP38OsVhcJH8pKSlC3tLS0gAAjo6OCvOuVq0abGxsSsxDamoqnJ2dFQJMYWlpaahWrRrs7OwUhotEIjg6Ogp5kFO2XIlEgtevX5eYHzll67o4hcsvH5aTk4PMzMxSzas05GVXll9nZ2fIZDI8e/ZMYXjh9SORSACgxPVTOMjFxsYiOjpaIcB5enri1KlTsLe3x+TJk+Hp6QlPT0/873//K3XZ5H0fiusc9OzZMxCRyvID/60ja2trvPfee9i5c6dw4bRjxw40a9YM9evXF6b7+OOPERwcjD59+uDIkSO4cOECoqOj0bhxY6XrSN19ZejQofjuu+/wwQcfICQkBBcvXkR0dDTs7OyUzrek7aTO+pGfZwYMGFDkOP7qq69ARHj69KnK6eXLKnyRVNJ+V/iYVHcdpaWlwcHBochwZcNUUef4X7VqFT788EM0b94c+/fvx/nz5xEdHY2uXbuqfZ6Qr5PSnFeKw727NWBoaIh27drhxIkTuH//vtKD4f79+7h8+TK6desGQ0NDYfiYMWMQFBSEuLg43L59G8nJyQonM1tbWwDA3Llz0a9fP6XLL9xRQ1lPbltbW6xZswZr1qzB3bt3cfjwYXz66ad4/PgxTpw4obJsGRkZ6N69O2QyGY4dOwZLS8si87WxsVE5D3NzcwD/HRApKSlwcXERxufl5RU5UJWxs7PDn3/+CZlMpjJQ29jYIC8vD6mpqQqBmoiQkpICf3//EpdTWqV9/lLZRVFKSgrEYrFQw5NKpcjOzi6SrvDFWGnI139ycnKRcQ8fPoSBgQGsrKw0nn9BVlZW6N27N3bu3Ikvv/wS27dvh1QqLVLLad26NVq3bo38/HxcunQJa9euxfTp0+Hg4IDBgwervTz5ti7cEalwngwMDFSWH/jvWAPeHJf79u1DaGgoatSogejoaGzYsEFhul27dmHkyJFYunSpwvAnT56gevXqRZajzr6Snp6O33//HQsWLMCnn34qDM/Ozi42SBan4PpR1cNYXva1a9eq7G1eXACUT184jwX3u8LnxYcPHyqsc0D948nGxkZpp1Nt1Vbldu3ahbZt2xbZ9i9evFB7HvJ1UrismuKatIbmzp0LIkJQUFCRZsv8/Hx8+OGHICLMnTtXYdyQIUMglUqxY8cO7NixAy4uLujcubMwvm7duqhduzauXLmCd955R+mfPBCqq0aNGvjoo4/QqVMn/PXXXyrT5eTkoG/fvkhKSsLx48eVXnz07NkTaWlpyM/PV5o3+QWEvGfm7t27Fab/5ZdfkJeXV2Keu3XrhqysLIUmyMI6dOgA4M2BVdD+/fvx8uVLYXxpqFt7VNeBAweQlZUl/H7x4gWOHDmC1q1bCxdvHh4eePz4sVC7Ad5si5CQEKX5UydvdevWhYuLC3766Sfhtgvwphl4//79Qo9vbRkzZgwePnyIY8eOYdeuXejbt6/SwAW8ucht3rw51q1bBwDF7pPK1KlTB56enti2bZvSixsAMDU1RfPmzXHgwAGF9SWTybBr1y64urqiTp06wvDOnTvDxcUF27dvV3mRIRKJhP1D7ujRo2V6eYVIJAIRFZnv999/r/HtkM6dO8PQ0LBIoCmoVatWqF69OmJjY1WeZwq2oBVWr149AEBiYqLCcHnTdeFjMjo6GnFxcRodkwAQGBiIFy9e4Pjx4wrD9+zZo9H8VFG2ja9evVqq565v374NGxubUtXyi8M1aQ21atUKa9aswfTp0/Huu+/io48+Qo0aNXD37l2sW7cOFy5cwJo1a9CyZUuF6apXr46+fftix44deP78OT755JMiNcVNmzahW7du6NKlC0aPHg0XFxc8ffoUcXFx+Ouvv7Bv375i85aeno527dph6NCh8Pb2hrm5OaKjo3HixAmVtXMAmDFjBs6cOYOlS5ciMzMT58+fF8bZ2dnB09MTgwcPxu7du9G9e3dMmzYNzZo1g5GREe7fv4+zZ8+id+/e6Nu3L+rVq4fhw4djzZo1MDIyQseOHXH9+nWsXLkSFhYWJa7fIUOGYPv27Zg0aRLi4+PRrl07yGQyXLhwAfXq1cPgwYPRqVMndOnSBXPmzEFGRgZatWqFq1evYsGCBfD19cWIESNKXE5h8nuomzdvhrm5OaRSKWrWrKlWE70yhoaG6NSpEz7++GPIZDJ89dVXyMjIwKJFi4Q0gwYNwvz58zF48GDMmjULWVlZ+Pbbb5WepBs2bIiwsDAcOXIETk5OMDc3L9KyAgAGBgb4+uuvMWzYMPTs2RMTJ05EdnY2VqxYgefPnwuPBmpL586d4erqiqCgIKSkpCi0DgFv7vOdOXMGPXr0QI0aNZCVlSU8/tKxY0chnZeXF4A3fTOKs27dOvTq1QstWrTAjBkzhGMvJCREuDBctmwZOnXqhHbt2uGTTz6BWCzG+vXrcf36dfz8888KtThDQ0OMHDkSq1atgoWFBfr161ekFalnz57YsWMHvL290ahRI1y+fBkrVqwo0zO5FhYWaNOmDVasWAFbW1t4eHjg3Llz2Lp1q8qLnJJ4eHjgs88+wxdffIHXr18Lj9XFxsbiyZMnWLRoEczMzLB27VqMGjUKT58+xYABA2Bvb4/U1FRcuXIFqampxQZ5V1dX1KpVC+fPn8fUqVOF4XXr1sWECROwdu1aGBgYoFu3bkhKSkJwcDDc3NwwY8YMjco0atQorF69GsOHD8eXX34JLy8vHD9+XLiQLe62WGn07NkTX3zxBRYsWIDAwEDEx8dj8eLFqFmzplqVC+DNWygDAwO199YzrXQ/e4tFRUXRgAEDyMHBgapVq0b29vbUr18/hUdsCjt58iQBIAD0zz//KE1z5coV4REQIyMjcnR0pPbt29PGjRuFNPLentHR0QrTZmVl0aRJk6hRo0ZkYWFBxsbGVLduXVqwYAG9fPlSSFe4V7G8t6Wyv4I9inNzc2nlypXUuHFjkkqlZGZmRt7e3jRx4kRKSEgQ0mVnZ9PMmTPJ3t6epFIptWjRgqKiosjd3b3E3t1Eb3pfzp8/n2rXrk1isZhsbGyoffv2Cuv29evXNGfOHHJ3dycjIyNycnKiDz/8sMhjPe7u7tSjR48iyyjci5SIaM2aNVSzZk0yNDRU6DkaGBhI9evXV5pXVb27v/rqK1q0aBG5urqSWCwmX19fCgkJKTL9sWPHqEmTJmRsbEy1atWi7777Tmkv1ZiYGGrVqhWZmJgQAGGZqnoNHzp0iJo3b05SqZRMTU2pQ4cOFBERoZBGvpyCj8cQ/bd/3blzR2mZC/vss8+Ex84K9ignenOc9O3bl9zd3UkikZCNjQ0FBgbS4cOHFdK5u7sX+8RB4Xl269aNLC0tSSKRkKenZ5GnCcLDw6l9+/ZkampKxsbG1KJFCzpy5IjS+f3zzz/C/h4aGlpk/LNnz2jcuHFkb29PJiYm9O6771J4eHiRbS/fFvv27SsyD2Xb6f79+9S/f3+ysrIic3Nz6tq1K12/fr3IcaLqeFe17Xfu3En+/v7CMerr66vQC5rozWNlPXr0IGtrazIyMiIXFxfq0aOH0rwXFhwcTFZWVgqPOhK96SH+1VdfUZ06dcjIyIhsbW1p+PDhdO/ePYV0pTmeiIju3r1L/fr1IzMzMzI3N6f+/fvTsWPHCAD99ttvQjpVvbvVOf6zs7Ppk08+IRcXF5JKpeTn50eHDh1S+gQGlPTuvnXrltKnX8pC9P8LY4wxxtT28OFD1KxZEzt37sSgQYMqJA9Lly7F559/jrt371bYW8YKCg4Oxs6dO5GYmKjWUyzq4CDNGGNMI3PmzMHx48cRExOjtSZnVeTfQvD29kZubi7OnDmDb7/9FoMGDcLOnTt1umx1PH/+HLVq1cLatWuLPHpaFnxPmjHGmEY+//xzmJiY4MGDB1p7V7UqJiYmWL16NZKSkpCdnY0aNWpgzpw5+Pzzz3W6XHXduXMHc+fOFd55oS1ck2aMMcb0FD+CxRhjjOkpDtKMMcaYnuIgzRhjjOkp7jhWiEwmw8OHD2Fubq69h9EZY4yxAogIL168KPEbBRykC3n48KHOeykyxhhjAHDv3r1in/HmIF2I/L3Y9+7dU+v1lYwxxlhpZWRkwM3NrcRvMXCQLkTexG1hYcFBmjHGmE6VdFuVO44xxhhjeoqDNGOMMaanuLmbMValhMY+QlRiGgI8bdDJRzvf9GWsonBNmjFWZYTGPsL4nZfwQ2QSxu+8hNDYRxWdJcbKhIM0Y6zKiEpMg6FIhHwiGIpEOH87raKzxFiZcJBmjFUZAZ42QoDOJ0KLWjYVnaVKIzT2ERYfieXWBz3DX8EqJCMjA5aWlkhPT+dHsBirhEJjH+H87TS0qKV/96T19X65/DaB/OJmy8h39Cp/VZG6sYY7jjHGqpROPg56GWAKBsJtEXf0KhAqu02gL3l723FzN2OMlQN9vl/Otwn0F9ekGWOsHAR42mBbxB29DISdfBywZeQ7enub4G3G96QL4XvSjDFd0ef75ax88T1pxhjTM/p6v5zpL74nzRhjjOkpDtKMMcaYnuLmbsb0mL4+V8sYKx8cpBnTU/r8XG1Z8cUHY+rh5m7G9JQ+P1dbFpp+BINfW8neRhykGdNTVfUFE5pcfPDXrdjbioM0Y3pK/oKJ0a08qlRTtyYXH1W1VYGxkvA9acb0WFV8rlaTt1vp89u6GNMlfuNYIfzGMcb0E7+ti2lTRXdeVDfWcJAuhIM0Y4xVbfrwaU51Y02luSe9bNky+Pv7w9zcHPb29ujTpw/i4+MV0owePRoikUjhr0WLFhWUY8YYY2Wli179lamPQ6UJ0ufOncPkyZNx/vx5hIaGIi8vD507d8bLly8V0nXt2hXJycnC37Fjxyoox4wxxspCV736K9OTE5Wm49iJEycUfm/fvh329va4fPky2rRpIwyXSCRwdHQs7+wxxspRRd9PZOVDWY1XG9u7Mn2as9LUpAtLT08HAFhbWysMDwsLg729PerUqYPx48fj8ePHFZE9VgXwyzP0Ez8z/fbQZY23k48Dgnv66HWABippxzEiQu/evfHs2TOEh4cLw/fu3QszMzO4u7vjzp07CA4ORl5eHi5fvgyJRKJ0XtnZ2cjOzhZ+Z2RkwM3NjTuOveX0oWMJU27xkVj8EJkknLxHt/JAcE+fis4W05Gq2qu/Sn9P+qOPPsLVq1fx559/KgwfNGiQ8P8GDRrgnXfegbu7O44ePYp+/fopndeyZcuwaNEinea3KquqzY66amZjZcfPTL9dquK7Akqj0jV3T5kyBYcPH8bZs2fh6upabFonJye4u7sjISFBZZq5c+ciPT1d+Lt37562s1xlVeVmx8rUseRtU1XfxMaYMpWmJk1EmDJlCg4ePIiwsDDUrFmzxGnS0tJw7949ODk5qUwjkUhUNoW/TTSpEVfl2mZl6ljyNnrba1es7FaExCPs5mO09bbHrC51Kzo7KlWaID158mT89NNP+O2332Bubo6UlBQAgKWlJYyNjZGZmYmFCxeif//+cHJyQlJSEj777DPY2tqib9++FZx7/abpJxGrerMjBwLGqqYVIfFYd/YWAOBGcgYAFAnU+nIrr9I0d2/YsAHp6elo27YtnJychL+9e/cCAAwNDXHt2jX07t0bderUwahRo1CnTh1ERUXB3Ny8gnOv3zR9sJ+bHRljldHhmAcKv49cUfytT7fyKk1NuqRO6MbGxggJCSmn3FQtZakRc22zciivWkFVWw6rmqxNxbj37LXw28pErDBen27lVZqaNNMdrhFXbeVVK6hqy2FV17u17Yr9rU8dRytNTZppX+HaCAfnqqm8agVVbTms6nqdkw8RAAIgApCVm68wXp86jnJN+i3FtZG3R3nVCqracljVZSw2hPwGKgGQGhkWSaMvbyTjmvRbimsjbw9t1QpKug9cXrUPfarlsMrpdY5izblwTVqfcJCuJLTdUaaqPz6lC5XluUplyno7Q93H9MrrtgnfnmFlkZKRpfA7OT1LRcqKx0G6EtD0OebicG2kdNR5rrIq45YXVpVcvJNW7G99wvekKwFdfaBcX+65VAZhNxW/phYW/3Z9XY3vAzNt0Jcvy+XkyhR/58lUpKx4GgfpvLw8nDp1Cps2bcKLFy8AAA8fPkRmZqbWMsfe4BNkxWvrba/4u669ipRVEz+mx8pKnzqrWpspPhdtbSpWkbLiadTc/e+//6Jr1664e/cusrOz0alTJ5ibm+Prr79GVlYWNm7cqO18vtW4aVo9unzBhbxpOyz+MdrWrXz3pLWB7wOzslB1y6QiXkzjZW+GpLRXBX7r71spNfqedJ8+fWBubo6tW7fCxsYGV65cQa1atXDu3Dl88MEHxX51St+p+41Ppl/4+8+M6TdlxyiACjlu5XmRPytdEecLnX5P+s8//0RERATEYsUmAnd3dzx48EDFVIzpDndsYky/KWsRXHwktkKOW01bJyui1q9RkJbJZMjPL/pc2f379/ljFqxCvA2PlPH7qlllV/iWSUUet6W9faOLp2zUoVGQ7tSpE9asWYPNmzcDAEQiETIzM7FgwQJ0795dqxlkTB1V/b59RZ0gGNOlijxuS3vRW1GtdRoF6dWrV6Ndu3bw8fFBVlYWhg4dioSEBNja2uLnn3/Wdh4ZU0tV7tjEzfmsqqqI41aTi96KqvVrFKSdnZ0RExODPXv24PLly5DJZBg3bhyGDRsGY2NjbeeRsbfe29Ccz94+FfUWP00ueiuq1q9R7+6qjHt3M30VGvuoyjbns7dPwbf4AcDkdl7lFqj14WkQdWONRi8zWbZsGbZt21Zk+LZt2/DVV19pMkvGWAn4DXGsKlHnLX66ekNZJx8HTG7nBW8nc0xu56XXx5RGQXrTpk3w9vYuMrx+/fr8IhPGGGMlKuktfrp8Q1lo7COsO3sLN5NfYN3ZWxX+mtLiaHRPOiUlBU5OTkWG29nZITk5ucyZYoyx0uDH07SrPNZnSW/x02VnycrUEVOjmrSbmxsiIiKKDI+IiICzs3OZM8UYU5++fLSgoujTO6GrgvJcn7O61MXRqa2V3ovW5TcLKtP3EDSqSX/wwQeYPn06cnNz0b59ewDA6dOnMXv2bMycOVOrGWSMqcbPT1euWlFloC/rU5e9qeX3pOW1eH3eXzQK0rNnz8bTp08RFBSEnJwcAIBUKsWcOXMwd+5crWaQMaaaNk6olb2pWF8eT9PFeqyIbaMv6xPQ3TPU8nvSIgA3HmagiVt1vd33y/QIVmZmJuLi4mBsbIzatWtDIpFoM28Vgh/BYpVJWR8l0YdHUbShoh9P08V6LM9tU/hioKLXp6598EM0TsX915u8Yz0HfD/qnXLNg04/sCFnZmYGf3//ssxCJ9avX48VK1YgOTkZ9evXx5o1a9C6deuKzhZjWlfWJsGKbtosqaaobk2yot82p4v1WF7bRtUtk6oYnAVFqqb6+7oQjTqOvXz5EsHBwWjZsiW8vLxQq1Ythb+KtHfvXkyfPh3z5s3D33//jdatW6Nbt264e/duheaLvb103bGrLM9PV2QHmpI6KOlDhzB1t50u1mN5bRtlFwNVndjIUPF3NUMVKSuexh3Hzp07hxEjRsDJyQkikUjb+dLYqlWrMG7cOHzwwQcAgDVr1iAkJAQbNmzAsmXL1J5PTn4OcvJzigw3EBmgmkE1hXSqiCCCkaGRRmlz83NBKq7udJUWAMSGYo3S5snyICNZqdOeinuE84lpaOFpg4713gQZIwMjYZ8qab6aps2X5SOfin7JTZO01QyqwUBkoDTtqbhH+HDXZRiKRNga8Q82j2iOLvWdyjzf4tLKSIY8WZ7KtIYiQxgavDkpdahnh/XDG+HC7TQ0r2WDwLpWCvtpwbSlma86aeXBIY9kMBTl489byQisayWkCU9IhoEoD3kkQjVRNZy/nYaO9eyRK8tVOd+CxycRlSmt4ra7he9HNhcuhAofy4F1rYT1GFDLTuGCSdNzRMF5Nq9lg7Z1rRWm1dZx71/TAtsi/rsYeMfDotg8l/c5QpmyniOu3EsF4b/tffV+KnLyc8r1HFHcOlaYVq1UhRw/fhxHjx5Fq1atNJlcZ3JycnD58mV8+umnCsM7d+6MyMhIpdNkZ2cjOztb+J2RkQEA+CbyG0hMi95jr21dG8MaDRN+r4hYofJE4FHdA6ObjBZ+rzm/Bq9yXylN62zujAlNJwi/10Wvw/Os50rT2pnYYXKzycLvzZc3I/VVqtK01aXVMb3FdOH39pjtePjiodK0JkYmmN1qtvB797XdSHqepDStkYER5rWZJ/zee30vEp4mKE0LAAvbLhT+fyDuAGJTY5GYmokjVx5CJBLh22hCr8bO8LQzw2etPxMO2N//+R37r/2J+09fw9XaGJ52ZgrzndVyFkzFpgCAkFshiH4YrTIP01tMR3VpdQDA6TunEXlP+T4BAEH+QbA3ffNyhfC74QhLClOZdrzfeLhYuAAAzt8/j9DbocK4c/GpyDB6DiKCSCRCyE1TIUhfTr6MYwnHVM53aMOhqGNTBwBw7fE1HLp5SGXa933eR337+gCAuNQ47IvdpzJtH+8+aOLYBABw6+ktXHzyE0QWwMUnwMVwxbTda3dHM5dmAIC76XexI2aHyvl2qtUJrWq8OSckv0jGlr+2qEzb1qMtAjzrYVvEHYhEGXhq+DtuZztjafh/2/dOTiaeGj6EMflAlO+LFrVskJ6djjXn16icr7+zP3rU6QEAeJX7CisiV6hM28SxCfp49wEA5MpysTR8qcL4gttOQu44f/u/N1MVTisnsgDSZLUBaO8cId8292N0d47YMnKIcMvkzuvfsDS86Dki4tYT3EvLx7gm04VHpnR9jlCl8DkiJiVGZVpl54gnBneRXi1LSCMVSbE0PKpczxHZL7NVpi9Io+ZuKysrWFtbl5ywnD158gT5+flwcFBs9nNwcEBKSorSaZYtWwZLS0vhz83NrTyyygDcf/oaIpFICGD3n70ukibm3nMcufIQMfff/JuYmlkBOdWcq7WxUD4igm+N6hWdJb0hv58+qJmbcIFWkKedGXo1dkbn+g4V0qGt4LaTQb+fpS2rkm6ZRNx6guikp3j0Igvrzt7CipD4cs6hdjWraV3sb32iUe/uXbt24bfffsMPP/wAExMTXeRLIw8fPoSLiwsiIyMREBAgDF+yZAl+/PFH3Lx5s8g0ymrSbm5uSH2aqrTHHTd3K0+rSVNWwebEfCJsGN4UHes5KDQjLTh8FT9G3RHul40IcMe8Hj7CvPS9uRt402wqb7LsWt9FoyZsXTV360PakpqlS5NWm83dwH/bLqCWHbo2cBGGF3csV8VzRO+1fyI2JeP/0xuhvrMFjk5tXWmbu785GY+N5xKFNJMCPTGzc91yPUdkZGTAztpON727v/nmGyQmJsLBwQEeHh4wMjJSGP/XX39pMtsys7W1haGhYZFa8+PHj4vUruUkEonSR8fEhmKFnUYVddJokrbgQVMZ0hY8KambtnsDN3w/Ulxsz+R3vRzwQ+Q9VPv/QP6ul5PK9ViaPBgaGMIQ6nUWKWva7g3c0L1B0RYaXeXBQGSg9r6mD2lFIpHeplW17XR13OvrOaJ9PRfEpfzX0iV/z7auzxG6SnvsaipE+C/vx6+lYm63hgppdX2OUHdbaxSk+/Tpo8lkOicWi9G0aVOEhoaib9++wvDQ0FD07t27AnPGVCnpUY+K+oYrY+w/Jb1nu7JJK3Q/+EmmeveHK0KV+5703r17MWLECGzcuBEBAQHYvHkztmzZghs3bsDd3b3E6bX1MpPK/hYnxiqbijzm1F02nxf0Q+15x5Cb/1/oMzIUIWFJ93LNQ7m8zEQfDRo0CGlpaVi8eDGSk5PRoEEDHDt2TK0ArS38PmXGypeyYw5AuQREdY93Pi/ojxrWJkhMfanwW19p1Ls7Pz8fK1euRLNmzeDo6Ahra2uFv4oWFBSEpKQkZGdn4/Lly2jTpk25Lv9tfDkAYxWp8DG3N/peub0IRd3jnc8L+iOwTvHfstYnGgXpRYsWYdWqVRg4cCDS09Px8ccfo1+/fjAwMMDChQu1nMXKpzJ9Bo2xqqDwMYcC/9dlQAyNfYS7aS/VOt75vKA/AjzfrHvD/++drc/bQqN70p6envj222/Ro0cPmJubIyYmRhh2/vx5/PTTT7rIa7nQ5j1p7uzEWPkpeMwB0PnHKQp/AKNjPQcM8ncr8Z40nxf0Q0VvC53ek05JSUHDhm+6q5uZmSE9PR0A0LNnTwQHB2syyyqnyr+gnjE9U/iY0/VTAYWbr91tTEpcDp8X9EfMvec4n5gGqZGhXm8TjYK0q6srkpOTUaNGDXh5eeHkyZPw8/NDdHR0lfhcJWOs8tN1QNSn7y4z9ch716dkZOHYtWQAwI3kNy9p0dfHyjQK0n379sXp06fRvHlzTJs2DUOGDMHWrVtx9+5dzJgxQ9t5ZIwxvcPP8FcuhW9PFBQW/7hqBenly5cL/x8wYABcXV0RGRkJLy8vvPfee1rLHGOM6bO3ofm6qjzbXfD2hAiKX5DW597dVe5lJmWlrY5jjDH9V1UCkK4Urn1W5me7C5ele0Mn/Jv2ssLeoKb1jmOHDx9Gt27dYGRkhMOHDxeblmvTjDF9xy8XKZmyZ7sr6zqqrLcn1A7Sffr0QUpKCuzt7Yt9d7dIJEJ+vuqvgTDGmD6oSgFIV6pa57jKeHtC7SAtk8mU/p8xxiqjqhaAdKGy1j6rklLfk87NzUXnzp2xadMm1KlTR1f5qjB8T5q9bd7m+7IV/UIL9vbS2ctMjIyMcP36deFj14yxyuttvy9bGZs/2dtFo3d3jxw5Elu3btV2Xhhj5Yw/+sCYftPoOemcnBx8//33CA0NxTvvvANTU1OF8atWrdJK5hhjusX3ZVl5e5tvr2hCo+ek27Vrp3qGIhHOnDlTpkxVJL4nzd42fF+WlRd9eu66oi8WdPqBjbNnz2qcMcaYfuH7sqy86Mtjb/KLBRGg930xNLonzRhjjJWWvnxTe+/FuwD+ezXo3ui7FZIPdWhUkwaA6Oho7Nu3D3fv3kVOTo7CuAMHDpQ5Y4wxxqoWvXnuusjDSfr7tJJGNek9e/agVatWiI2NxcGDB5Gbm4vY2FicOXMGlpaW2s4jY3ovNPYRFh+JRWjso4rOikYqe/5Z5dHJxwHBPX0qtHl5kH8NAP+F5kH+bhWWl5Jo1HGsUaNGmDhxIiZPngxzc3NcuXIFNWvWxMSJE+Hk5IRFixbpIq/lgjuOsdLSp84wmqjs+WdMExXdYVLdWKNRTToxMRE9evQAAEgkErx8+RIikQgzZszA5s2bNcsxY5WUvjxrrGltWF/yz1h50ocavTo0CtLW1tZ48eIFAMDFxQXXr18HADx//hyvXr3SXu4YqwT0oTOMvDb8Q2QSxu+8VKpArQ/5Z6y8VZZbPBp1HGvdujVCQ0PRsGFDDBw4ENOmTcOZM2cQGhqKDh06aDuPSEpKwhdffIEzZ84gJSUFzs7OGD58OObNmwexWCykU/aq0g0bNmDSpElazxNjcvrQGaYsj7boQ/6rsoLP4wJQeDY3NPbRm57Gojf3SfVt3Vf0s8S6Upleh6tRkP7uu++QlZUFAJg7dy6MjIzw559/ol+/fggODtZqBgHg5s2bkMlk2LRpE7y8vHD9+nWMHz8eL1++xMqVKxXSbt++HV27dhV+c0c2Vh4q+lnjsr45rKLzX1UVDgYAhP9PbueFdWdvCWlPxT3Wq2BRmQJZaenL89rq0ChIW1tbC/83MDDA7NmzMXv2bK1lqrCuXbsqBN5atWohPj4eGzZsKBKkq1evDkdHR53lhTF9xLVh/VQwGMjb+eSBISz+MUT471ldEaBXwaIyBbLSqkyvw9XonnS7du2wdetWpKenazs/aktPT1e4WJD76KOPYGtrC39/f2zcuJG/fc3eGpWlI8zbpOD9fsKbgCwPDG3r2qPgozUE6FWwqMp9FeQXtaNbeeh9C4FGj2BNnToV+/btw/Pnz9G9e3eMGDEC3bt3V7g/rEuJiYnw8/PDN998gw8++EAY/uWXX6JDhw4wNjbG6dOnMX/+fMydOxeff/65ynllZ2cjOztb+J2RkQE3Nzd+BIsxphUFH/UBoNDaERr76P/fdiXCIH83vQsWFf2YUlWm9uO+pKH8/HwKCQmhUaNGkYWFBVlZWdH48eMpLCxM7XksWLBAfnGp8i86OlphmgcPHpCXlxeNGzeuxPmvXLmSLCwsNMpDenq62uVgjDHGSiM9PV2tWKNRTbqwrKwsHDlyBEuWLMG1a9eQn5+v1nRPnjzBkydPik3j4eEBqVQKAHj48CHatWuH5s2bY8eOHTAwKL61PiIiAu+++y5SUlLg4KD8KpBr0owxVrGCdv8l1NjXD/Or6OyUC51+BauglJQU7NmzB7t27cLVq1fh7++v9rS2trawtbVVK+2DBw/Qrl07NG3aFNu3by8xQAPA33//DalUiurVq6tMI5FIIJFI1M0yY4wxLQra/ReOXUsGABy7loyg3X+9NYFaHRoF6YyMDOzfvx8//fQTwsLCUKtWLQwdOhR79uyBl5eXtvOIhw8fom3btqhRowZWrlyJ1NRUYZy8J/eRI0eQkpKCgIAAGBsb4+zZs5g3bx4mTJjAQZgxxvRU4TfcXeA33inQKEg7ODjAysoKAwcOxNKlS0tVe9bEyZMncevWLdy6dQuurq4K4+St9UZGRli/fj0+/vhjyGQy1KpVC4sXL8bkyZN1mjfGGGOaa1HLRqhJA0DzKtSLXBs0uid98uRJdOzYUa0m58qGP7DBGGPlK2j3X7hwOw3N+Z50EWXqOJaamor4+HiIRCLUqVMHdnZ2ms5Kb3CQZowxpms6/QrWq1evMHbsWDg5OaFNmzZo3bo1nJ2dMW7cOP7ABmOMMaYlGgXpGTNm4Ny5czhy5AieP3+O58+f47fffsO5c+cwc+ZMbeeRMcYYeytp1Nxta2uLX3/9FW3btlUYfvbsWQwcOFCh93Vlw83djDHGdE3nzd3KXg5ib2/Pzd2MMcaYlmgUpAMCArBgwQLhc5UA8Pr1ayxatAgBAQFayxxjjDH2NtPoOek1a9agW7ducHV1RePGjSESiRATEwOJRIKTJ09qO4+MMcbYW0njR7Bev36NXbt24ebNmyAi+Pj4YNiwYTA2NtZ2HssV35NmjDGmazp9d/eyZcvg4OCA8ePHKwzftm0bUlNTMWfOHE1myxhjjLECNLonvWnTJnh7excZXr9+fWzcuLHMmWKMMcaYhkE6JSUFTk5ORYbb2dkhOTlZyRSMMcYYKy2NgrSbmxsiIiKKDI+IiICzs3OZM8UYY4wxDe9Jf/DBB5g+fTpyc3PRvn17AMDp06cxe/ZsfuMYY4wxpiUaBenZs2fj6dOnCAoKQk5ODgBAKpVizpw5mDt3rlYzyBhjjL2tyvQVrMzMTMTFxcHY2Bi1a9eGRCLRZt4qBD+CxRhjTNd0+giWnJmZGfz9/csyC8YYY4ypoFHHMcYYY4zpHgdpxhhjTE9xkGaMMcb0FAdpxhhjTE9xkGaMMcb0FAdpxhhjTE9xkGaMMcb0VKUJ0h4eHhCJRAp/n376qUKau3fvolevXjA1NYWtrS2mTp0qvBGNMcYYq2zK9DKT8rZ48WKFb1ibmZkJ/8/Pz0ePHj1gZ2eHP//8E2lpaRg1ahSICGvXrq2I7DLGGGNlUqmCtLm5ORwdHZWOO3nyJGJjY3Hv3j3hS1zffPMNRo8ejSVLlvArPhljjFU6laa5GwC++uor2NjYoEmTJliyZIlCU3ZUVBQaNGig8KnMLl26IDs7G5cvX1Y5z+zsbGRkZCj8McYYY/qg0tSkp02bBj8/P1hZWeHixYuYO3cu7ty5g++//x4AkJKSAgcHB4VprKysIBaLkZKSonK+y5Ytw6JFi3Sad8YYY0wTFVqTXrhwYZHOYIX/Ll26BACYMWMGAgMD0ahRI3zwwQfYuHEjtm7dirS0NGF+IpGoyDKISOlwublz5yI9PV34u3fvnvYLyhhjjGmgQmvSH330EQYPHlxsGg8PD6XDW7RoAQC4desWbGxs4OjoiAsXLiikefbsGXJzc4vUsAuSSCRV4hObjDHGqp4KDdK2trawtbXVaNq///4bAODk5AQACAgIwJIlS5CcnCwMO3nyJCQSCZo2baqdDDPGGGPlqFLck46KisL58+fRrl07WFpaIjo6GjNmzMB7772HGjVqAAA6d+4MHx8fjBgxAitWrMDTp0/xySefYPz48dyzmzHGWKVUKYK0RCLB3r17sWjRImRnZ8Pd3R3jx4/H7NmzhTSGhoY4evQogoKC0KpVKxgbG2Po0KFYuXJlBeacMcYY05yIiKiiM6FPMjIyYGlpifT0dK6BM8YY0wl1Y02lek6aMcYYe5twkGaMMcb0FAdpxhhjTE9xkGaMMcb0FAdpxhhjTE9xkGaMMcb0FAdpxhhjTE9xkGaMMcb0FAdpxhhjTE9xkGZMR1aExKPH/8KxIiS+orPCGKukKsW7uxmrbFaExGPd2VsAgBvJGQCAWV3qVmSWGGOVENekGdOBsJuPFX/HK/4OjX2ExUdiERr7qDyzxRirZDhIM6YDbb3tFX/X/e93aOwjjN95CT9EJmH8zkscqBljKnFzN2M6IG/aDot/jLZ17RWauqMS02AoEiGfCIYiEc7fTkMnH4eKyipjTI9xkGZMR2Z1qav0PnSApw22RdwRAnWLWjYVkDvGWGXAQZqxctbJxwFbRr6D87fT0KKWDdeiGWMqcZBmrAJ08nHg4MwYKxF3HGOMMcb0FAdpxhhjTE9xc3chRAQAyMjIqOCcMMYYq6rkMUYec1ThIF3IixcvAABubm4VnBPGGGNV3YsXL2BpaalyvIhKCuNvGZlMhocPH8Lc3BwikUjr88/IyICbmxvu3bsHCwsLrc+/PHFZ9E9VKQfAZdFXVaUsFV0OIsKLFy/g7OwMAwPVd565Jl2IgYEBXF1ddb4cCwuLSr2DF8Rl0T9VpRwAl0VfVZWyVGQ5iqtBy3HHMcYYY0xPcZBmjDHG9BQH6XImkUiwYMECSCSSis5KmXFZ9E9VKQfAZdFXVaUslaUc3HGMMcYY01Nck2aMMcb0FAdpxhhjTE9xkGaMMcb0FAdpLXv27BlGjBgBS0tLWFpaYsSIEXj+/Hmx0xARFi5cCGdnZxgbG6Nt27a4ceOGMD4pKQkikUjp3759+ypVWeSioqLQvn17mJqaonr16mjbti1ev36to5Lorixt27Ytsk0GDx6ss3IAut0u8rTdunWDSCTCoUOHtF+A/6erckycOBGenp4wNjaGnZ0devfujZs3b+qsHIBuyvL06VNMmTIFdevWhYmJCWrUqIGpU6ciPT290pUFADZv3oy2bdvCwsICIpGoxHlqYv369ahZsyakUimaNm2K8PDwYtOfO3cOTZs2hVQqRa1atbBx48Yiafbv3w8fHx9IJBL4+Pjg4MGDWs93sYhpVdeuXalBgwYUGRlJkZGR1KBBA+rZs2ex0yxfvpzMzc1p//79dO3aNRo0aBA5OTlRRkYGERHl5eVRcnKywt+iRYvI1NSUXrx4UanKQkQUGRlJFhYWtGzZMrp+/Tr9888/tG/fPsrKyqp0ZQkMDKTx48crbJvnz5/rrBy6LIvcqlWrqFu3bgSADh48qKNS6K4cmzZtonPnztGdO3fo8uXL1KtXL3Jzc6O8vLxKVZZr165Rv3796PDhw3Tr1i06ffo01a5dm/r376+zcuiqLEREq1evpmXLltGyZcsIAD179kyr+d6zZw8ZGRnRli1bKDY2lqZNm0ampqb077//Kk1/+/ZtMjExoWnTplFsbCxt2bKFjIyM6NdffxXSREZGkqGhIS1dupTi4uJo6dKlVK1aNTp//rxW814cDtJaFBsbSwAUNmBUVBQBoJs3byqdRiaTkaOjIy1fvlwYlpWVRZaWlrRx40aVy2rSpAmNHTtWe5kvRJdlad68OX3++ec6y3thuixLYGAgTZs2TWd5L0zX+1hMTAy5urpScnKyToN0eR4rV65cIQB069Yt7RWggPIsyy+//EJisZhyc3O1V4ACyqMsZ8+e1UmQbtasGU2aNElhmLe3N3366adK08+ePZu8vb0Vhk2cOJFatGgh/B44cCB17dpVIU2XLl1o8ODBWsp1ybi5W4uioqJgaWmJ5s2bC8NatGgBS0tLREZGKp3mzp07SElJQefOnYVhEokEgYGBKqe5fPkyYmJiMG7cOO0WoABdleXx48e4cOEC7O3t0bJlSzg4OCAwMBB//vlnpSuL3O7du2Fra4v69evjk08+ET7Sogu6LMurV68wZMgQfPfdd3B0dNRZGYDyO1ZevnyJ7du3o2bNmjr7aE55lQUA0tPTYWFhgWrVdPNG5/Isizbl5OTg8uXLCnkAgM6dO6vMQ1RUVJH0Xbp0waVLl5Cbm1tsmvIqF8D3pLUqJSUF9vb2RYbb29sjJSVF5TQA4ODgoDDcwcFB5TRbt25FvXr10LJlyzLmWDVdleX27dsAgIULF2L8+PE4ceIE/Pz80KFDByQkJGizCAr50tV2GTZsGH7++WeEhYUhODgY+/fvR79+/bSY+6L50lVZZsyYgZYtW6J3795azLFyuj5W1q9fDzMzM5iZmeHEiRMIDQ2FWCzWUu6L5qs8jvu0tDR88cUXmDhxYhlzrFp5lUXbnjx5gvz8/FLlISUlRWn6vLw8PHnypNg05VUugIO0WhYuXKiy45b879KlSwCg9MtZRFTiF7UKj1c1zevXr/HTTz9pXIuu6LLIZDIAbzr3jBkzBr6+vli9ejXq1q2Lbdu2VaqyAMD48ePRsWNHNGjQAIMHD8avv/6KU6dO4a+//qpUZTl8+DDOnDmDNWvWlCrf+lYOuWHDhuHvv//GuXPnULt2bQwcOBBZWVmVsizAmy829ejRAz4+PliwYEGpyqFvZdGl0uZBWfrCwyu6XPwVLDV89NFHJfbY9fDwwNWrV/Ho0aMi41JTU4tcjcnJmxVTUlLg5OQkDH/8+LHSaX799Ve8evUKI0eOLE0RBBVdFvlwHx8fhWnr1auHu3fvql8QVHxZlPHz84ORkRESEhLg5+enTjEAVHxZzpw5g8TERFSvXl1h2v79+6N169YICwurFOWQk/dMrl27Nlq0aAErKyscPHgQQ4YMUasc+lSWFy9eoGvXrjAzM8PBgwdhZGSkdhnk9KUsumJrawtDQ8MiNdzi8uDo6Kg0fbVq1WBjY1NsmvIqFwDu3a1N8k4XFy5cEIadP39erU4XX331lTAsOztbZaeLwMBAnffuJNJdWWQyGTk7OxfpONakSROaO3euDkpSPttF7tq1awSAzp07p70CFKCrsiQnJ9O1a9cU/gDQ//73P7p9+3alKYcy2dnZZGxsTNu3b9da/gvSZVnS09OpRYsWFBgYSC9fvtRJ/gsqj+2iy45jH374ocKwevXqFdtxrF69egrDJk2aVKTjWLdu3RTSdO3atVw7jnGQ1rKuXbtSo0aNKCoqiqKioqhhw4ZFHl+oW7cuHThwQPi9fPlysrS0pAMHDtC1a9doyJAhSh+PSUhIIJFIRMePH6/UZVm9ejVZWFjQvn37KCEhgT7//HOSSqU6632rq7LcunWLFi1aRNHR0XTnzh06evQoeXt7k6+vr84f99HVPlYQyuERLG2XIzExkZYuXUqXLl2if//9lyIjI6l3795kbW1Njx49qlRlycjIoObNm1PDhg3p1q1bCo/5Vcb9Kzk5mf7++2/asmULAaA//viD/v77b0pLS9NKvuWPYG3dupViY2Np+vTpZGpqSklJSURE9Omnn9KIESOE9PJHsGbMmEGxsbG0devWIo9gRUREkKGhIS1fvpzi4uJo+fLl/AhWZZeWlkbDhg0jc3NzMjc3p2HDhhW5YgSgcFUvk8lowYIF5OjoSBKJhNq0aUPXrl0rMu+5c+eSq6sr5efn67gUb+iyLMuWLSNXV1cyMTGhgIAACg8Pr3RluXv3LrVp04asra1JLBaTp6cnTZ06VWsnnfIsizK6DtK6KMeDBw+oW7duZG9vT0ZGRuTq6kpDhw5VWQvU57LIa5zK/u7cuVOpykJEtGDBAqVl0WYLx7p168jd3Z3EYjH5+fkptGiNGjWKAgMDFdKHhYWRr68vicVi8vDwoA0bNhSZ5759+6hu3bpkZGRE3t7etH//fq3lVx38FSzGGGNMT3HvbsYYY0xPcZBmjDHG9BQHacYYY0xPcZBmjDHG9BQHacYYY0xPcZBmjDHG9BQHacYYY0xPcZBmjDHG9BQH6Spg9OjR6NOnj/C7bdu2mD59erksq7wkJSVBJBIhJiYGABAWFgaRSITnz58LaQ4dOgQvLy8YGhoK5Vc2rKrJycmBl5cXIiIihGE3b95EixYtIJVK0aRJk3LPU0XtJ8osXLgQDg4OEIlEOHTokFbnXdp5KttvKyIf2lL4uKzMXr16hf79+8PCwqJM28jf3x8HDhzQXsbK9f1mTG3u7u60evVqtdI+f/5c4bV9gYGBNG3atDIt/86dOwSA/v7772KXVV4K5yc7O5uSk5NJJpMJaezt7WnOnDn04MED4Z3ByoZVNWvXrqX27dsrDBs4cCC1b9+ekpKS6MmTJzpbtr7tJ4XJPxhx8OBBSk5OpqysLK3Ov7TzVLbfagN0/ApXVfLy8ig5OZlyc3PLfdnatn79erKzs6Nr164p3UaBgYEqX9MKgNzd3YmI6LfffqPatWtr7fXN/KnKSiw/Px8ikQiWlpbltszyXFZxxGKx8Ik8AMjMzMTjx4/RpUsXODs7qxymiZycHIjF4jLnWVfWrl2LhQsXKgxLTExEjx494O7urnK63NxcjT57qA592U8SExMBAL1799bqN4Dl+0TBfVAdmkyjrzRdB/oqMTER9erVQ4MGDZSOP3DgAHJycgAA9+7dQ7NmzXDq1CnUr18fAGBoaAgA6NGjB8aPH4+QkBB069at7BnTSqh/y+Tn59Py5cvJ09OTxGIxubm50ZdffimMv3r1KrVr146kUilZW1vT+PHj6cWLF8L4UaNGUe/evWnFihXk6OhI1tbWFBQURDk5OUSk/IqNiGj79u1kaWlJR44coXr16pGhoSHdvn1bmJ9cYGAgTZ48mSZPnkyWlpZkbW1N8+bNU7gyhJIrb0tLS+Fl94WXL38xfeFlZWVl0ZQpU8jOzo4kEgm1atWKLl68KIyXfyTg1KlT1LRpUzI2NqaAgIASP3hw4cIFatKkCUkkEmratCkdOHBAocZW8HN3yj5EoGoY0Zsv27Ru3ZqkUim5urrSlClTKDMzU1i2u7s7ffHFFzRq1CiysLCgkSNHqj3dkiVLaMyYMWRmZkZubm60adMmhXLdu3ePBg0aRFZWVmRiYkJNmzZV+KLO4cOHyc/PjyQSCdWsWZMWLlxYbC3l8uXLZGBgQOnp6cKwwuVesGCBUOPdu3cvBQYGkkQioW3bttGTJ09o8ODB5OLiQsbGxtSgQQP66aefFJZR3P5e0ftJcceasg86qBIWFkb+/v4kFovJ0dGR5syZo7De5cfUjBkzyMbGhtq0aSOUv+BxFBERQY0bNxb224MHD6rcb4n+O6ZPnDhB3t7eZGpqSl26dKGHDx8K87x48SJ17NiRbGxsyMLCgtq0aUOXL19WyL+y41lu48aN5OzsXKRm16tXL2HfvnXrFr333ntkb29Ppqam9M4771BoaKhCemXHReGWlLy8PBo7dix5eHiQVCqlOnXq0Jo1axTmU9L5j+jN/jJr1ixydXUlsVhMXl5e9P333wvjb9y4Qd26dSNTU1Oyt7en4cOHU2pqqtLyy/3666/k4+NDYrGY3N3daeXKlcK4wufcwh/iKExVC5Lc6NGjFb64VRYcpDUwe/ZssrKyoh07dtCtW7coPDyctmzZQkREL1++JGdnZ+rXrx9du3aNTp8+TTVr1qRRo0YJ08t38kmTJlFcXBwdOXKETExMaPPmzUT05is0rq6utHjxYuHTdERvDmgjIyNq2bIlRURE0M2bNykzM1NpkDYzM6Np06bRzZs3adeuXQrzJyo5SF+8eFE4aSYnJwtfdiq8rKlTp5KzszMdO3aMbty4QaNGjSIrKyshvfyk1Lx5cwoLC6MbN25Q69atqWXLlirXb2ZmJtnZ2dGgQYPo+vXrdOTIEapVq5bKk112djbFx8cTANq/fz8lJyerHHb16lUyMzOj1atX0z///EMRERHk6+tLo0ePFpbv7u5OFhYWtGLFCkpISKCEhAS1p7O2tqZ169ZRQkICLVu2jAwMDCguLo6IiF68eEG1atWi1q1bU3h4OCUkJNDevXspMjKSiIhOnDhBFhYWtGPHDkpMTKSTJ0+Sh4cHLVy4UOW6Wr16NXl7eysMS05Opvr169PMmTMpOTmZXrx4IZxUPDw8aP/+/XT79m168OAB3b9/n1asWEF///03JSYm0rfffkuGhoYKFw7F7e8VuZ+UdKy9ePGCtm/fTgAUjqPC7t+/TyYmJhQUFERxcXF08OBBsrW1pQULFghp5MfUrFmz6ObNm8I2LXgcZWRkkLW1NQ0fPpxu3LhBx44dozp16pQYpI2MjKhjx44UHR1Nly9fpnr16tHQoUOFZZ8+fZp+/PFHio2NpdjYWBo3bhw5ODgo3L4pLkinpaWRWCymU6dOCcOePn1KYrGYQkJCiIgoJiaGNm7cSFevXqV//vmH5s2bR1KplP79919hGmXHReFglZOTQ/Pnz6eLFy/S7du3hXPP3r17hfmUdP4jenO7xs3NjQ4cOECJiYl06tQp2rNnDxERPXz4kGxtbWnu3LkUFxdHf/31F3Xq1InatWuntPxERJcuXSIDAwNavHgxxcfH0/bt2xW+MZ6Wlkbjx4+ngIAAhf1YlZKC9Pr168nDw6PYeaiLg3QpZWRkkEQiEU5ShW3evJmsrKwUalhHjx4lAwMDSklJIaI3O6m7u7vCN2Hff/99GjRokPBb2T1p+QknJiZGYbiyIF2vXj2FmvOcOXMUPnBeUpBWtRMWXFZmZiYZGRnR7t27hfE5OTnk7OxMX3/9NREp1pAKrg8A9Pr1a1Jm06ZNZG1trfCR+w0bNhR7snv27JlCbVnVsBEjRtCECRMUlhceHk4GBgZCftzd3alPnz4KadSdbvjw4cJ4mUxG9vb2wufvNm3aRObm5ipPAK1bt6alS5cqDPvxxx/JyclJaXoiomnTphW5H01E1LhxY4UgI9+ehWs1ynTv3p1mzpxJRCXv7xW5n6hzrMlrssX57LPPqG7dugrHy7p168jMzEyofQYGBlKTJk2KTFvwONqwYQPZ2Ngo5Ff+7eTigjQAhW+pr1u3jhwcHFTmNy8vj8zNzenIkSNK86HMe++9R2PHjhV+b9q0iRwdHYv9LrWPjw+tXbtW+K3suCgpWBERBQUFUf/+/YXfJZ3/5BfXhWvycsHBwdS5c2eFYffu3SMAFB8fr3SaoUOHUqdOnRSGzZo1i3x8fITf06ZNK7EGLVdSuX/77TcyMDDQyn1p7t1dSnFxccjOzkaHDh1Ujm/cuDFMTU2FYa1atYJMJkN8fLwwrH79+sI9DABwcnLC48ePS1y+WCxGo0aNSkzXokULhXtwAQEBSEhIQH5+fonTqisxMRG5ublo1aqVMMzIyAjNmjVDXFycQtqCeXZycgIAleWVr0MTExOF/GvD5cuXsWPHDpiZmQl/Xbp0gUwmw507d4R077zzjkbTFSynSCSCo6OjUM6YmBj4+vrC2tpaZd4WL16ssIzx48cjOTkZr169UjrN69evIZVK1S5/4XLl5+djyZIlaNSoEWxsbGBmZoaTJ0/i7t27AEre39Wh6/2kpGOtJHFxcQgICFA4Xlq1aoXMzEzcv39fGFZ43RUWHx+PRo0aKWyPZs2albh8ExMTeHp6Cr8LnwseP36MSZMmoU6dOrC0tISlpSUyMzOFbaSOYcOGYf/+/cjOzgYA7N69G4MHDxbOQS9fvsTs2bPh4+OD6tWrw8zMDDdv3iyyjJLWAQBs3LgR77zzDuzs7GBmZoYtW7YUmU9x57+YmBgYGhoiMDBQ6fwvX76Ms2fPKhwn3t7eAP7rg1BYXFycwv4HvNnG2j4nyhkbG0Mmkwnruyy441gpGRsbFzueiFR2UCk4vHCHHZFIBJlMptbytdEBRiQSgQp9Sjw3N7dU85BPXzg/ytZBwfLKx6kqb+F8aZNMJsPEiRMxderUIuNq1Kgh/L/gib800xW3XUvad2QyGRYtWoR+/foVGacqENva2uLatWvFzregwuX65ptvsHr1aqxZswYNGzaEqakppk+fLnSQKSnP6tDlfqLOsaZO/pTlrfB8Cq+70synOMr2mYLTjR49GqmpqVizZg3c3d0hkUgQEBAgbCN19OrVCzKZDEePHoW/vz/Cw8OxatUqYfysWbMQEhKClStXwsvLC8bGxhgwYECRZZS0Dn755RfMmDED33zzDQICAmBubo4VK1bgwoULJZa5NMdJr1698NVXXxUZJ7+wK0zTbaOpp0+fwsTERCvHD9ekS6l27dowNjbG6dOnlY738fFBTEwMXr58KQyLiIiAgYEB6tSpo/ZyxGJxma7wzp8/X+R37dq1hatXOzs7JCcnC+MTEhIUamvy3szF5cHLywtisRh//vmnMCw3NxeXLl1CvXr1NM67j48Prly5gtevX6ssj6b8/Pxw48YNeHl5Ffkrrge3ptMV1KhRI8TExODp06cqlxEfH690GQYGyg9VX19f3Lx5U+MTTnh4OHr37o3hw4ejcePGqFWrFhISEoTxJe3vFb2faONY8/HxQWRkpMI6jIyMhLm5OVxcXNSej7e3N65evapQe7p06ZLa06sSHh6OqVOnonv37qhfvz4kEgmePHlSqnkYGxujX79+2L17N37++WfUqVMHTZs2VVjG6NGj0bdvXzRs2BCOjo5ISkrSKK8tW7ZEUFAQfH194eXlpbJ2q0rDhg0hk8lw7tw5pePlx6KHh0eR40TVRYSPj4/C/ge82cZ16tRRqNFry/Xr1+Hn56eVeXGQLiWpVIo5c+Zg9uzZ2LlzJxITE3H+/Hls3boVwJtmJalUilGjRuH69es4e/YspkyZghEjRsDBwUHt5Xh4eOCPP/7AgwcPSn1AAm8eEfj4448RHx+Pn3/+GWvXrsW0adOE8e3bt8d3332Hv/76C5cuXcKkSZMUrm7t7e1hbGyMEydO4NGjR0hPTy+yDFNTU3z44YeYNWsWTpw4gdjYWIwfPx6vXr3CuHHjSp1nuaFDh8LAwADjxo1DbGwsjh07hpUrV2o8v4LmzJmDqKgoTJ48GTExMUhISMDhw4cxZcoUnUxX0JAhQ+Do6Ig+ffogIiICt2/fxv79+xEVFQUAmD9/Pnbu3ImFCxfixo0biIuLw969e/H555+rnGe7du3w8uVL3LhxQ+18FOTl5YXQ0FBERkYiLi4OEydOREpKijC+pP29IvcTbR1rQUFBuHfvHqZMmYKbN2/it99+w4IFC/Dxxx+rvDhSZujQoZDJZJgwYQLi4uKEmilQupp9YV5eXvjxxx8RFxeHCxcuYNiwYRrV0IYNG4ajR49i27ZtGD58eJFlHDhwADExMbhy5YpQFk3yeunSJYSEhOCff/5BcHAwoqOjSzUPDw8PjBo1CmPHjsWhQ4dw584dhIWF4ZdffgEATJ48GU+fPsWQIUNw8eJF3L59GydPnsTYsWNVXizOnDkTp0+fxhdffIF//vkHP/zwA7777jt88sknpS6jOsLDw9G5c2etzIuDtAaCg4Mxc+ZMzJ8/H/Xq1cOgQYOE+ykmJiYICQnB06dP4e/vjwEDBqBDhw747rvvSrWMxYsXIykpCZ6enrCzsyt1HkeOHInXr1+jWbNmmDx5MqZMmYIJEyYI47/55hu4ubmhTZs2GDp0KD755BOFe8DVqlXDt99+i02bNsHZ2Rm9e/dWupzly5ejf//+GDFiBPz8/HDr1i2EhITAysqq1HmWMzMzw5EjRxAbGwtfX1/MmzdPadOWJho1aoRz584hISEBrVu3hq+vL4KDg1U2k5V1uoLEYjFOnjwJe3t7dO/eHQ0bNsTy5cuFK/kuXbrg999/R2hoKPz9/dGiRQusWrWq2GedbWxshBqSJoKDg+Hn54cuXbqgbdu2wkVE4TSq9veK3E+0day5uLjg2LFjuHjxIho3boxJkyZh3LhxxV4cKWNhYYEjR44gJiYGTZo0wbx58zB//nwAqm9XqGPbtm149uwZfH19MWLECEydOhX29valnk/79u1hbW2N+Ph4DB06VGHc6tWrYWVlhZYtW6JXr17o0qWLRjXBSZMmoV+/fhg0aBCaN2+OtLQ0BAUFlXo+GzZswIABAxAUFARvb2+MHz9eaDFxdnZGREQE8vPz0aVLFzRo0ADTpk2DpaWlyosqPz8//PLLL9izZw8aNGiA+fPnY/HixRg9enSp81aSBw8eIDIyEmPGjNHK/ESky4Z5xpjOXbt2DR07dsStW7dgbm5e0dlhBezevRtjxoxBenq6Vu5PMv03a9YspKenY/PmzVqZH3ccY6ySa9iwIb7++mskJSWhYcOGFZ2dt9rOnTtRq1YtuLi44MqVK5gzZw4GDhzIAfotYm9vr9VmdK5JM8aYlnz99ddYv349UlJS4OTkhD59+mDJkiUKt5IYKw0O0owxxpie4o5jjDHGmJ7iIM0YY4zpKQ7SjDHGmJ7iIM0YY4zpKQ7SjDHGmJ7iIM0YY4zpKQ7SjDHGmJ7iIM0YY4zpKQ7SjDHGmJ76P3zzOAz0u3IHAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 500x250 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(5,2.5))\n",
    "plt.scatter(*np.array(collector).T, s=4)\n",
    "plt.title('Oversized contribution vs. covariance (original)')\n",
    "plt.ylabel('covariance')\n",
    "plt.xlabel('contribution difference (fraction of original variance of T)')\n",
    "plt.tight_layout()\n",
    "plt.axhline(0, color=\"g\", alpha=0.5, linestyle=\"--\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "7d6b5a7b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.lines.Line2D at 0x7f2d8c148b20>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 500x250 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(5,2.5))\n",
    "plt.scatter(*np.array(collector3).T, s=4)\n",
    "plt.title('Oversized contribution vs. covariance (fixed)')\n",
    "plt.ylabel('covariance')\n",
    "plt.xlabel('contribution difference (fraction of original variance of T)')\n",
    "plt.tight_layout()\n",
    "plt.axhline(0, color=\"k\", alpha=0.5, linestyle=\"--\")\n",
    "plt.axvline(0, color=\"k\", alpha=0.5, linestyle=\"--\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db81e8ad",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:lgbm]",
   "language": "python",
   "name": "conda-env-lgbm-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}