diff --git a/.doctrees/03_api.doctree b/.doctrees/03_api.doctree index cb03440..0edbb68 100644 Binary files a/.doctrees/03_api.doctree and b/.doctrees/03_api.doctree differ diff --git a/.doctrees/demos/card_matcher.doctree b/.doctrees/demos/card_matcher.doctree index 20c97b4..35c111a 100644 Binary files a/.doctrees/demos/card_matcher.doctree and b/.doctrees/demos/card_matcher.doctree differ diff --git a/.doctrees/demos/lp_matcher.doctree b/.doctrees/demos/lp_matcher.doctree index 7550ed9..b4bf9eb 100644 Binary files a/.doctrees/demos/lp_matcher.doctree and b/.doctrees/demos/lp_matcher.doctree differ diff --git a/.doctrees/environment.pickle b/.doctrees/environment.pickle index e8f5057..e153fbd 100644 Binary files a/.doctrees/environment.pickle and b/.doctrees/environment.pickle differ diff --git a/.doctrees/nbsphinx/demos/card_matcher.ipynb b/.doctrees/nbsphinx/demos/card_matcher.ipynb index d91dad4..9520a10 100644 --- a/.doctrees/nbsphinx/demos/card_matcher.ipynb +++ b/.doctrees/nbsphinx/demos/card_matcher.ipynb @@ -8,6 +8,26 @@ "# Cardinality matching" ] }, + { + "cell_type": "markdown", + "id": "14c518ee-3bc0-493a-9eb3-e2a289642823", + "metadata": {}, + "source": [ + "Cardinality matching is the process of finding the size of the largest subset $\\hat{P}$ of a pool of patient $P$ within some \"distance\" of a given target population:\n", + "\n", + "\\begin{equation}\n", + "\\begin{aligned}\n", + "& \\underset{\\hat{P}}{\\text{maximize}}\n", + "& & |\\hat{P}| \\\\\n", + "& \\text{subject to}\n", + "& & |\\mu_{\\hat{P},k} - \\mu_{T,k}| \\leq \\delta \\textrm{ for all }k\n", + "\\end{aligned}\n", + "\\end{equation}\n", + "\n", + "where $k$ indexes the covariates of $P$ and $T$. In cardinality matching, at least as implemented here, we search only for the size of the largest subset.\n", + "Then in a second step, we optimize the balance (distance) among all subsets of the determined size." + ] + }, { "cell_type": "code", "execution_count": 1, @@ -253,7 +273,7 @@ "" ], "text/plain": [ - "" + "" ] }, "execution_count": 3, @@ -271,7 +291,7 @@ "id": "4e699cd6-9f4c-4493-a261-0a704f288c64", "metadata": {}, "source": [ - "## Optimize pool size subject to balance constraint" + "## Optimize pool size with balance constraint" ] }, { @@ -294,93 +314,109 @@ "INFO:pybalance.lp.matcher:Calculating bounds on feature variables ...\n", "INFO:pybalance.lp.matcher:Applying size constraints on pool and target ...\n", "INFO:pybalance.lp.matcher:Solving with 4 workers ...\n", - "INFO:pybalance.lp.matcher:Initial balance score: 0.2095\n", + "INFO:pybalance.lp.matcher:Initial balance score: 0.1236\n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 1, time = 0.34 m\n", + "INFO:pybalance.lp.matcher:Solution 1, time = 0.36 m\n", "INFO:pybalance.lp.matcher:Objective:\t13153.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0117\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0068\n", "INFO:pybalance.lp.matcher:Patients (pool):\t1847\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 2, time = 0.45 m\n", + "INFO:pybalance.lp.matcher:Solution 2, time = 0.47 m\n", "INFO:pybalance.lp.matcher:Objective:\t12981.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0280\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0163\n", "INFO:pybalance.lp.matcher:Patients (pool):\t2019\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 3, time = 0.47 m\n", - "INFO:pybalance.lp.matcher:Objective:\t12979.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0382\n", - "INFO:pybalance.lp.matcher:Patients (pool):\t2021\n", + "INFO:pybalance.lp.matcher:Solution 3, time = 0.53 m\n", + "INFO:pybalance.lp.matcher:Objective:\t12937.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0171\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t2063\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 4, time = 0.49 m\n", - "INFO:pybalance.lp.matcher:Objective:\t12909.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0380\n", - "INFO:pybalance.lp.matcher:Patients (pool):\t2091\n", + "INFO:pybalance.lp.matcher:Solution 4, time = 0.55 m\n", + "INFO:pybalance.lp.matcher:Objective:\t12910.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0178\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t2090\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 5, time = 0.51 m\n", - "INFO:pybalance.lp.matcher:Objective:\t12879.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0383\n", - "INFO:pybalance.lp.matcher:Patients (pool):\t2121\n", + "INFO:pybalance.lp.matcher:Solution 5, time = 0.98 m\n", + "INFO:pybalance.lp.matcher:Objective:\t12907.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0179\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t2093\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 6, time = 0.85 m\n", - "INFO:pybalance.lp.matcher:Objective:\t12827.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0387\n", - "INFO:pybalance.lp.matcher:Patients (pool):\t2173\n", + "INFO:pybalance.lp.matcher:Solution 6, time = 1.28 m\n", + "INFO:pybalance.lp.matcher:Objective:\t12906.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0250\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t2094\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 7, time = 1.94 m\n", - "INFO:pybalance.lp.matcher:Objective:\t11000.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0648\n", - "INFO:pybalance.lp.matcher:Patients (pool):\t4000\n", + "INFO:pybalance.lp.matcher:Solution 7, time = 2.22 m\n", + "INFO:pybalance.lp.matcher:Objective:\t12689.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0259\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t2311\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 8, time = 2.10 m\n", + "INFO:pybalance.lp.matcher:Solution 8, time = 2.39 m\n", + "INFO:pybalance.lp.matcher:Objective:\t12632.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0260\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t2368\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 9, time = 2.39 m\n", "INFO:pybalance.lp.matcher:Objective:\t10818.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0704\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0413\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:Status = FEASIBLE\n", - "INFO:pybalance.lp.matcher:Number of solutions found: 8\n" + "INFO:pybalance.lp.matcher:Number of solutions found: 9\n" ] } ], "source": [ + "# Note that by default, gamma uses the standardized mean difference \n", + "# to calculate distance. The ConstraintSatisfactionMatcher, however,\n", + "# can only optimize linear objectives. It is not an error to pass \n", + "# gamma with standardized_difference=True, at this is only affects\n", + "# reporting, but to make the reporting consistent with what we're \n", + "# optimizing, we explicitly pass standardized_difference=False here.\n", + "\n", + "gamma = GammaBalance(m, standardize_difference=False)\n", "matcher = ConstraintSatisfactionMatcher(\n", " matching_data=m, \n", - " objective='gamma', \n", - " max_mismatch=0.05, \n", + " objective=gamma,\n", + " max_mismatch=0.05,\n", " time_limit=600\n", ")\n", "match_card = matcher.match()" ] }, + { + "cell_type": "markdown", + "id": "47da2013-6ffe-4d68-a9b6-d87f89e0ccf4", + "metadata": {}, + "source": [ + "Note that as the optimization progresses, the size of the matched population increases and the balance also increases. This will generally be the case, since it is harder to find a larger set of patients (they have more degrees of freedom) that match a given target. Increased mismatch is the tradeoff of having a larger matched population.\n", + "\n", + "Let's check that the found solution satisfies the balance constraint:" + ] + }, { "cell_type": "code", "execution_count": 5, "id": "a76e9375-d27f-4f9d-aea4-27d1f7e7a483", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pybalance.utils.preprocess:Discretized age with bins [18.02, 27.51, 37.01, 46.51, 56.0, 65.5, 75.0].\n", - "INFO:pybalance.utils.preprocess:Discretized height with bins [125.0, 136.67, 148.33, 159.99, 171.66, 183.32, 194.99].\n", - "INFO:pybalance.utils.preprocess:Discretized weight with bins [50.01, 61.67, 73.34, 85.0, 96.67, 108.33, 120.0].\n" - ] - }, { "data": { "text/plain": [ @@ -393,7 +429,6 @@ } ], "source": [ - "gamma = GammaBalance(m, standardize_difference=False)\n", "gamma.per_feature_loss(match_card.get_population('pool')).max()" ] }, @@ -405,7 +440,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -435,7 +470,15 @@ "id": "ce715a25-d006-419d-ab1b-c6dfe3e77c29", "metadata": {}, "source": [ - "## Optimize balance with balance constraint" + "## Optimize balance with size and balance constraints" + ] + }, + { + "cell_type": "markdown", + "id": "5dde7ed9-75af-486c-82c6-2e69ae040ab0", + "metadata": {}, + "source": [ + "Now that we have determined the optimal size of the matched population, let's optimize the balance for all subsets of that size. For this, we create a second matcher object, setting size constraints and keeping the balance constraint (max_mismatch)." ] }, { @@ -448,9 +491,6 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO:pybalance.utils.preprocess:Discretized age with bins [18.02, 27.51, 37.01, 46.51, 56.0, 65.5, 75.0].\n", - "INFO:pybalance.utils.preprocess:Discretized height with bins [125.0, 136.67, 148.33, 159.99, 171.66, 183.32, 194.99].\n", - "INFO:pybalance.utils.preprocess:Discretized weight with bins [50.01, 61.67, 73.34, 85.0, 96.67, 108.33, 120.0].\n", "INFO:pybalance.lp.matcher:Scaling features by factor 200.00 in order to use integer solver with <= 0.0000% loss.\n", "INFO:pybalance.lp.matcher:Solving for match population with pool size = 4182 and target size = 1000 subject to 0.05 balance constraint.\n", "INFO:pybalance.lp.matcher:Matching on 27 dimensions ...\n", @@ -458,46 +498,46 @@ "INFO:pybalance.lp.matcher:Calculating bounds on feature variables ...\n", "INFO:pybalance.lp.matcher:Applying size constraints on pool and target ...\n", "INFO:pybalance.lp.matcher:Solving with 4 workers ...\n", - "INFO:pybalance.lp.matcher:Initial balance score: 0.2095\n", + "INFO:pybalance.lp.matcher:Initial balance score: 0.1236\n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 1, time = 0.25 m\n", + "INFO:pybalance.lp.matcher:Solution 1, time = 0.29 m\n", "INFO:pybalance.lp.matcher:Objective:\t825443200.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0644\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0366\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 2, time = 0.31 m\n", + "INFO:pybalance.lp.matcher:Solution 2, time = 0.37 m\n", "INFO:pybalance.lp.matcher:Objective:\t825304800.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0644\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0365\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 3, time = 0.47 m\n", + "INFO:pybalance.lp.matcher:Solution 3, time = 0.55 m\n", "INFO:pybalance.lp.matcher:Objective:\t733533600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0557\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0325\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 4, time = 3.09 m\n", + "INFO:pybalance.lp.matcher:Solution 4, time = 3.59 m\n", "INFO:pybalance.lp.matcher:Objective:\t733527200.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0557\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0325\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 5, time = 3.59 m\n", + "INFO:pybalance.lp.matcher:Solution 5, time = 4.10 m\n", "INFO:pybalance.lp.matcher:Objective:\t733465600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0557\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0325\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 6, time = 3.73 m\n", + "INFO:pybalance.lp.matcher:Solution 6, time = 4.24 m\n", "INFO:pybalance.lp.matcher:Objective:\t733395200.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0557\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0325\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", @@ -509,7 +549,7 @@ "source": [ "matcher = ConstraintSatisfactionMatcher(\n", " matching_data=m, \n", - " objective='gamma', \n", + " objective=gamma, \n", " max_mismatch=0.05, \n", " pool_size=len(match_card.get_population('pool')),\n", " target_size=len(match_card.get_population('target')),\n", @@ -559,6 +599,14 @@ "## Optimize balance without balance constraint" ] }, + { + "cell_type": "markdown", + "id": "dea30112-beb0-49b8-95bc-c7f95444fcaf", + "metadata": {}, + "source": [ + "You can also remove the balance constraint, if you don't care about individual mismatched features. Here we run a matcher fixed to the size of the optimal subset size but relax the mismatch constraint." + ] + }, { "cell_type": "code", "execution_count": 9, @@ -569,9 +617,6 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO:pybalance.utils.preprocess:Discretized age with bins [18.02, 27.51, 37.01, 46.51, 56.0, 65.5, 75.0].\n", - "INFO:pybalance.utils.preprocess:Discretized height with bins [125.0, 136.67, 148.33, 159.99, 171.66, 183.32, 194.99].\n", - "INFO:pybalance.utils.preprocess:Discretized weight with bins [50.01, 61.67, 73.34, 85.0, 96.67, 108.33, 120.0].\n", "INFO:pybalance.lp.matcher:Scaling features by factor 200.00 in order to use integer solver with <= 0.0000% loss.\n", "INFO:pybalance.lp.matcher:Solving for match population with pool size = 4182 and target size = 1000 subject to None balance constraint.\n", "INFO:pybalance.lp.matcher:Matching on 27 dimensions ...\n", @@ -579,81 +624,81 @@ "INFO:pybalance.lp.matcher:Calculating bounds on feature variables ...\n", "INFO:pybalance.lp.matcher:Applying size constraints on pool and target ...\n", "INFO:pybalance.lp.matcher:Solving with 4 workers ...\n", - "INFO:pybalance.lp.matcher:Initial balance score: 0.2095\n", + "INFO:pybalance.lp.matcher:Initial balance score: 0.1236\n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 1, time = 0.07 m\n", "INFO:pybalance.lp.matcher:Objective:\t2127925600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1582\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0942\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 2, time = 0.11 m\n", "INFO:pybalance.lp.matcher:Objective:\t2020125600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1489\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0895\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 3, time = 0.13 m\n", "INFO:pybalance.lp.matcher:Objective:\t2019725600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1489\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0894\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 4, time = 0.20 m\n", "INFO:pybalance.lp.matcher:Objective:\t2016325600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1487\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0893\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 5, time = 0.26 m\n", "INFO:pybalance.lp.matcher:Objective:\t2015325600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1486\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0892\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 6, time = 0.32 m\n", "INFO:pybalance.lp.matcher:Objective:\t2012125600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1483\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0891\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 7, time = 0.32 m\n", "INFO:pybalance.lp.matcher:Objective:\t2011725600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1482\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0891\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 8, time = 0.34 m\n", "INFO:pybalance.lp.matcher:Objective:\t2011525600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1482\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0891\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 9, time = 0.36 m\n", "INFO:pybalance.lp.matcher:Objective:\t2011325600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1482\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0891\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 10, time = 0.66 m\n", + "INFO:pybalance.lp.matcher:Solution 10, time = 0.65 m\n", "INFO:pybalance.lp.matcher:Objective:\t478921600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0346\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0212\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 11, time = 1.19 m\n", + "INFO:pybalance.lp.matcher:Solution 11, time = 1.18 m\n", "INFO:pybalance.lp.matcher:Objective:\t478920000.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0346\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0212\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", @@ -665,7 +710,7 @@ "source": [ "matcher = ConstraintSatisfactionMatcher(\n", " matching_data=m, \n", - " objective='gamma', \n", + " objective=gamma, \n", " pool_size=len(match_card.get_population('pool')),\n", " target_size=len(match_card.get_population('target')),\n", " time_limit=600\n", @@ -706,25 +751,24 @@ "fig = plot_categoric_features(match_dist2)" ] }, + { + "cell_type": "markdown", + "id": "e82f82fb-eab8-4966-99fd-bd4d5d87e7cc", + "metadata": {}, + "source": [ + "Note that the solution no longer satisfies the max_mismatch constraint." + ] + }, { "cell_type": "code", "execution_count": 11, "id": "014a2b7e-d2a5-46be-bd25-299ff3bf52df", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pybalance.utils.preprocess:Discretized age with bins [18.02, 27.51, 37.01, 46.51, 56.0, 65.5, 75.0].\n", - "INFO:pybalance.utils.preprocess:Discretized height with bins [125.0, 136.67, 148.33, 159.99, 171.66, 183.32, 194.99].\n", - "INFO:pybalance.utils.preprocess:Discretized weight with bins [50.01, 61.67, 73.34, 85.0, 96.67, 108.33, 120.0].\n" - ] - }, { "data": { "text/plain": [ - "tensor(0.0500)" + "tensor(0.1696)" ] }, "execution_count": 11, @@ -733,8 +777,7 @@ } ], "source": [ - "beta = GammaBalance(m, standardize_difference=False)\n", - "beta.per_feature_loss(match_dist.get_population('pool')).max()" + "gamma.per_feature_loss(match_dist2.get_population('pool')).max()" ] } ], diff --git a/.doctrees/nbsphinx/demos/lp_matcher.ipynb b/.doctrees/nbsphinx/demos/lp_matcher.ipynb index 81937a7..0f97e8d 100644 --- a/.doctrees/nbsphinx/demos/lp_matcher.ipynb +++ b/.doctrees/nbsphinx/demos/lp_matcher.ipynb @@ -7,7 +7,21 @@ "source": [ "# Constraint Satisfaction Matcher\n", "\n", - "The ConstraintSatisfactionMatcher can be used to optimize any linear function of the baseline covariates. In this demo notebook, we show how to call the matcher in the PyBalance library." + "The ConstraintSatisfactionMatcher can be used to optimize any linear function of the baseline covariates. We support constraints on the size of the subset populations and the allowed mismatch.\n", + "\n", + "Here, we demonstrate the optimization of balance subject to size constraints only. Namely, we solve:\n", + "\n", + "\\begin{equation}\n", + "\\begin{aligned}\n", + "& \\underset{\\hat{P}}{\\text{minimize}}\n", + "& & \\sum_k |\\mu_{\\hat{P},k} - \\mu_{T,k}| \\\\\n", + "& \\text{subject to}\n", + "& & |\\hat{P}| = P^* \\\\\n", + "& & & |\\hat{T}| = T^* \\\\\n", + "\\end{aligned}\n", + "\\end{equation}\n", + "\n", + "where $P$ and $T$ refer to two populations we are trying to match, $\\hat{P}$ and $\\hat{T}$ are the subsets of $P$ and $T$ we are seeking, $P^*$ and $T^*$ are fixed integers, and $k$ indexes the covariates of $P$ and $T$." ] }, { @@ -269,7 +283,7 @@ "" ], "text/plain": [ - "" + "" ] }, "execution_count": 3, @@ -497,21 +511,21 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 22, time = 0.55 m\n", + "INFO [matcher.py:97] Solution 22, time = 0.56 m\n", "INFO [matcher.py:101] Objective:\t22084000.0\n", "INFO [matcher.py:120] Balance (beta):\t0.0122\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 23, time = 3.16 m\n", + "INFO [matcher.py:97] Solution 23, time = 3.14 m\n", "INFO [matcher.py:101] Objective:\t22083000.0\n", "INFO [matcher.py:120] Balance (beta):\t0.0101\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 24, time = 5.78 m\n", + "INFO [matcher.py:97] Solution 24, time = 5.71 m\n", "INFO [matcher.py:101] Objective:\t22082000.0\n", "INFO [matcher.py:120] Balance (beta):\t0.0102\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -735,7 +749,7 @@ "" ], "text/plain": [ - "" + "" ] }, "execution_count": 5, @@ -975,7 +989,7 @@ "" ], "text/plain": [ - "" + "" ] }, "execution_count": 6, @@ -1133,7 +1147,7 @@ "INFO [preprocess.py:442] Added cross term binary_2 * binary_3 to matching features.\n", "INFO [preprocess.py:442] Added cross term binary_2 * height to matching features.\n", "INFO [preprocess.py:442] Added cross term binary_0 * binary_2 to matching features.\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 1/50, 0.000 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 1/50, 0.001 min) ...\n", "INFO [matcher.py:136] Best propensity score match found:\n", "INFO [matcher.py:137] \tModel: SGDClassifier\n", "INFO [matcher.py:139] \t* alpha: 0.1045355473186929\n", @@ -1183,48 +1197,48 @@ "INFO [matcher.py:180] Training model LogisticRegression (iter 6/50, 0.024 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 7/50, 0.044 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 7/50, 0.046 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 8/50, 0.065 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 9/50, 0.066 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 8/50, 0.067 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 9/50, 0.068 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 10/50, 0.083 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 11/50, 0.102 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 12/50, 0.103 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 13/50, 0.115 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 10/50, 0.085 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 11/50, 0.104 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 12/50, 0.105 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 13/50, 0.118 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 14/50, 0.137 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 15/50, 0.138 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 16/50, 0.139 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 14/50, 0.139 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 15/50, 0.140 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 16/50, 0.141 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 17/50, 0.161 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 18/50, 0.162 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 19/50, 0.163 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 20/50, 0.164 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 21/50, 0.165 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 17/50, 0.163 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 18/50, 0.164 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 19/50, 0.165 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 20/50, 0.166 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 21/50, 0.167 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 22/50, 0.186 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 23/50, 0.187 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 24/50, 0.188 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 25/50, 0.189 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 26/50, 0.190 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 27/50, 0.195 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 28/50, 0.196 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 22/50, 0.188 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 23/50, 0.189 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 24/50, 0.190 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 25/50, 0.191 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 26/50, 0.192 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 27/50, 0.196 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 28/50, 0.198 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 29/50, 0.216 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 30/50, 0.217 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 31/50, 0.232 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 29/50, 0.214 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 30/50, 0.215 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 31/50, 0.230 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 32/50, 0.254 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 33/50, 0.255 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 34/50, 0.258 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 32/50, 0.251 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 33/50, 0.252 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 34/50, 0.254 min) ...\n", "INFO [matcher.py:136] Best propensity score match found:\n", "INFO [matcher.py:137] \tModel: SGDClassifier\n", "INFO [matcher.py:139] \t* alpha: 0.02606111348517078\n", @@ -1235,24 +1249,24 @@ "INFO [matcher.py:139] \t* max_iter: 1500\n", "INFO [matcher.py:139] \t* penalty: l2\n", "INFO [matcher.py:140] \tScore (beta_x): 0.0603\n", - "INFO [matcher.py:141] \tSolution time: 0.259 min\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 35/50, 0.259 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 36/50, 0.260 min) ...\n", + "INFO [matcher.py:141] \tSolution time: 0.255 min\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 35/50, 0.255 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 36/50, 0.256 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 37/50, 0.282 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 38/50, 0.284 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 39/50, 0.285 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 37/50, 0.278 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 38/50, 0.280 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 39/50, 0.281 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 40/50, 0.306 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 41/50, 0.322 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 42/50, 0.331 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 43/50, 0.333 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 44/50, 0.334 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 45/50, 0.346 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 46/50, 0.352 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 47/50, 0.353 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 40/50, 0.302 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 41/50, 0.319 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 42/50, 0.328 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 43/50, 0.330 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 44/50, 0.331 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 45/50, 0.344 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 46/50, 0.351 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 47/50, 0.352 min) ...\n", "INFO [matcher.py:180] Training model SGDClassifier (iter 48/50, 0.354 min) ...\n", "INFO [matcher.py:180] Training model SGDClassifier (iter 49/50, 0.355 min) ...\n", "INFO [matcher.py:180] Training model SGDClassifier (iter 50/50, 0.356 min) ...\n", @@ -1266,7 +1280,7 @@ "INFO [matcher.py:139] \t* max_iter: 1500\n", "INFO [matcher.py:139] \t* penalty: l2\n", "INFO [matcher.py:140] \tScore (beta_x): 0.0603\n", - "INFO [matcher.py:141] \tSolution time: 0.259 min\n", + "INFO [matcher.py:141] \tSolution time: 0.255 min\n", "INFO [matcher.py:577] Hint achieves objective value = 147332.\n", "INFO [matcher.py:579] Applying hints ...\n", "INFO [matcher.py:611] Solving with 4 workers ...\n", @@ -1321,7 +1335,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 8, time = 0.12 m\n", + "INFO [matcher.py:97] Solution 8, time = 0.13 m\n", "INFO [matcher.py:101] Objective:\t145229000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0596\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1405,7 +1419,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 20, time = 0.27 m\n", + "INFO [matcher.py:97] Solution 20, time = 0.26 m\n", "INFO [matcher.py:101] Objective:\t143574000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0591\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1426,7 +1440,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 23, time = 0.30 m\n", + "INFO [matcher.py:97] Solution 23, time = 0.29 m\n", "INFO [matcher.py:101] Objective:\t142588000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0589\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1461,7 +1475,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 28, time = 0.36 m\n", + "INFO [matcher.py:97] Solution 28, time = 0.35 m\n", "INFO [matcher.py:101] Objective:\t141681000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0587\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1489,7 +1503,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 32, time = 0.40 m\n", + "INFO [matcher.py:97] Solution 32, time = 0.39 m\n", "INFO [matcher.py:101] Objective:\t141229000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0586\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1503,7 +1517,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 34, time = 0.44 m\n", + "INFO [matcher.py:97] Solution 34, time = 0.43 m\n", "INFO [matcher.py:101] Objective:\t140938000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0584\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1573,7 +1587,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 44, time = 0.68 m\n", + "INFO [matcher.py:97] Solution 44, time = 0.67 m\n", "INFO [matcher.py:101] Objective:\t139980000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0583\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1636,7 +1650,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 53, time = 0.77 m\n", + "INFO [matcher.py:97] Solution 53, time = 0.78 m\n", "INFO [matcher.py:101] Objective:\t138879000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0580\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1769,7 +1783,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 72, time = 1.11 m\n", + "INFO [matcher.py:97] Solution 72, time = 1.10 m\n", "INFO [matcher.py:101] Objective:\t136838000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0574\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1783,28 +1797,28 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 74, time = 1.25 m\n", + "INFO [matcher.py:97] Solution 74, time = 1.24 m\n", "INFO [matcher.py:101] Objective:\t136654000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0574\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 75, time = 1.25 m\n", + "INFO [matcher.py:97] Solution 75, time = 1.24 m\n", "INFO [matcher.py:101] Objective:\t136559000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0574\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 76, time = 1.26 m\n", + "INFO [matcher.py:97] Solution 76, time = 1.25 m\n", "INFO [matcher.py:101] Objective:\t136503000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0573\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 77, time = 1.26 m\n", + "INFO [matcher.py:97] Solution 77, time = 1.25 m\n", "INFO [matcher.py:101] Objective:\t136457000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0573\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1818,14 +1832,14 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 79, time = 1.37 m\n", + "INFO [matcher.py:97] Solution 79, time = 1.36 m\n", "INFO [matcher.py:101] Objective:\t136386000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0574\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 80, time = 1.38 m\n", + "INFO [matcher.py:97] Solution 80, time = 1.37 m\n", "INFO [matcher.py:101] Objective:\t136349000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0573\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1839,735 +1853,1169 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 82, time = 1.39 m\n", + "INFO [matcher.py:97] Solution 82, time = 1.38 m\n", "INFO [matcher.py:101] Objective:\t136286000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0573\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 83, time = 1.39 m\n", + "INFO [matcher.py:97] Solution 83, time = 1.38 m\n", "INFO [matcher.py:101] Objective:\t136020000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0573\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 84, time = 1.43 m\n", + "INFO [matcher.py:97] Solution 84, time = 1.41 m\n", "INFO [matcher.py:101] Objective:\t135535000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0570\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 85, time = 1.48 m\n", + "INFO [matcher.py:97] Solution 85, time = 1.47 m\n", "INFO [matcher.py:101] Objective:\t135513000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0570\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 86, time = 1.49 m\n", + "INFO [matcher.py:97] Solution 86, time = 1.48 m\n", "INFO [matcher.py:101] Objective:\t135473000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0570\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 87, time = 1.49 m\n", + "INFO [matcher.py:97] Solution 87, time = 1.48 m\n", "INFO [matcher.py:101] Objective:\t135452000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0570\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 88, time = 1.53 m\n", + "INFO [matcher.py:97] Solution 88, time = 1.51 m\n", "INFO [matcher.py:101] Objective:\t135375000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0570\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 89, time = 1.54 m\n", + "INFO [matcher.py:97] Solution 89, time = 1.53 m\n", "INFO [matcher.py:101] Objective:\t135312000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0569\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 90, time = 1.55 m\n", + "INFO [matcher.py:97] Solution 90, time = 1.54 m\n", "INFO [matcher.py:101] Objective:\t134988000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0568\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 91, time = 1.59 m\n", + "INFO [matcher.py:97] Solution 91, time = 1.58 m\n", "INFO [matcher.py:101] Objective:\t134977000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0568\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 92, time = 1.60 m\n", + "INFO [matcher.py:97] Solution 92, time = 1.59 m\n", "INFO [matcher.py:101] Objective:\t134937000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0568\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 93, time = 1.60 m\n", + "INFO [matcher.py:97] Solution 93, time = 1.59 m\n", "INFO [matcher.py:101] Objective:\t134931000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0568\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 94, time = 1.62 m\n", + "INFO [matcher.py:97] Solution 94, time = 1.61 m\n", "INFO [matcher.py:101] Objective:\t134909000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0567\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 95, time = 1.68 m\n", + "INFO [matcher.py:97] Solution 95, time = 1.66 m\n", "INFO [matcher.py:101] Objective:\t134887000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0566\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 96, time = 1.69 m\n", + "INFO [matcher.py:97] Solution 96, time = 1.67 m\n", "INFO [matcher.py:101] Objective:\t134614000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0566\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 97, time = 1.69 m\n", + "INFO [matcher.py:97] Solution 97, time = 1.68 m\n", "INFO [matcher.py:101] Objective:\t134579000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0566\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 98, time = 1.69 m\n", + "INFO [matcher.py:97] Solution 98, time = 1.68 m\n", "INFO [matcher.py:101] Objective:\t134522000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0566\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 99, time = 1.70 m\n", + "INFO [matcher.py:97] Solution 99, time = 1.68 m\n", "INFO [matcher.py:101] Objective:\t134400000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0565\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 100, time = 1.70 m\n", + "INFO [matcher.py:97] Solution 100, time = 1.69 m\n", "INFO [matcher.py:101] Objective:\t134234000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0565\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 101, time = 1.71 m\n", + "INFO [matcher.py:97] Solution 101, time = 1.69 m\n", "INFO [matcher.py:101] Objective:\t134107000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0564\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 102, time = 1.75 m\n", + "INFO [matcher.py:97] Solution 102, time = 1.73 m\n", "INFO [matcher.py:101] Objective:\t133877000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0564\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 103, time = 1.75 m\n", + "INFO [matcher.py:97] Solution 103, time = 1.74 m\n", "INFO [matcher.py:101] Objective:\t133872000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0564\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 104, time = 1.79 m\n", + "INFO [matcher.py:97] Solution 104, time = 1.77 m\n", "INFO [matcher.py:101] Objective:\t133834000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0562\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 105, time = 1.81 m\n", + "INFO [matcher.py:97] Solution 105, time = 1.79 m\n", "INFO [matcher.py:101] Objective:\t133706000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0561\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 106, time = 1.86 m\n", + "INFO [matcher.py:97] Solution 106, time = 1.84 m\n", "INFO [matcher.py:101] Objective:\t133469000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0560\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 107, time = 1.89 m\n", + "INFO [matcher.py:97] Solution 107, time = 1.87 m\n", "INFO [matcher.py:101] Objective:\t133214000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 108, time = 1.89 m\n", + "INFO [matcher.py:97] Solution 108, time = 1.87 m\n", "INFO [matcher.py:101] Objective:\t133090000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 109, time = 1.89 m\n", + "INFO [matcher.py:97] Solution 109, time = 1.87 m\n", "INFO [matcher.py:101] Objective:\t133063000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 110, time = 1.90 m\n", + "INFO [matcher.py:97] Solution 110, time = 1.88 m\n", "INFO [matcher.py:101] Objective:\t133033000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 111, time = 1.92 m\n", + "INFO [matcher.py:97] Solution 111, time = 1.89 m\n", "INFO [matcher.py:101] Objective:\t133028000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 112, time = 1.92 m\n", + "INFO [matcher.py:97] Solution 112, time = 1.90 m\n", "INFO [matcher.py:101] Objective:\t133008000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0558\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 113, time = 1.93 m\n", + "INFO [matcher.py:97] Solution 113, time = 1.91 m\n", "INFO [matcher.py:101] Objective:\t132983000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 114, time = 1.93 m\n", + "INFO [matcher.py:97] Solution 114, time = 1.91 m\n", "INFO [matcher.py:101] Objective:\t132978000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 115, time = 1.98 m\n", + "INFO [matcher.py:97] Solution 115, time = 1.95 m\n", "INFO [matcher.py:101] Objective:\t132841000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0558\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 116, time = 1.98 m\n", + "INFO [matcher.py:97] Solution 116, time = 1.96 m\n", "INFO [matcher.py:101] Objective:\t132785000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0558\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 117, time = 1.98 m\n", + "INFO [matcher.py:97] Solution 117, time = 1.96 m\n", "INFO [matcher.py:101] Objective:\t132779000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0558\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 118, time = 2.04 m\n", + "INFO [matcher.py:97] Solution 118, time = 2.02 m\n", "INFO [matcher.py:101] Objective:\t132600000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 119, time = 2.05 m\n", + "INFO [matcher.py:97] Solution 119, time = 2.02 m\n", "INFO [matcher.py:101] Objective:\t132480000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 120, time = 2.05 m\n", + "INFO [matcher.py:97] Solution 120, time = 2.03 m\n", "INFO [matcher.py:101] Objective:\t132453000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 121, time = 2.06 m\n", + "INFO [matcher.py:97] Solution 121, time = 2.04 m\n", "INFO [matcher.py:101] Objective:\t132264000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 122, time = 2.17 m\n", + "INFO [matcher.py:97] Solution 122, time = 2.16 m\n", "INFO [matcher.py:101] Objective:\t132136000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 123, time = 2.21 m\n", + "INFO [matcher.py:97] Solution 123, time = 2.19 m\n", "INFO [matcher.py:101] Objective:\t132122000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 124, time = 2.22 m\n", + "INFO [matcher.py:97] Solution 124, time = 2.21 m\n", "INFO [matcher.py:101] Objective:\t132117000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 125, time = 2.23 m\n", + "INFO [matcher.py:97] Solution 125, time = 2.21 m\n", "INFO [matcher.py:101] Objective:\t132079000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 126, time = 2.33 m\n", + "INFO [matcher.py:97] Solution 126, time = 2.31 m\n", "INFO [matcher.py:101] Objective:\t132025000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 127, time = 2.35 m\n", + "INFO [matcher.py:97] Solution 127, time = 2.33 m\n", "INFO [matcher.py:101] Objective:\t132007000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 128, time = 2.35 m\n", + "INFO [matcher.py:97] Solution 128, time = 2.33 m\n", "INFO [matcher.py:101] Objective:\t131985000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 129, time = 2.35 m\n", + "INFO [matcher.py:97] Solution 129, time = 2.33 m\n", "INFO [matcher.py:101] Objective:\t131979000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 130, time = 2.37 m\n", + "INFO [matcher.py:97] Solution 130, time = 2.35 m\n", "INFO [matcher.py:101] Objective:\t131957000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 131, time = 2.42 m\n", + "INFO [matcher.py:97] Solution 131, time = 2.39 m\n", "INFO [matcher.py:101] Objective:\t131715000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 132, time = 2.49 m\n", + "INFO [matcher.py:97] Solution 132, time = 2.47 m\n", "INFO [matcher.py:101] Objective:\t131695000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 133, time = 2.51 m\n", + "INFO [matcher.py:97] Solution 133, time = 2.49 m\n", "INFO [matcher.py:101] Objective:\t131689000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 134, time = 2.53 m\n", + "INFO [matcher.py:97] Solution 134, time = 2.51 m\n", "INFO [matcher.py:101] Objective:\t131687000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 135, time = 2.53 m\n", + "INFO [matcher.py:97] Solution 135, time = 2.51 m\n", "INFO [matcher.py:101] Objective:\t131585000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 136, time = 2.54 m\n", + "INFO [matcher.py:97] Solution 136, time = 2.52 m\n", "INFO [matcher.py:101] Objective:\t131572000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 137, time = 2.54 m\n", + "INFO [matcher.py:97] Solution 137, time = 2.52 m\n", "INFO [matcher.py:101] Objective:\t131526000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 138, time = 2.54 m\n", + "INFO [matcher.py:97] Solution 138, time = 2.52 m\n", "INFO [matcher.py:101] Objective:\t131488000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 139, time = 2.60 m\n", + "INFO [matcher.py:97] Solution 139, time = 2.58 m\n", "INFO [matcher.py:101] Objective:\t131421000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 140, time = 2.61 m\n", + "INFO [matcher.py:97] Solution 140, time = 2.58 m\n", "INFO [matcher.py:101] Objective:\t131418000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 141, time = 2.63 m\n", + "INFO [matcher.py:97] Solution 141, time = 2.60 m\n", "INFO [matcher.py:101] Objective:\t131344000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 142, time = 2.63 m\n", + "INFO [matcher.py:97] Solution 142, time = 2.61 m\n", "INFO [matcher.py:101] Objective:\t131338000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 143, time = 2.64 m\n", + "INFO [matcher.py:97] Solution 143, time = 2.61 m\n", "INFO [matcher.py:101] Objective:\t131174000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 144, time = 2.64 m\n", + "INFO [matcher.py:97] Solution 144, time = 2.62 m\n", "INFO [matcher.py:101] Objective:\t131116000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 145, time = 2.76 m\n", + "INFO [matcher.py:97] Solution 145, time = 2.73 m\n", "INFO [matcher.py:101] Objective:\t131101000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 146, time = 2.76 m\n", + "INFO [matcher.py:97] Solution 146, time = 2.73 m\n", "INFO [matcher.py:101] Objective:\t131083000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 147, time = 2.76 m\n", + "INFO [matcher.py:97] Solution 147, time = 2.74 m\n", "INFO [matcher.py:101] Objective:\t131069000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 148, time = 2.77 m\n", + "INFO [matcher.py:97] Solution 148, time = 2.74 m\n", "INFO [matcher.py:101] Objective:\t131061000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 149, time = 2.77 m\n", + "INFO [matcher.py:97] Solution 149, time = 2.74 m\n", "INFO [matcher.py:101] Objective:\t131055000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 150, time = 2.77 m\n", + "INFO [matcher.py:97] Solution 150, time = 2.74 m\n", "INFO [matcher.py:101] Objective:\t131053000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 151, time = 2.78 m\n", + "INFO [matcher.py:97] Solution 151, time = 2.75 m\n", "INFO [matcher.py:101] Objective:\t131017000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 152, time = 2.80 m\n", + "INFO [matcher.py:97] Solution 152, time = 2.77 m\n", "INFO [matcher.py:101] Objective:\t130827000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0553\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 153, time = 2.81 m\n", + "INFO [matcher.py:97] Solution 153, time = 2.77 m\n", "INFO [matcher.py:101] Objective:\t130822000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0553\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 154, time = 2.83 m\n", + "INFO [matcher.py:97] Solution 154, time = 2.79 m\n", "INFO [matcher.py:101] Objective:\t130586000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0553\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 155, time = 2.84 m\n", + "INFO [matcher.py:97] Solution 155, time = 2.81 m\n", "INFO [matcher.py:101] Objective:\t130560000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0552\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 156, time = 2.86 m\n", + "INFO [matcher.py:97] Solution 156, time = 2.82 m\n", "INFO [matcher.py:101] Objective:\t130554000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0553\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 157, time = 2.86 m\n", + "INFO [matcher.py:97] Solution 157, time = 2.83 m\n", "INFO [matcher.py:101] Objective:\t130462000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0553\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 158, time = 2.87 m\n", + "INFO [matcher.py:97] Solution 158, time = 2.84 m\n", "INFO [matcher.py:101] Objective:\t130390000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0552\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 159, time = 2.91 m\n", + "INFO [matcher.py:97] Solution 159, time = 2.87 m\n", "INFO [matcher.py:101] Objective:\t130376000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0552\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 160, time = 2.96 m\n", + "INFO [matcher.py:97] Solution 160, time = 2.93 m\n", "INFO [matcher.py:101] Objective:\t130053000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0552\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 161, time = 2.96 m\n", + "INFO [matcher.py:97] Solution 161, time = 2.93 m\n", "INFO [matcher.py:101] Objective:\t130016000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0551\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 162, time = 2.96 m\n", + "INFO [matcher.py:97] Solution 162, time = 2.93 m\n", "INFO [matcher.py:101] Objective:\t129852000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0551\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 163, time = 2.97 m\n", + "INFO [matcher.py:97] Solution 163, time = 2.94 m\n", "INFO [matcher.py:101] Objective:\t129796000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0551\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 164, time = 2.97 m\n", + "INFO [matcher.py:97] Solution 164, time = 2.94 m\n", "INFO [matcher.py:101] Objective:\t129752000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0551\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 165, time = 2.98 m\n", + "INFO [matcher.py:97] Solution 165, time = 2.94 m\n", "INFO [matcher.py:101] Objective:\t129638000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0550\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 166, time = 3.02 m\n", + "INFO [matcher.py:97] Solution 166, time = 2.98 m\n", "INFO [matcher.py:101] Objective:\t129415000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0550\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 167, time = 3.08 m\n", + "INFO [matcher.py:97] Solution 167, time = 3.04 m\n", "INFO [matcher.py:101] Objective:\t129413000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0549\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 168, time = 3.08 m\n", + "INFO [matcher.py:97] Solution 168, time = 3.05 m\n", "INFO [matcher.py:101] Objective:\t129338000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0549\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 169, time = 3.11 m\n", + "INFO [matcher.py:97] Solution 169, time = 3.07 m\n", "INFO [matcher.py:101] Objective:\t129216000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0548\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 170, time = 3.20 m\n", + "INFO [matcher.py:97] Solution 170, time = 3.11 m\n", "INFO [matcher.py:101] Objective:\t129055000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0539\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 171, time = 3.26 m\n", - "INFO [matcher.py:101] Objective:\t129023000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0548\n", + "INFO [matcher.py:97] Solution 171, time = 3.17 m\n", + "INFO [matcher.py:101] Objective:\t128661000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0546\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", "INFO [matcher.py:97] Solution 172, time = 3.27 m\n", - "INFO [matcher.py:101] Objective:\t128812000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0548\n", + "INFO [matcher.py:101] Objective:\t128657000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0545\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 173, time = 3.27 m\n", - "INFO [matcher.py:101] Objective:\t128809000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0547\n", + "INFO [matcher.py:97] Solution 173, time = 3.28 m\n", + "INFO [matcher.py:101] Objective:\t128319000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0544\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 174, time = 3.28 m\n", - "INFO [matcher.py:101] Objective:\t128793000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0547\n", + "INFO [matcher.py:97] Solution 174, time = 3.46 m\n", + "INFO [matcher.py:101] Objective:\t128266000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0543\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 175, time = 3.38 m\n", - "INFO [matcher.py:101] Objective:\t128688000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0547\n", + "INFO [matcher.py:97] Solution 175, time = 3.67 m\n", + "INFO [matcher.py:101] Objective:\t127794000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0539\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 176, time = 3.39 m\n", - "INFO [matcher.py:101] Objective:\t128255000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0546\n", + "INFO [matcher.py:97] Solution 176, time = 3.72 m\n", + "INFO [matcher.py:101] Objective:\t127703000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0542\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 177, time = 3.55 m\n", - "INFO [matcher.py:101] Objective:\t128243000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0553\n", + "INFO [matcher.py:97] Solution 177, time = 3.73 m\n", + "INFO [matcher.py:101] Objective:\t127624000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0542\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 178, time = 3.56 m\n", - "INFO [matcher.py:101] Objective:\t127543000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0550\n", + "INFO [matcher.py:97] Solution 178, time = 3.77 m\n", + "INFO [matcher.py:101] Objective:\t127604000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0542\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 179, time = 4.02 m\n", - "INFO [matcher.py:101] Objective:\t127017000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0547\n", + "INFO [matcher.py:97] Solution 179, time = 3.78 m\n", + "INFO [matcher.py:101] Objective:\t127576000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0542\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 180, time = 4.49 m\n", - "INFO [matcher.py:101] Objective:\t127008000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0546\n", + "INFO [matcher.py:97] Solution 180, time = 3.78 m\n", + "INFO [matcher.py:101] Objective:\t127565000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 181, time = 4.72 m\n", - "INFO [matcher.py:101] Objective:\t126858000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0545\n", + "INFO [matcher.py:97] Solution 181, time = 3.78 m\n", + "INFO [matcher.py:101] Objective:\t127533000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 182, time = 4.93 m\n", - "INFO [matcher.py:101] Objective:\t125797000.0\n", + "INFO [matcher.py:97] Solution 182, time = 3.78 m\n", + "INFO [matcher.py:101] Objective:\t127526000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 183, time = 3.79 m\n", + "INFO [matcher.py:101] Objective:\t127520000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 184, time = 3.79 m\n", + "INFO [matcher.py:101] Objective:\t127464000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 185, time = 3.79 m\n", + "INFO [matcher.py:101] Objective:\t127463000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 186, time = 3.82 m\n", + "INFO [matcher.py:101] Objective:\t127450000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 187, time = 3.82 m\n", + "INFO [matcher.py:101] Objective:\t127394000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 188, time = 3.83 m\n", + "INFO [matcher.py:101] Objective:\t127388000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 189, time = 3.83 m\n", + "INFO [matcher.py:101] Objective:\t127253000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0540\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 190, time = 3.84 m\n", + "INFO [matcher.py:101] Objective:\t127241000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0540\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 191, time = 3.84 m\n", + "INFO [matcher.py:101] Objective:\t127209000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0539\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 192, time = 3.84 m\n", + "INFO [matcher.py:101] Objective:\t127189000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0539\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 183, time = 5.12 m\n", - "INFO [matcher.py:101] Objective:\t125342000.0\n", + "INFO [matcher.py:97] Solution 193, time = 3.84 m\n", + "INFO [matcher.py:101] Objective:\t126998000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0540\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 194, time = 3.86 m\n", + "INFO [matcher.py:101] Objective:\t126837000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0539\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 195, time = 3.86 m\n", + "INFO [matcher.py:101] Objective:\t126768000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0539\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 184, time = 5.18 m\n", - "INFO [matcher.py:101] Objective:\t54272000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0309\n", + "INFO [matcher.py:97] Solution 196, time = 3.88 m\n", + "INFO [matcher.py:101] Objective:\t126686000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0538\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 197, time = 3.88 m\n", + "INFO [matcher.py:101] Objective:\t126679000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0538\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 198, time = 3.89 m\n", + "INFO [matcher.py:101] Objective:\t126673000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0538\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 199, time = 3.93 m\n", + "INFO [matcher.py:101] Objective:\t126450000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0536\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 200, time = 4.02 m\n", + "INFO [matcher.py:101] Objective:\t126359000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0536\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 201, time = 4.02 m\n", + "INFO [matcher.py:101] Objective:\t126346000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0537\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 202, time = 4.02 m\n", + "INFO [matcher.py:101] Objective:\t126318000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0536\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 203, time = 4.04 m\n", + "INFO [matcher.py:101] Objective:\t125810000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0535\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 204, time = 4.04 m\n", + "INFO [matcher.py:101] Objective:\t125799000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0535\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 205, time = 4.05 m\n", + "INFO [matcher.py:101] Objective:\t125767000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0535\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 206, time = 4.05 m\n", + "INFO [matcher.py:101] Objective:\t125760000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0534\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 207, time = 4.08 m\n", + "INFO [matcher.py:101] Objective:\t125507000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0534\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 208, time = 4.10 m\n", + "INFO [matcher.py:101] Objective:\t125496000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0533\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 209, time = 4.10 m\n", + "INFO [matcher.py:101] Objective:\t125464000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0533\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 210, time = 4.15 m\n", + "INFO [matcher.py:101] Objective:\t125016000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0532\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 211, time = 4.15 m\n", + "INFO [matcher.py:101] Objective:\t124988000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0532\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 212, time = 4.16 m\n", + "INFO [matcher.py:101] Objective:\t124956000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0532\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 213, time = 4.39 m\n", + "INFO [matcher.py:101] Objective:\t124605000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0529\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 214, time = 4.57 m\n", + "INFO [matcher.py:101] Objective:\t124569000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0530\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 215, time = 4.60 m\n", + "INFO [matcher.py:101] Objective:\t124537000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0532\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 216, time = 4.63 m\n", + "INFO [matcher.py:101] Objective:\t124416000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0532\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 217, time = 4.64 m\n", + "INFO [matcher.py:101] Objective:\t124370000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0531\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 218, time = 4.66 m\n", + "INFO [matcher.py:101] Objective:\t123956000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0530\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 219, time = 4.67 m\n", + "INFO [matcher.py:101] Objective:\t123910000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0530\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 220, time = 4.71 m\n", + "INFO [matcher.py:101] Objective:\t123851000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0530\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 221, time = 4.77 m\n", + "INFO [matcher.py:101] Objective:\t123830000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0530\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 222, time = 4.77 m\n", + "INFO [matcher.py:101] Objective:\t123810000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0530\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 223, time = 4.80 m\n", + "INFO [matcher.py:101] Objective:\t123045000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0527\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 224, time = 4.98 m\n", + "INFO [matcher.py:101] Objective:\t122999000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0527\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 225, time = 5.20 m\n", + "INFO [matcher.py:101] Objective:\t122997000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0528\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 226, time = 5.20 m\n", + "INFO [matcher.py:101] Objective:\t122958000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0528\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 227, time = 5.25 m\n", + "INFO [matcher.py:101] Objective:\t122833000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0528\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 228, time = 5.25 m\n", + "INFO [matcher.py:101] Objective:\t122802000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0528\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 229, time = 5.26 m\n", + "INFO [matcher.py:101] Objective:\t122708000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0527\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 230, time = 5.30 m\n", + "INFO [matcher.py:101] Objective:\t122646000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0527\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 231, time = 5.30 m\n", + "INFO [matcher.py:101] Objective:\t122600000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 232, time = 5.31 m\n", + "INFO [matcher.py:101] Objective:\t122464000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 233, time = 5.33 m\n", + "INFO [matcher.py:101] Objective:\t122463000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 234, time = 5.34 m\n", + "INFO [matcher.py:101] Objective:\t122453000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 235, time = 5.34 m\n", + "INFO [matcher.py:101] Objective:\t122421000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0525\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 236, time = 5.35 m\n", + "INFO [matcher.py:101] Objective:\t122333000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 237, time = 5.35 m\n", + "INFO [matcher.py:101] Objective:\t122319000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 238, time = 5.35 m\n", + "INFO [matcher.py:101] Objective:\t122280000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 239, time = 5.35 m\n", + "INFO [matcher.py:101] Objective:\t122118000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 240, time = 5.44 m\n", + "INFO [matcher.py:101] Objective:\t122093000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 241, time = 5.44 m\n", + "INFO [matcher.py:101] Objective:\t121931000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 242, time = 5.44 m\n", + "INFO [matcher.py:101] Objective:\t121912000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 243, time = 5.54 m\n", + "INFO [matcher.py:101] Objective:\t121870000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 244, time = 5.55 m\n", + "INFO [matcher.py:101] Objective:\t121820000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0525\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 185, time = 5.36 m\n", - "INFO [matcher.py:101] Objective:\t54271000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0309\n", + "INFO [matcher.py:97] Solution 245, time = 5.56 m\n", + "INFO [matcher.py:101] Objective:\t121793000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0525\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 246, time = 5.58 m\n", + "INFO [matcher.py:101] Objective:\t120770000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0521\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 247, time = 5.79 m\n", + "INFO [matcher.py:101] Objective:\t120522000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0521\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:618] Status = FEASIBLE\n", - "INFO [matcher.py:619] Number of solutions found: 185\n" + "INFO [matcher.py:619] Number of solutions found: 247\n" ] }, { @@ -2719,34 +3167,34 @@ " 9933\n", " \n", " \n", - " 9965\n", - " 41.035792\n", - " 130.021437\n", - " 80.495109\n", - " 0.0\n", - " 0\n", - " 1\n", + " 9947\n", + " 64.290077\n", + " 168.091011\n", + " 63.511962\n", + " 1.0\n", + " 2\n", + " 2\n", " pool\n", " 0\n", + " 0\n", + " 0\n", " 1\n", - " 1\n", - " 1\n", - " 9965\n", + " 9947\n", " \n", " \n", - " 9981\n", - " 39.006118\n", - " 133.419182\n", - " 71.135407\n", + " 9958\n", + " 51.722321\n", + " 170.350117\n", + " 80.695438\n", " 0.0\n", - " 1\n", + " 2\n", " 4\n", " pool\n", " 0\n", + " 1\n", " 0\n", - " 0\n", - " 0\n", - " 9981\n", + " 1\n", + " 9958\n", " \n", " \n", " 9982\n", @@ -2784,7 +3232,7 @@ "" ], "text/plain": [ - "" + "" ] }, "execution_count": 9, @@ -2804,7 +3252,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABBAAAAKkCAYAAAC57sypAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAADidklEQVR4nOzdd3gU5d7G8XsTUoFQBBIIgdA7hCIQQOUoUgXRo2KliIhKFI0CohAIHEUsCAiCqNiQA/aKFCmKEEHpvUOkJBBaqNmQzPsHb/aw7CZbTLJj+H6uay/YmWeeuWd2s8n+9plnLYZhGAIAAAAAAMiDn68DAAAAAAAA86OAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAADAFaKjo9W3b1/b/Q8//FAWi0V//vlnoey/ffv2at++faHsqzCMHj1aFotFaWlpvo5SaPr27asSJUoU+H4uXbqkoUOHKioqSn5+furZs2eB7xMAcG2jgAAAKFB79uzRwIEDVb16dQUHByssLExt27bVpEmTdOHChQLb79atWzV69Gjt37+/wPbhLTNmM2Om3MyePVsTJ070dQyfmzlzpl577TXddddd+uijj/TMM88UyH443wCAHMV8HQAAUHT9+OOPuvvuuxUUFKTevXurYcOGslqt+u233zRkyBBt2bJFM2bMKJB9b926VYmJiWrfvr2io6Pd3m7Hjh3y8yvY+npe2RYuXFig+/Ymk9nMnj1bmzdv1tNPP+3rKD61ZMkSRUZG6s033yzQ/XC+AQA5KCAAAArEvn37dO+996pq1apasmSJKlasaFs3aNAg7d69Wz/++KMPE/6PYRi6ePGiQkJCFBQU5NMsgYGBPt0//jmOHj2q0qVL+zqG186fP6/Q0FBfxwAAeIBLGAAABeLVV1/V2bNn9f7779sVD3LUrFlTgwcPtt2/dOmSxo4dqxo1aigoKEjR0dF64YUXlJGRYbdddHS0brvtNv32229q2bKlgoODVb16dX388ce2Nh9++KHuvvtuSdK//vUvWSwWWSwWLVu2zK6PBQsWqEWLFgoJCdE777xjW3flHAg5zp8/r4EDB+q6665TWFiYevfurZMnT9q1sVgsGj16tMO2V/bpKpuzORCOHj2q/v37Kzw8XMHBwWrSpIk++ugjuzb79++XxWLR66+/rhkzZtjO4/XXX68//vjDIdOVXGWSpLffflsNGjRQUFCQKlWqpEGDBunUqVN59nultLQ03XPPPQoLC9N1112nwYMH6+LFiw7tZs2apebNmyskJERly5bVvffeq7/++su2vn379vrxxx914MABW86cERNWq1UJCQlq3ry5SpUqpeLFi+uGG27Q0qVL3c4pSdu2bVNISIh69+5tt/y3336Tv7+/hg0b5lY/e/fuVadOnVS8eHFVqlRJY8aMkWEYki4XraKjo3X77bc7bHfx4kWVKlVKAwcOdNpvzmO9dOlSbdmyxeHxys7O1sSJE9WgQQMFBwcrPDxcAwcOdHi+fvvtt+rWrZsqVaqkoKAg1ahRQ2PHjlVWVpatTV7nO2d+kKsve1m2bJnD86d9+/Zq2LCh1qxZoxtvvFGhoaF64YUXJEkZGRkaNWqUatasqaCgIEVFRWno0KEOP/sAAN9jBAIAoEB8//33ql69utq0aeNW+0ceeUQfffSR7rrrLj377LNatWqVxo0bp23btunrr7+2a7t7927ddddd6t+/v/r06aOZM2eqb9++at68uRo0aKAbb7xRTz31lCZPnqwXXnhB9erVkyTbv9LlSxXuu+8+DRw4UAMGDFCdOnXyzBcXF6fSpUtr9OjR2rFjh6ZNm6YDBw7Y3iy5y51sV7pw4YLat2+v3bt3Ky4uTtWqVdPnn3+uvn376tSpU3ZFGOnycPMzZ85o4MCBslgsevXVV3XnnXdq7969CggI8CrT6NGjlZiYqA4dOujxxx+3Hf8ff/yhFStW5Nrvle655x5FR0dr3Lhx+v333zV58mSdPHnSrvDz0ksvaeTIkbrnnnv0yCOP6NixY3rrrbd04403at26dSpdurRefPFFnT59WgcPHrQN3c+ZsDA9PV3vvfee7rvvPg0YMEBnzpzR+++/r06dOmn16tWKiYlxmTPnuMeOHashQ4borrvuUo8ePXTu3Dn17dtXdevW1ZgxY1z2kZWVpc6dO6t169Z69dVXNX/+fI0aNUqXLl3SmDFjZLFY9OCDD+rVV1/ViRMnVLZsWdu233//vdLT0/Xggw867bt8+fL65JNP9NJLL+ns2bMaN26cLbckDRw4UB9++KH69eunp556Svv27dOUKVO0bt06u8frww8/VIkSJRQfH68SJUpoyZIlSkhIUHp6ul577TVJyvN8e+r48ePq0qWL7r33Xj344IMKDw9Xdna2evTood9++02PPvqo6tWrp02bNunNN9/Uzp079c0333i1LwBAATEAAMhnp0+fNiQZt99+u1vt169fb0gyHnnkEbvlzz33nCHJWLJkiW1Z1apVDUnGr7/+alt29OhRIygoyHj22Wdtyz7//HNDkrF06VKH/eX0MX/+fKfr+vTpY7v/wQcfGJKM5s2bG1ar1bb81VdfNSQZ3377rW2ZJGPUqFEu+8wr20033WTcdNNNtvsTJ040JBmzZs2yLbNarUZsbKxRokQJIz093TAMw9i3b58hybjuuuuMEydO2Np+++23hiTj+++/d9jXlXLLdPToUSMwMNDo2LGjkZWVZVs+ZcoUQ5Ixc+bMPPsdNWqUIcno0aOH3fInnnjCkGRs2LDBMAzD2L9/v+Hv72+89NJLdu02bdpkFCtWzG55t27djKpVqzrs69KlS0ZGRobdspMnTxrh4eHGww8/nGfOq2VlZRnt2rUzwsPDjbS0NGPQoEFGsWLFjD/++MPltn369DEkGU8++aRtWXZ2ttGtWzcjMDDQOHbsmGEYhrFjxw5DkjFt2jS77Xv06GFER0cb2dnZee7npptuMho0aGC3bPny5YYk49NPP7VbPn/+fIfl58+fd+hz4MCBRmhoqHHx4kXbstzOd87Pxr59++yWL1261OG5dNNNNxmSjOnTp9u1/eSTTww/Pz9j+fLldsunT59uSDJWrFjh9NgBAL7BJQwAgHyXnp4uSSpZsqRb7efNmydJio+Pt1v+7LPPSpLDXAn169fXDTfcYLtfvnx51alTR3v37nU7Y7Vq1dSpUye32z/66KN2n7Q//vjjKlasmC17QZk3b54iIiJ033332ZYFBAToqaee0tmzZ/XLL7/Yte/Vq5fKlClju59znjw5N1f6+eefZbVa9fTTT9tNLjlgwACFhYW5PY/FoEGD7O4/+eSTkv732H/11VfKzs7WPffco7S0NNstIiJCtWrVcusyBH9/f9scEtnZ2Tpx4oQuXbqkFi1aaO3atW7lzOHn56cPP/xQZ8+eVZcuXfT2229r+PDhatGihdt9xMXF2f5vsVgUFxcnq9Wqn3/+WZJUu3ZttWrVSp9++qmt3YkTJ/TTTz/pgQce8GhkS47PP/9cpUqV0q233mp3Hps3b64SJUrYnceQkBDb/8+cOaO0tDTdcMMNOn/+vLZv3+7xvl0JCgpSv379HPLWq1dPdevWtct78803S5LHl58AAAoWlzAAAPJdWFiYpMtvStxx4MAB+fn5qWbNmnbLIyIiVLp0aR04cMBueZUqVRz6KFOmjMM13nmpVq2a220lqVatWnb3S5QooYoVKxb41x4eOHBAtWrVcvhmiJzh6q7OTU4xwZNzc/X+JTlc4hEYGKjq1as77D83V5+/GjVqyM/Pz3b+du3aJcMwHNrlcOcyCUn66KOP9MYbb2j79u3KzMy0Lff08c7JOHr0aA0ZMkQNGzbUyJEj3d7Wz89P1atXt1tWu3ZtSbJ7zvTu3VtxcXE6cOCAqlatqs8//1yZmZl66KGHPM4rXT6Pp0+fVoUKFZyuP3r0qO3/W7Zs0YgRI7RkyRJb0S/H6dOnvdp/XiIjIx0mCd21a5e2bdum8uXLu8wLAPA9CggAgHwXFhamSpUqafPmzR5t5+4nrv7+/k6XG/8/QZ07rvz0taBdOSldQcuPc1MYrn6ss7OzZbFY9NNPPzk9Bneuu581a5b69u2rnj17asiQIapQoYL8/f01btw47dmzx6ucOV+refjwYR0/flwRERFe9ZObe++9V88884w+/fRTvfDCC5o1a5ZatGjhck6O3GRnZ6tChQp2oxqulPNG/dSpU7rpppsUFhamMWPGqEaNGgoODtbatWs1bNgwZWdnu9xXbj+vuT3fnf3MZWdnq1GjRpowYYLTbaKiolzmAAAUHgoIAIACcdttt2nGjBlKSkpSbGxsnm2rVq2q7Oxs7dq1y24ywdTUVJ06dUpVq1b1eP/eDP/Oy65du/Svf/3Ldv/s2bM6cuSIunbtaltWpkwZh28msFqtOnLkiNfZqlatqo0bNyo7O9tuFELOEHNvzo0zuWXK6X/Hjh12n6hbrVbt27dPHTp0cKv/Xbt22Y0C2L17t7Kzs20z+teoUUOGYahatWq2T+o9zfrFF1+oevXq+uqrr+zajBo1yq2MV5s+fboWLVqkl156SePGjdPAgQP17bffurVtdna29u7da3csO3fulCTbMUtS2bJl1a1bN3366ad64IEHtGLFCk2cONGrvNLl8/jzzz+rbdu2eRbJli1bpuPHj+urr77SjTfeaFu+b98+h7a5ne+c0S1XP+fdHZWSk3fDhg265ZZb8v1nFgCQ/5gDAQBQIIYOHarixYvrkUceUWpqqsP6PXv2aNKkSZJkexN+9RunnE8lu3Xr5vH+ixcvLsnxzY23ZsyYYTckftq0abp06ZK6dOliW1ajRg39+uuvDttd/YmsJ9m6du2qlJQUzZ0717bs0qVLeuutt1SiRAnddNNN3hyOg9wydejQQYGBgZo8ebLdKIb3339fp0+fdvuxmTp1qt39t956S5Js5+/OO++Uv7+/EhMTHUZLGIah48eP22V1NsQ+Z+TClduvWrVKSUlJbmW80r59+zRkyBD9+9//1gsvvKDXX39d3333nd23RrgyZcoUu2OYMmWKAgICdMstt9i1e+ihh7R161YNGTJE/v7+uvfeez3Om+Oee+5RVlaWxo4d67Du0qVLtsfX2bmyWq16++23HbbL7XzXqFFDkuye81lZWZoxY4ZHeQ8dOqR3333XYd2FCxd07tw5t/sCABQ8RiAAAApEjRo1NHv2bPXq1Uv16tVT79691bBhQ1mtVq1cudL2VYSS1KRJE/Xp00czZsywDa1evXq1PvroI/Xs2dPuk393xcTEyN/fX+PHj9fp06cVFBSkm2++Oddrw12xWq265ZZbdM8992jHjh16++231a5dO/Xo0cPW5pFHHtFjjz2mf//737r11lu1YcMGLViwQOXKlfM626OPPqp33nlHffv21Zo1axQdHa0vvvjC9km1uxNVupJXpuHDhysxMVGdO3dWjx49bMd//fXX5/pVg1fbt2+fevTooc6dOyspKUmzZs3S/fffryZNmki6/Hz5z3/+o+HDh2v//v3q2bOnSpYsqX379unrr7/Wo48+queee06S1Lx5c82dO1fx8fG6/vrrVaJECXXv3l233XabvvrqK91xxx3q1q2b9u3bp+nTp6t+/fo6e/as2+fCMAw9/PDDCgkJ0bRp0yRd/mrEL7/8UoMHD1aHDh1UqVKlPPsIDg7W/Pnz1adPH7Vq1Uo//fSTfvzxR73wwgsO1/t369ZN1113nT7//HN16dLF6+eoJN10000aOHCgxo0bp/Xr16tjx44KCAjQrl279Pnnn2vSpEm666671KZNG5UpU0Z9+vTRU089JYvFok8++cTppS65ne8GDRqodevWGj58uO2rKOfMmaNLly65nfehhx7SZ599pscee0xLly5V27ZtlZWVpe3bt+uzzz7TggULPJq4EgBQwHzz5Q8AgGvFzp07jQEDBhjR0dFGYGCgUbJkSaNt27bGW2+9ZfdVcZmZmUZiYqJRrVo1IyAgwIiKijKGDx9u18YwLn8lYrdu3Rz2c/XXHxqGYbz77rtG9erVDX9/f7uvlcutj5x1zr7G8ZdffjEeffRRo0yZMkaJEiWMBx54wDh+/LjdtllZWcawYcOMcuXKGaGhoUanTp2M3bt3O/SZVzZnx5Gammr069fPKFeunBEYGGg0atTI+OCDD+za5HyN42uvveZwTMrl6yWvllsmw7j8tY1169Y1AgICjPDwcOPxxx83Tp486bLPnK9x3Lp1q3HXXXcZJUuWNMqUKWPExcUZFy5ccGj/5ZdfGu3atTOKFy9uFC9e3Khbt64xaNAgY8eOHbY2Z8+eNe6//36jdOnShiTbVwxmZ2cbL7/8slG1alUjKCjIaNq0qfHDDz8Yffr0cfo1hLmZNGmSIcn48ssv7ZYnJycbYWFhRteuXfPcvk+fPkbx4sWNPXv2GB07djRCQ0ON8PBwY9SoUXZfhXmlnK+1nD17tts5nX2NY44ZM2YYzZs3N0JCQoySJUsajRo1MoYOHWocPnzY1mbFihVG69atjZCQEKNSpUrG0KFDjQULFjg89rmdb8MwjD179hgdOnQwgoKCjPDwcOOFF14wFi1a5PRrHHPLarVajfHjxxsNGjQwgoKCjDJlyhjNmzc3EhMTjdOnT7t9PgAABc9iGCabVQkAAOAa88wzz+j9999XSkqKQkNDfR0HAACnmAMBAADAhy5evKhZs2bp3//+N8UDAICpMQcCAAC4Zpw4cUJWqzXX9f7+/g5zFBSUo0eP6ueff9YXX3yh48ePa/DgwYWyXwAAvEUBAQAAXDPuvPNO/fLLL7mur1q1qvbv318oWbZu3aoHHnhAFSpU0OTJkxUTE1Mo+wUAwFvMgQAAAK4Za9as0cmTJ3NdHxISorZt2xZiIgAA/jkoIAAAAAAAAJeYRBEAAAAAALh0zc2BkJ2drcOHD6tkyZKyWCy+jgMAAAAAgM8YhqEzZ86oUqVK8vPLe4zBNVdAOHz4sKKionwdAwAAAAAA0/jrr79UuXLlPNtccwWEkiVLSrp8csLCwnycxlHNmjW1e/duX8dwimyeM2suiWzeMms2s+aSyOYts2Yzay6JbN4yazaz5pLI5i2zZjNrLols3jJrNrPmSk9PV1RUlO29cl6uuQJCzmULYWFhpiwg+Pn5mTKXRDZvmDWXRDZvmTWbWXNJZPOWWbOZNZdENm+ZNZtZc0lk85ZZs5k1l0Q2b5k1m1lz5XDnEn8mUQQAAAAAAC5RQAAAAAAAAC5RQAAAAAAAAC5dc3MguCsrK0uZmZmFvt/KlSvr4sWLhb5fd5DNc2bNJZHNW/mRLSAgQP7+/vmUCAAAACgcFBCuYhiGUlJSdOrUKZ/s/+WXX9a+fft8sm9XyOY5s+aSyOat/MpWunRpRUREuDVZDQAAAGAGFBCuklM8qFChgkJDQwv9j/uMjAxVq1atUPfpLrJ5zqy5JLJ56+9mMwxD58+f19GjRyVJFStWzK9oAAAAQIGigHCFrKwsW/Hguuuu80kGi8Wi4OBgn+zbFbJ5zqy5JLJ5Kz+yhYSESJKOHj2qChUqcDkDAAAA/hGYRPEKOXMehIaG+jgJgKIu53XGF3OtAAAAAN6ggOAE1yQDKGi8zgAAAOCfhgICAAAAAABwiQICPBIdHa2JEyfm2cZqtapmzZpauXKlJGn//v2yWCxav359wQfE3zJ9+nR1797d1zEAAAAAmBCTKLqp+ZCPC29nszZozWu9C29/+Wz69OmqVq2a2rRpk6/9tm/fXjExMS4LGGZ38eJFPfvss5ozZ44yMjLUqVMnvf322woPD891G8MwNGrUKL377rs6deqU2rZtq2nTpqlWrVq2Nj169ND69et19OhRlSlTRh06dND48eNVqVIl234fe+wxrVmzRtu2bdMNN9ygpUuX2u3n4Ycf1tixY7V8+XLdcMMNBXMCAAAAAPwjMQIB+cowDE2ZMkX9+/f3dRTTeuaZZ/T999/r888/1y+//KLDhw/rzjvvzHObV199VZMnT9b06dO1atUqFS9eXJ06ddLFixdtbf71r3/ps88+044dO/Tll19qz549uuuuu2zrs7KyFBISoqeeekodOnRwup/AwEDdf//9mjx5cv4cLAAAAIAigwJCEdG+fXvFxcUpLi5OpUqVUrly5TRy5EgZhmFrc/LkSfXu3VtlypRRaGiounTpol27dtn18+WXX6pBgwYKCgpSdHS03njjDY9yrFmzRnv27FG3bt0c1m3fvl1t2rRRcHCwGjZsqF9++cVu/ebNm9WlSxeVKFFC4eHheuihh5SWliZJ6tu3r3755RdNmjRJFotFFotF+/fvV1ZWlvr376+uXbsqJCREderU0aRJk9zKevHiRTVo0ECPPvqobdmePXtUsmRJzZw506Pjdtfp06f1/vvva8KECbr55pvVvHlzffDBB1q5cqV+//13p9sYhqGJEydqxIgRuv3229W4cWN9/PHHOnz4sL755htbu2eeeUatW7dW1apV1aZNGz3//PP6/fffbbP8Fy9eXNOmTdOAAQMUERGRa8bu3bvru+++04ULF/L12AEAAAD8s1FAKEI++ugjFStWTKtXr9akSZM0YcIEvffee7b1ffv21Z9//qnvvvtOSUlJMgxDXbt2tb3BXLNmje655x7de++92rRpk0aPHq2RI0fqww8/dDvD8uXLVbt2bZUsWdJh3ZAhQ/Tss89q3bp1io2NVffu3XX8+HFJ0qlTp3TzzTeradOm+vPPPzV//nylpqbqnnvukSRNmjRJsbGxGjBggI4cOaIjR44oKipK2dnZqly5sl577TVt3bpVCQkJeuGFF/TZZ5+5zBocHKxPP/1UH330kb799ltlZWXpwQcf1K233qqHH3441+1yihy53Ro0aJDrtmvWrFFmZqbdCIC6deuqSpUqSkpKcrrNvn37lJKSYrdNqVKl1KpVq1y3OXHihD799FO1adNGAQEBrk6FnRYtWujSpUtatWqVR9sBAAAAKNqYA6EIiYqK0ptvvimLxaI6depo06ZNevPNNzVgwADt2rVL3333nVasWGGbm+DTTz9VVFSUvvnmG919992aMGGCbrnlFo0cOVKSVLt2bW3dulWvvfaa+vbt61aGAwcO2K65v1pcXJz+/e9/S5KmTZum+fPn6/3339fQoUM1ZcoUNW3aVC+//LKt/cyZMxUVFaWdO3eqdu3aCgwMVGhoqN2n5/7+/kpMTNSGDRtUrVo1VatWTUlJSfrss89sxYe8xMTE6D//+Y8eeeQR3XvvvTpw4IB++OGHPLd577338vx0Pq837CkpKQoMDFTp0qXtloeHhyslJSXXbXLauNpm2LBhmjJlis6fP6/WrVu7PBZnQkNDVapUKR04cMDjbQEAAAAUXYxAKEJat25t993ysbGx2rVrl7KysrRt2zYVK1ZMrVq1sq2/7rrrVKdOHW3btk2StG3bNrVt29auz7Zt29r6cMeFCxcUHBzsdF1sbKzt/8WKFVOLFi1s+96wYYOWLl1q90l+3bp1JV2+rCAvU6dO1X333afy5curRIkSmjFjhpKTk93KK0nPPvusateurSlTpmjmzJm67rrr8mwfGRmpmjVr5nqrWrWq2/vOb0OGDNG6deu0cOFC+fv7q3fv3naXsbgrJCRE58+fL4CEAAAAAP6pKCAgX5UrV04nT570eLuzZ8+qe/fuWr9+vd1t165duvHGG3Pdbs6cOXruuefUs2dPLVy4UOvXr1e/fv1ktVrd3vfRo0e1c+dO+fv7O8wJ4czfuYQhIiJCVqtVp06dsluempqa67wEOctTU1NdblOuXDnVrl1bt956q+bMmaN58+blOrdCXk6cOKHy5ct7vB0AAACAootLGIqQq69Z//3331WrVi35+/urXr16tuvacy5hOH78uHbs2KH69etLkurVq6cVK1bY9bFixQrVrl1b/v7+bmVo2rSppk2bJsMw7EZD5OTJKQZcunRJa9asUVxcnCSpWbNm+vLLLxUdHa1ixZw/LQMDAx1GQuRcktGrVy81adJEkusRC1d7+OGH1ahRI/Xv318DBgxQhw4dVK9evVzb/51LGJo3b66AgAAtXrzYdjnHjh07lJycbDdC40rVqlVTRESEFi9erJiYGElSenq6Vq1apccffzzXfWVnZ0uSMjIycm3jzJ49e3Tx4kU1bdrUo+0AAAAAFG0UEIqQ5ORkxcfHa+DAgVq7dq3eeust27co1KpVS7fffrsGDBigd955RyVLltTzzz+vyMhI3X777ZIuD+W//vrrNXbsWPXq1UtJSUmaMmWK3n77bbcz/Otf/9LZs2e1ZcsWNWzY0G7d1KlTVatWLdWrV09vvvmmTp48aZuscNCgQXr33Xd13333aejQoSpbtqx2796tOXPm6L333pO/v7+io6O1atUq7d+/XyVKlFDZsmVVq1Ytffzxx1q5cqVCQkL0ySef6I8//lC1atXcyjt16lQlJSVp48aNioqK0o8//qgHHnhAv//+uwIDA51uExkZ6fb5uFqpUqXUv39/xcfHq2zZsgoLC9OTTz6p2NhYtW7d2taubt26GjdunO644w5ZLBY9/fTT+s9//qNatWqpWrVqGjlypCpVqqSePXtKulw8+uOPP9SuXTuVKVNGe/bs0ciRI1WjRg27wsTWrVtltVp14sQJnT17VuvXr5ckW2FCujwRZvXq1VWjRg2vjxMAACC/JI9p5Fa7KgmbCjgJAAoIblrzWu9C2c+GDRtsn6R7qnfv3rpw4YJatmwpf39/DR482O4rCj/44AMNHjxYt912m6xWq2688UbNmzfP9ol5s2bN9NlnnykhIUFjx45VxYoVNWbMGLcnUJQuz6twxx136NNPP9W4cePs1r3yyit65ZVXtH79etWsWVPfffedypUrJ0mqVKmSVqxYoWHDhqljx47KyMhQ1apV1blzZ/n5Xb7S5rnnnlOfPn1Uv359XbhwQfv27dPAgQO1bt06DR06VMWKFdN9992nJ554Qj/99JPLrNu3b9eQIUP0/vvvKyoqSpL09ttvq3Hjxho5cqTGjx/v9nF74s0335Sfn5/+/e9/KyMjQ506dXIo0uzYsUOnT5+23R86dKjOnTunRx99VKdOnVK7du00f/5823wToaGh+uqrrzRq1CidO3dOFStWVOfOnTVixAgFBQXZ+unatavd5Ig5owyunCfhv//9rwYMGFAgxw4AAADgn8tieDPD2j9Yenq6SpUqpdOnTyssLMxu3cWLF7Vv3z5Vq1Yt14kAC5q3BYT27dsrJiZGEydOzP9Q/8/dbBs3btStt96qPXv2qESJEgWW50p/p/BSkMyaS3KebcuWLbr55pu1c+dOlSpVykfJ/nnnzRv5/XoTERGR6zd5+BrZvGPWbGbNJZHNW2bNZtZcEtm85W22gh6BUBTPWWEgm+fMmiuv98hXYxJF5LvGjRtr/Pjx2rdvn6+jwENHjhzRxx9/7NPiAQAAAABz4hIGFAhPLnsoSHmNgPjpp590ww03FGIa8+vQoYOvIwAAAAAwKQoIRcSyZct8HcGUciYJdObvTIYIAAAAANcaCggo0mrWrOnrCAAAAABQJDAHAgAAAAAAcIkCAgAAAAAAcIkCAgAAAAAAcIkCAgAAAAAAcIkCAgAAAAAAcMnnBYSpU6cqOjpawcHBatWqlVavXp1n+4kTJ6pOnToKCQlRVFSUnnnmGV28eLGQ0iI6OloTJ07Ms43ValXNmjW1cuXKwgllIhaLRd98802u67du3arKlSvr3LlzbvV34403avbs2W73D3OYPn26unfv7usYAAAAQL7y6dc4zp07V/Hx8Zo+fbpatWqliRMnqlOnTtqxY4cqVKjg0H727Nl6/vnnNXPmTLVp00Y7d+5U3759ZbFYNGHChALNmjymUYH2n6OMpORvpSoJmwplfwVh+vTpqlatmtq0aePrKF7bv3+/qlWrpnXr1ikmJibf+q1fv75at26tCRMmaOTIkXm2/e6775Samqp777033/YvSX379tWpU6eUmJiYr/0WNsMwNGrUKL377rs6deqU2rZtq2nTpqlWrVq5bjNu3Dh99dVX2r59u0JCQtSmTRuNHz9ederUsbUZOHCgfv75Zx0+fFglSpSwtalbt64kaceOHXrllVf022+/KS0tTdHR0Xrsscc0ePBgWx8PP/ywxo4dq+XLl+uGG24ouJMAAAAAFCKfjkCYMGGCBgwYoH79+ql+/fqaPn26QkNDNXPmTKftV65cqbZt2+r+++9XdHS0OnbsqPvuu8/lqAUUHsMwNGXKFPXv3/9v93Pp0qV8SmUu/fr107Rp01we3+TJk9WvXz/5+fl8oJApvfrqq5o8ebKmT5+uVatWqXjx4urUqVOeI5J++eUXDRo0SL///rsWLVqkzMxMdezY0W5ESPPmzfXBBx9o27ZtWrBggQzDUMeOHZWVlSVJ2rZtmypUqKBZs2Zpy5YtevHFFzV8+HBNmTLF1kdgYKDuv/9+TZ48ueBOAAAAAFDIfDYCwWq1as2aNRo+fLhtmZ+fnzp06KCkpCSn27Rp00azZs3S6tWr1bJlS+3du1fz5s3TQw89lOt+MjIylJGRYbufnp4uScrMzFRmZqZd28zMTBmGoezsbGVnZ/+dw/vbPN3/zTffrAYNGkiSZs2apYCAAD322GNKTEyUxWKRJJ08eVJPP/20fvjhB2VkZOjGG2/UpEmT7D6x/fLLLzV69Gjt3r1bFStWVFxcnOLj4yVdflOf829u+f7880/t2bNHXbp0sbXZv3+/atSooU8//VRTpkzR2rVrVbNmTb311lu66aabJEnLli3TLbfcoh9++EEJCQnatGmT5s+frxtvvFGvvvqq3n33XaWkpKh27dp68cUXddddd9ltN3XqVPXt21fbt29XbGysZs+erTVr1ui5557ToUOH1K1bN7377rsKDQ2VJM2fP18vv/yyNm/eLH9/f7Vu3VoTJ05UjRo1JEnVqlWTJDVt2lSSdNNNN2nJkiWSpJkzZ+rNN9/U7t27VbZsWd1555166623bOfg6NGj6tmzpxYuXKhy5cpp8uTJ6tGjh239LbfcohMnTmjp0qW65ZZbnJ7HY8eOacmSJXrzzTcdzvWhQ4fUuXNn/fLLL6pYsaJeeeUV2/mQpL/++kvPPfecFi1aJD8/P7Vr104TJ05UdHS0EhMT9dFHH0mSvv32W0nS4sWL1b59ez3//PP65ptvdPDgQUVEROj+++/XyJEjFRAQ4DRjDsMw1KlTJ/n5+emnn36SxWLRiRMnFBMTo379+nk10iGv51jO+okTJ+rFF1+0XSrw4YcfqmLFivrqq69yHbUxb948u/szZ85URESE/vjjD914442SpEceecS2vkqVKhozZoyaNm2qvXv3qkaNGrr99tvVuHFjW5vo6GitXLlSX331lZ544gnb8m7duqlTp046d+6cQkJCHLJkZ2fLMAxlZmbK39/fjbOSt5y+zIhs3jFrNrPmksjmLbNmM2suiWze8jZbll+QW+28Pe6ieM4KA9k8Z9ZcnmTyWQEhLS1NWVlZCg8Pt1seHh6u7du3O93m/vvvV1pamtq1a2f7hPqxxx7TCy+8kOt+xo0b5/QNzMKFC21vJnMUK1ZMEREROnv2rKxWqxdHlX9yCh3uunTpkj7++GM9+OCD+vnnn7Vu3To988wzKl++vPr06SNJeuihh7R37159+umnKlmypBITE9W1a1f9/vvvCggI0Pr163Xvvffq+eef1x133KHVq1frueeeU2hoqO6//37bm7qLFy/mmu/nn39WzZo1ZRiGrc3Zs2clSUOGDNG4ceNUp04dvf3227r99tu1fv16lS1bVufPn5ckDRs2TGPHjlV0dLRKly6t0aNH6/PPP9frr7+uGjVqaOXKlerdu7eKFy+utm3b2rabPn26Xn31VYWGhqpfv3666667FBQUpHfeeUdnz57VQw89pNdff11PP/20pMvPv4EDB6pBgwY6d+6cXn75ZfXs2VPLly+Xn5+fFi9erFtuuUXffPON6tatq8DAQKWnp+v999/XiBEjNGrUKHXo0EHp6elatWqV3flITExUYmKiEhIS9Prrr+uhhx7Sxo0bVaZMGVubRo0aafHixbr++uudnsdFixYpNDRUkZGRDuc6ISFBo0aN0n/+8x/NnTtX999/v6pWrao6deooMzNTnTp10vXXX68ff/xRxYoV0+uvv67OnTvrt99+04ABA7Rp0yalp6dr2LBhqlKlisqUKaP09HQFBgbqrbfeUsWKFbVlyxY9/fTTCggIsBuan5vJkyerbdu2eu211/TYY49pwIABioiI0ODBg3N9rjzzzDP6/PPPna7Lzs6Wn5+fDh486HT9/v37lZKSotatW9v6t1gsat68uX799Vd17drVZWbpcjFGku3xvdq5c+c0Y8YMVa1aVaVKlVJ6errdcztHWlqaSpYsabe8du3aunTpkpYuXap27do59G21WnXhwgX9+uuv+TLaxmq1OhRIzIJs3jFrNrPmksjmLbNmM2suiWze8jpbo7wv+8yx0cvjLpLnrBCQzXNmzZXznsodPp0DwVPLli3Tyy+/rLffflutWrXS7t27NXjwYI0dOzbX68mHDx9u+wRduvzGPCoqSh07dlRYWJhd24sXL+qvv/5SiRIlFBwcbLfOs7fzf9/V2VwpVqyYoqKiNGXKFNsbqT179uidd97Rk08+qV27dumnn37S8uXLbXMT/Pe//1XVqlW1ZMkS3X333ZoxY4ZuvvlmjR07VpLUrFkz7du3T1OnTtVjjz0mi8UiPz8/BQcH55ovNTVVlStXtltfokQJSdKTTz6pBx98UJL07rvvasmSJfr88881ZMgQWzFn7Nixuv322yVdHj3y5ptvauHChYqNjZUkNW7cWGvWrNGsWbPUpUsX23aDBg1Sx44dJV3+BPmFF17Qrl27VL16dUnSXXfdpaSkJCUkJEiSLUeOjz76SOHh4Tp48KAaNmyo6OhoSVJUVJTdCI0JEyYoPj5eQ4cOtS1r3769XV/9+vXTww8/bDvm//73v9q2bZs6d+5sa1O5cmWlpKTkeh6PHTum8PBwlS5d2mHd3Xffrbi4OEmXH6Ply5frww8/1NSpUzVr1ixJlz+Nzxl58sknn6hs2bJau3atOnbsqJIlSyorK0vly5e3O7YxY8bY/t+wYUMdPHhQc+fOdTlXg3T5+Tp9+nTb/AqLFi3SmjVrVLZs2Vy3GTdunN0IpCtt375ddevWzfX85BSlqlevbtemUqVKOnHihFs/P9nZ2Ro5cqTatm2r1q1b262bNm2ahg0bpnPnzqlOnTpatGiRypUrJ+lyoeLK/leuXKmvv/5a33//vd3ysLAwlSpVSseOHXOa5+LFiwoJCdGNN97o8HrjjcDAQLcLJ4WNbN4xazaz5pLI5i2zZjNrLols3vI228HxsW61qzzM+ShmV4riOSsMZPOcWXN58uG1zwoI5cqVk7+/v1JTU+2Wp6amKiIiwuk2I0eO1EMPPWQbYtyoUSOdO3dOjz76qF588UWn14oHBQUpKMhx2FNAQIDD0OysrCzbm2RfX3fuzf5bt25tNxS6TZs2mjBhggzD0I4dO1SsWDHFxsba+i5fvrzq1KmjHTt2yM/PT9u3b9ftt99ut+927dpp0qRJMgzD9oY05xw5c/HiRQUHB9utz/l/mzZtbP8PDAxUixYttH37drvz3bJlS9v/9+7dq/Pnz6tTp052+7BarWratKnddrVr17b9PyIiQqGhoapZs6Ztm5xh6jltdu3apYSEBK1atUppaWm24fIHDx5U48aNbe2u3MfRo0d1+PBhdejQIc/Hp0mTJrb1oaGhCgsLU1pamt02oaGhunDhgkfnMceV51GSYmNjtX79evn5+WnTpk3avXu3SpUq5dDfvn375OfnJ4vFYrtd2c/cuXM1efJk7dmzR2fPntWlS5cUFhbm9nOxV69e+vbbbzV+/HhNmzbNbmJCZyIiInL9Wb9w4YJq166d67bOHh9JTo8rN4MGDdKWLVv022+/ObR/8MEH1bFjRx05ckSvv/667r33Xq1YsULBwcF2/W/evFl33HGHRo0aZVcgyhESEqKLFy86zZPzWDh7LfJGTl9mRDbvmDWbWXNJZPOWWbOZNZdENm95m80/O8N1I8nr4y6K56wwkM1zZs3lSSafFRACAwPVvHlzLV68WD179pR0+RPBxYsX2z5dvdr58+cd/hDPecOcc30+fKtcuXLatMn7b5AoXry47f85nzL/+OOPioyMtGt3dVGoWLH/PZWd/WBaLBa7a+q7d++uqlWr6t1331WlSpWUnZ2thg0b5nnpirPr2J1xtW9JOnHihG2+BWfKlSunkydPurW/K509e1bNmzfXp59+6rCufPnyuW6XlJSkBx54QImJierUqZNKlSqlOXPm6I033nB73+fPn9eaNWvk7++vXbt2uWz/2GOP2UZMXC3nEoac58DVcgoPqampqlixom15amqqW9+aERcXpx9++EG//vqrKleu7LC+VKlSKlWqlGrVqqXWrVurTJky+vrrr3XffffZ2mzdulW33HKLHn30UY0YMcLpfk6cOJHneQcAAAD+SXz6MXt8fLzeffddffTRR9q2bZsef/xxnTt3Tv369ZMk9e7d226Ic/fu3TVt2jTNmTNH+/bt06JFizRy5Eh17949XyYh+6dbtWqV3f3ff/9dtWrVkr+/v+rVq6dLly7ZtTl+/Lh27Nih+vXrS5Lq1aunFStW2PWxYsUK1a5d2+3z27RpU23fvt1pQef333+3/f/SpUtas2aN6tWrl2tf9evXV1BQkJKTk1WzZk27W1RUlFt5nMk57hEjRuiWW25RvXr1HN6sBwYGSpJt5n1JKlmypKKjo7V48WKv951j8+bNtgkanWnatKlSUlKcFhGuPI8593POY7NmzbRr1y5VqFDB4ZzljEoIDAy0Oy7p8jD8qlWr6sUXX1SLFi1Uq1YtHThwwKNjevbZZ20TKU6ePNk26WRuxowZo/Xr1zu9zZ07V+vXr89122rVqikiIsLusciZjyLnchdnDMNQXFycvv76ay1ZssQ2WWZeDMOQYRh2k7Fu2bJF//rXv9SnTx+99NJLTrfbs2ePLl68mOfjDAAAAPyT+HQOhF69eunYsWNKSEhQSkqKYmJiNH/+fNvEisnJyXYjDkaMGCGLxaIRI0bo0KFDKl++vLp3757rH/DXmuTkZMXHx2vgwIFau3at3nrrLdsnyLVq1dLtt9+uAQMG6J133lHJkiX1/PPPKzIy0jbnwLPPPqvrr79eY8eOVa9evZSUlKQpU6bo7bffdjvDv/71L509e1ZbtmxRw4YN7dZNnTpVtWrVUr169fTmm2/q5MmTtrkCnClZsqSee+45PfPMM8rOzla7du10+vRprVixQmFhYbbJIT1VpkwZXXfddZoxY4YqVqyo5ORkPf/883ZtKlSooJCQEM2fP1+VK1dWcHCwSpUqpdGjR+uxxx5ThQoV1KVLF505c0YrVqzQk08+6fb+9+/fr0OHDqlDhw65tmnatKnKlSunFStW6LbbbrNb9/nnn6tFixZq166dPv30U61evVrvv/++JOmBBx7Qa6+9pttvv11jxoxR5cqVdeDAAX311VcaOnSoKleurOjoaC1YsED79+9XZGSk7ZP25ORkzZkzxzYB49dff+32Mf3444+aOXOmkpKS1KxZMw0ZMkR9+vRxmDzyShUqVFCFChWcrjt37pzdJShXs1gsevrpp/Wf//xHtWrVUrVq1TRy5EhVqlTJNqJJuvyNF3fccYdtVNOgQYM0e/ZsffvttypZsqRSUlIkXR5xEBISor1792ru3Lnq2LGjypcvr4MHD+qVV15RSEiI7Xq13bt36/HHH1enTp0UHx9v68Pf399utMHy5ctVvXr1PEeaAAAAAP8kPv+C+bi4OB04cEAZGRlatWqVWrVqZVu3bNkyffjhh7b7xYoV06hRo7R7925duHBBycnJmjp1qtOJ5q5FvXv31oULF9SyZUsNGjRIgwcP1qOPPmpb/8EHH6h58+a67bbbFBsbK8MwNG/ePNuQ+2bNmumzzz7TnDlz1LBhQyUkJGjMmDHq27ev2xmuu+463XHHHU6H0L/yyit65ZVX1KRJE/3222/67rvvbBPT5SZngsxx48apXr166ty5s3788Ue3PjnOjZ+fn+bMmaM1a9aoYcOGeuaZZ/Taa6/ZtSlWrJgmT56sd955R5UqVbIVWfr06aOJEyfq7bffVoMGDXTbbbe5NVz/Sv/973/VsWNHVa1aNdc2/v7+6tevn9PzmJiYqDlz5qhx48b6+OOP9d///tc2iiQ0NFS//vqrqlSpojvvvFP16tVT//79dfHiRdtEfgMGDFCdOnV0//33q3z58lqxYoV69OihZ555RnFxcYqJidHKlSvdmjxRujzhY//+/TV69Gg1a9bMljE8PFyPPfaYR+fGE0OHDtWTTz6pRx99VNdff73Onj2r+fPn201IuGfPHqWlpdnuT5s2TadPn1b79u1VsWJF223u3LmSpODgYC1fvlxdu3ZVzZo11atXL5UsWVIrV660FTsWLVqkY8eOadasWXZ9XP2NGv/97381YMCAAjt+AAAAoLBZjGts8oD09HSVKlVKp0+fdvotDPv27VO1atXyZVZ0b2zYsEFNmjTxeLv27dsrJiZGEydOzP9Q/8/dbBs3btStt96qPXv2qESJEtq/f7+qVaumdevWuXV9ekFmK2xX57JarapVq5Zmz56ttm3b5rltSkqKGjRooLVr1+ZZbMivbGbyT8+2ZcsW3Xzzzdq5c6fDhJY58vv1JiIiwjYawmzI5h2zZjNrLols3jJrNrPmksjmLW+zJY9p5Fa7KgnezcNVFM9ZYSCb58yaK6/3yFfz+QgEFD2NGzfW+PHjtW/fPl9HMZ3k5GS98MILLosH0uUXmPfff1/JycmFkAz56ciRI/r4449zLR4AAAAA/0Q+nQMBRZcnlz1cS3ImNHTXldfz+1KDBg1ynVTxnXfe0QMPPFDIicwtr/ktAAAAgH8qCghFxLJly3wdIVfR0dF8zeY/3Lx585SZmel0Xc6kpwAAAACKNgoIAFwqiDkYAAAAAPyzMAcCAAAAAABwiQICAAAAAABwiQICAAAAAABwiQICAAAAAABwiQICAAAAAABwiQICTGHHjh2KiIjQmTNnJEkffvihSpcu7dtQcEvr1q315Zdf+joGAAAAgALG1zi6qe1bbQtvZ79KK55c4dEm7du3V0xMjCZOnFgwmbzgSabhw4frySefVMmSJfM1g8Vi0ddff62ePXvma7+FLTk5WY8//riWLl2qEiVKqE+fPho3bpyKFcv9R/jEiRN68skn9f3338vPz0///ve/NWnSJJUoUcLWZuPGjRo0aJD++OMPlS9fXk8++aSGDh1q18/nn3+ukSNHav/+/apVq5bGjx+vrl272taPGDFCzzzzjO644w75+VGTBAAAAIoq/tqHHavVWuj7TE5O1g8//KC+ffsW+r7/CbKystStWzdZrVatXLlSH330kT788EMlJCTkud0DDzygLVu2aNGiRfrhhx/066+/6tFHH7WtP3v2rDp27KiqVatqzZo1eu211zR69GjNmDHD1mblypW677771L9/f61bt049e/ZUz549tXnzZlubLl266MyZM/rpp5/y/+ABAAAAmAYFhCKgb9+++uWXXzRp0iRZLBZZLBbt379fWVlZ6t+/v6pVq6aQkBDVqVNHkyZNcti2Z8+eeumll1SpUiXVqVNH0uU3jjExMQoODlaLFi30zTffKCYmRuvXr7dtu3nzZnXp0kUlSpRQeHi4HnroIaWlpeWZyZnPPvtMTZo0UWRkpMO6b775RrVq1VJwcLA6deqkv/76y279t99+q2bNmqlly5aqXr26EhMTdenSJUlSdHS0JOmOO+6QxWKx3d+zZ49uv/12hYeHq0SJErr++uv1888/u3Wut2/frtDQUM2ePdsuf0hIiLZu3epWH55auHChtm7dqlmzZikmJkZdunTR2LFjNXXq1FwLPtu2bdP8+fP13nvvqVWrVmrXrp3eeustzZkzR4cPH5YkzZs3T1arVTNnzlSDBg1077336qmnntKECRNs/UyaNEmdO3fWkCFDVK9ePY0dO1bNmjXTlClTbG38/f3VtWtXzZkzp0COHwAAAIA5UEAoAiZNmqTY2FgNGDBAR44c0ZEjRxQVFaXs7GxVrlxZn3/+ubZu3aqEhAS98MIL+uyzz+y2X7x4sXbs2GH7pDo9PV3du3dXo0aNtHbtWo0dO1bDhg2z2+bUqVO6+eab1bRpU/3555+aP3++UlNTdc899+SZyZnly5erRYsWDsvPnz+vl156SR9//LFWrFihU6dO6d5777Xbrnfv3ho8eLC++uorvfPOO/rwww/10ksvSZL++OMPSdIHH3ygI0eO2O6fPXtWXbt21eLFi7Vu3Tp17txZ3bt3V3JysstzXbduXb3++ut64oknlJycrIMHD+qxxx7T+PHjVb9+/Vy3K1GiRJ63xx57LNdtk5KS1KhRI4WHh9uWderUSenp6dqyZUuu25QuXdruvHbo0EF+fn5atWqVpMuXL9x4440KDAy063fHjh06efKkrZ8OHTrY9d2pUyclJSXZLWvZsqWWL1+e6zEAAAAA+OdjDoQioFSpUgoMDFRoaKgiIiJsy/39/ZWYmGi7X61aNSUlJemzzz6zvdGXpOLFi+u9996zvZGcPn26LBaL3n33XQUHB6t+/fo6dOiQBgwYYNtmypQpatq0qV5++WXbspkzZyoqKko7d+5U7dq1nWZy5sCBA04LCJmZmZoyZYpatWolSfroo49Ur149rV69Wi1btlRiYqKef/559enTRxs2bFCTJk00duxYDR06VKNGjVL58uUlSaVLl7bL0KRJEzVp0sR2f+zYsfr666/13XffKS4uLu+TLemJJ57QvHnz9OCDDyowMFDXX3+9nnzyyTy3uXLkhjNhYWG5rktJSbErHkiy3U9JScl1mwoVKtgtK1asmMqWLWvbJi0tTY0bN8613zJlyuS676v3W6lSJf3111/Kzs5mHgQAAACgiKKAUMRNnTpVM2fOVHJysi5cuCCr1aqYmBi7No0aNbL7FHrHjh1q3LixgoODbctatmxpt82GDRtsE/pdbc+ePapdu7bbGS9cuGC3rxzFihXT9ddfb7tft25dlS5dWtu2bVPLli21YcMGrVixQi+99JLtjWtWVpYuXryo8+fPKzQ01On+zp49q9GjR+vHH3/UkSNHdOnSJV24cMGtEQg5Zs6cqdq1a8vPz09btmyRxWLJs33NmjXd7vufKCQkRNnZ2crIyFBISIiv4wAAAAAoABQQirA5c+boueee0xtvvKHY2FiVLFlSr732mm0Ie47ixYt73PfZs2fVvXt3jR8/3mFdxYoVPeqrXLlytiHznmZITEzUnXfeqW3btqlevXq2dc4KEjmee+45LVq0SK+//rpq1qypkJAQ3XXXXR5NILlhwwadO3dOfn5+OnLkiMtjdlZoudKDDz6o6dOnO10XERGh1atX2y1LTU21rcttm6NHj9otu3Tpkk6cOGHbply5crZ+cus3IiLCaZur93vixAkVL16c4gEAAABQhFFAKCICAwOVlZVlt2zFihVq06aNnnjiCduyPXv2uOyrTp06mjVrljIyMhQUFCTpf/MJ5GjWrJm+/PJLRUdH5/pVgs4yOdO0aVOnExBeunRJf/75p230w44dO3Tq1ClboaBZs2basWOHatasqXPnzjn9lD8gIMDpeenbt6/uuOMOSZcLEblN8OjMiRMn1LdvX7344os6cuSIHnjgAa1duzbPN89/5xKG2NhYvfTSSzp69KjtsoRFixYpLCws13kXYmNjderUKa1Zs0bNmzeXJC1ZskTZ2dm2S0IaN26sadOmKTMzUwEBAbZ+69SpozJlytj6Wbx4sZ5++mlb34sWLVJsbKzd/jZv3qymTZvmeYwAAAAA/tm4WLmIiI6O1qpVq7R//36lpaUpOztbtWrV0p9//qkFCxZo586dGjlypEMhwJn7779f2dnZevTRR7Vt2zYtWLBAr7/+uiTZhuoPGjRIJ06c0H333ac//vhDe/bs0YIFC9SvXz/bG3ZnmZzJmZTv6jf6AQEBevLJJ7Vq1SqtWbNGffv2VevWrW0FhYSEBH388cdKTEzU7t27tW3bNs2ZM0cjRoywOy+LFy9WSkqKbZRDrVq19NVXX2n9+vXasGGD7Xjd9dhjjykqKkojRozQhAkTlJWVpeeeey7PbWrWrJnn7er5Cq7UsWNH1a9fXw899JA2bNigBQsWaMSIERo0aJCtwLN69WrVrVtXhw4dkiTVq1dPnTt31oABA7R69WqtWLFCcXFxuvfee1WpUiVJl79+MTAwUP3799eWLVs0d+5cTZo0SfHx8bZ9Dx48WPPnz9cbb7yh7du3a/To0frzzz8d5opYvny5Onbs6PY5BAAAAPDPQwGhiHjuuefk7++v+vXrq3z58kpOTtbAgQN15513qlevXmrVqpWOHz9uNxohN2FhYfr++++1fv16xcTE6MUXX1RCQoKk/10aUKlSJa1YsUJZWVnq2LGjGjVqpKefflqlS5e2TaLnLJMzXbp0UbFixRy+SjE0NFTDhg3T/fffr7Zt26pEiRKaO3eubX2nTp30ww8/aOHChXrwwQfVunVrvfnmm6pataqtzRtvvKFFixYpKirK9gn5hAkTVKZMGbVp00bdu3dXp06d1KxZM7fO88cff6x58+bpk08+UbFixVS8eHHNmjVL7777rn766Se3+vCUv7+/fvjhB/n7+ys2NlYPPvigevfurTFjxtjanD9/Xjt27FBmZqZt2aeffqq6devqlltuUdeuXdWuXTvNmDHDtr5kyZJauHCh9u3bp+bNm+vZZ59VQkKCHn30UVubNm3aaPbs2ZoxY4aaNGmiL774Qt98840aNmxoa3Po0CGtXLlS/fr1K5DjBwAAAGAOFsMwDF+HKEzp6ekqVaqUTp8+7TBs/OLFi9q3b5+qVauW5zX0BSnn2wTM5tNPP1Xfvn2Vnp5eINe5T506Vd99950WLFjg1fZmPW9mzSXlX7Zhw4bp5MmTdsWJv+taOG/5/XoTERGR67dy+BrZvGPWbGbNJZHNW2bNZtZcEtm85W225DGN3GpXJWGTx31LRfOcFQayec6sufJ6j3w15kCAUx9//LGqV6+uyMhIbdiwQcOGDVPHjh0LbJK8gQMH6tSpUzpz5oxKlixZIPtAwahQoYLdZQ8AAAAAiiYKCHAqJSVFCQkJSklJUcWKFXX33XerV69eBba/YsWK6cUXXyyw/t21fPlydenSJdf1Z8+eLcQ0/wzPPvusryMAAAAAKAQUEODU0KFDNXToULtlGzZs8FGawtOiRQuX35gAAAAAANciCgjAFUJCQpx+HSQAAAAAXOv4FgYAAAAAAOASBQQnsrOzfR0BQBHH6wwAAAD+abiE4QqBgYHy8/PT4cOHVb58eQUGBspisRRqBsMwdPHixULdp7vI5jmz5pLI5q2/m80wDFmtVh07dkx+fn4KDAzMx3QAAABAwaGAcAU/Pz9Vq1ZNR44c0eHDh32S4ejRowoKCvLJvl0hm+fMmksim7fyK1toaKiqVKkiPz8GggEAAOCfgQLCVQIDA1WlShVdunRJWVlZhb7/hx56SL/99luh79cdZPOcWXNJZPNWfmTz9/dXsWLFCn2EEwAAAPB3UEBwwmKxKCAgQAEBAYW+74MHDyo4OLjQ9+sOsnnOrLkksnnLzNkAAACAgsTYWQAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4JIpCghTp05VdHS0goOD1apVK61evTrXtu3bt5fFYnG4devWrRATAwAAAABwbfF5AWHu3LmKj4/XqFGjtHbtWjVp0kSdOnXS0aNHnbb/6quvdOTIEdtt8+bN8vf31913313IyQEAAAAAuHb4vIAwYcIEDRgwQP369VP9+vU1ffp0hYaGaubMmU7bly1bVhEREbbbokWLFBoaSgEBAAAAAIACVMyXO7darVqzZo2GDx9uW+bn56cOHTooKSnJrT7ef/993XvvvSpevLjT9RkZGcrIyLDdT09PlyRlZmYqMzPzb6QvGIZhmDKXRDZvmDWXRDZvmTWbWXNJZPOWWbOZNZdENm+ZNZtZc0lk85a32bL8gtxq5+1xF8VzVhjI5jmz5vIkk08LCGlpacrKylJ4eLjd8vDwcG3fvt3l9qtXr9bmzZv1/vvv59pm3LhxSkxMdFi+cOFChYaGeh66gFmtVs2bN8/XMZwim+fMmksim7fMms2suSSyecus2cyaSyKbt8yazay5JLJ5y+tsjUa61Wyjl8ddJM9ZISCb58ya6/z58263tRiGYRRgljwdPnxYkZGRWrlypWJjY23Lhw4dql9++UWrVq3Kc/uBAwcqKSlJGzduzLWNsxEIUVFRSktLU1hY2N8/iHxWuXJlHTx40NcxnCKb58yaSyKbt8yazay5JLJ5y6zZzJpLIpu3zJrNrLkksnnL22wHx8e6biSp8jD3RjA7bFcEz1lhIJvnzJorPT1d5cqV0+nTp12+R/bpCIRy5crJ399fqampdstTU1MVERGR57bnzp3TnDlzNGbMmDzbBQUFKSjIcdhTQECAAgICPA9dwCwWiylzSWTzhllzSWTzllmzmTWXRDZvmTWbWXNJZPOWWbOZNZdENm95m80/O8N1I8nr4y6K56wwkM1zZs3lSSafTqIYGBio5s2ba/HixbZl2dnZWrx4sd2IBGc+//xzZWRk6MEHHyzomAAAAAAAXPN8OgJBkuLj49WnTx+1aNFCLVu21MSJE3Xu3Dn169dPktS7d29FRkZq3Lhxdtu9//776tmzp6677jpfxAYAAAAA4Jri8wJCr169dOzYMSUkJCglJUUxMTGaP3++bWLF5ORk+fnZD5TYsWOHfvvtNy1cuNAXkQEAAAAAuOb4vIAgSXFxcYqLi3O6btmyZQ7L6tSpIx/O/QgAAAAAwDXHp3MgAAAAAACAfwYKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCWfFxCmTp2q6OhoBQcHq1WrVlq9enWe7U+dOqVBgwapYsWKCgoKUu3atTVv3rxCSgsAAAAAwLWpmC93PnfuXMXHx2v69Olq1aqVJk6cqE6dOmnHjh2qUKGCQ3ur1apbb71VFSpU0BdffKHIyEgdOHBApUuXLvzwAAAAAABcQ3xaQJgwYYIGDBigfv36SZKmT5+uH3/8UTNnztTzzz/v0H7mzJk6ceKEVq5cqYCAAElSdHR0YUYGAAAAAOCa5LMCgtVq1Zo1azR8+HDbMj8/P3Xo0EFJSUlOt/nuu+8UGxurQYMG6dtvv1X58uV1//33a9iwYfL393e6TUZGhjIyMmz309PTJUmZmZnKzMzMxyPKH4ZhmDKXRDZvmDWXRDZvmTWbWXNJZPOWWbOZNZdENm+ZNZtZc0lk85a32bL8gtxq5+1xF8VzVhjI5jmz5vIkk88KCGlpacrKylJ4eLjd8vDwcG3fvt3pNnv37tWSJUv0wAMPaN68edq9e7eeeOIJZWZmatSoUU63GTdunBITEx2WL1y4UKGhoX//QPKZ1Wo17ZwOZPOcWXNJZPOWWbOZNZdENm+ZNZtZc0lk85ZZs5k1l0Q2b3mdrdFIt5pt9PK4i+Q5KwRk85xZc50/f97tthbDMIwCzJKrw4cPKzIyUitXrlRsbKxt+dChQ/XLL79o1apVDtvUrl1bFy9e1L59+2wjDiZMmKDXXntNR44ccbofZyMQoqKilJaWprCwsHw+qr+vcuXKOnjwoK9jOEU2z5k1l0Q2b5k1m1lzSWTzllmzmTWXRDZvmTWbWXNJZPOWt9kOjo913UhS5WHORzG73K4InrPCQDbPmTVXenq6ypUrp9OnT7t8j+yzEQjlypWTv7+/UlNT7ZanpqYqIiLC6TYVK1ZUQECA3eUK9erVU0pKiqxWqwIDAx22CQoKUlCQ47CngIAA2zwKZmKxWEyZSyKbN8yaSyKbt8yazay5JLJ5y6zZzJpLIpu3zJrNrLkksnnL22z+2RmuG0leH3dRPGeFgWyeM2suTzL57GscAwMD1bx5cy1evNi2LDs7W4sXL7YbkXCltm3bavfu3crOzrYt27lzpypWrOi0eAAAAAAAAPKHzwoIkhQfH693331XH330kbZt26bHH39c586ds30rQ+/eve0mWXz88cd14sQJDR48WDt37tSPP/6ol19+WYMGDfLVIQAAAAAAcE3w6dc49urVS8eOHVNCQoJSUlIUExOj+fPn2yZWTE5Olp/f/2ocUVFRWrBggZ555hk1btxYkZGRGjx4sIYNG+arQwAAAAAA4Jrg0wKCJMXFxSkuLs7pumXLljksi42N1e+//17AqQAAAAAAwJV8egkDAAAAAAD4Z6CAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXDJFAWHq1KmKjo5WcHCwWrVqpdWrV+fa9sMPP5TFYrG7BQcHF2JaAAAAAACuPT4vIMydO1fx8fEaNWqU1q5dqyZNmqhTp046evRortuEhYXpyJEjttuBAwcKMTEAAAAAANcenxcQJkyYoAEDBqhfv36qX7++pk+frtDQUM2cOTPXbSwWiyIiImy38PDwQkwMAAAAAMC1p5gvd261WrVmzRoNHz7ctszPz08dOnRQUlJSrtudPXtWVatWVXZ2tpo1a6aXX35ZDRo0cNo2IyNDGRkZtvvp6emSpMzMTGVmZubTkeQfwzBMmUsimzfMmksim7fMms2suSSyecus2cyaSyKbt8yazay5JLJ5y9tsWX5BbrXz9riL4jkrDGTznFlzeZLJpwWEtLQ0ZWVlOYwgCA8P1/bt251uU6dOHc2cOVONGzfW6dOn9frrr6tNmzbasmWLKleu7NB+3LhxSkxMdFi+cOFChYaG5s+B5COr1ap58+b5OoZTZPOcWXNJZPOWWbOZNZdENm+ZNZtZc0lk85ZZs5k1l0Q2b3mdrdFIt5pt9PK4i+Q5KwRk85xZc50/f97tthbDMIwCzJKnw4cPKzIyUitXrlRsbKxt+dChQ/XLL79o1apVLvvIzMxUvXr1dN9992ns2LEO652NQIiKilJaWprCwsLy50DyUeXKlXXw4EFfx3CKbJ4zay6JbN4yazaz5pLI5i2zZjNrLols3jJrNrPmksjmLW+zHRwf67qRpMrDch/BnOd2RfCcFQayec6sudLT01WuXDmdPn3a5Xtkn45AKFeunPz9/ZWammq3PDU1VREREW71ERAQoKZNm2r37t1O1wcFBSkoyHHYU0BAgAICAjwPXcAsFospc0lk84ZZc0lk85ZZs5k1l0Q2b5k1m1lzSWTzllmzmTWXRDZveZvNPzvDdSPJ6+MuiuesMJDNc2bN5Ukmn06iGBgYqObNm2vx4sW2ZdnZ2Vq8eLHdiIS8ZGVladOmTapYsWJBxQQAAAAA4Jrn9QiEU6dOafXq1Tp69Kiys7Pt1vXu3dvtfuLj49WnTx+1aNFCLVu21MSJE3Xu3Dn169fP1ldkZKTGjRsnSRozZoxat26tmjVr6tSpU3rttdd04MABPfLII94eCgAAAAAAcMGrAsL333+vBx54QGfPnlVYWJgsFottncVi8aiA0KtXLx07dkwJCQlKSUlRTEyM5s+fb5tYMTk5WX5+/xsocfLkSQ0YMEApKSkqU6aMmjdvrpUrV6p+/freHAoAAAAAAHCDVwWEZ599Vg8//LBefvnlfPkmg7i4OMXFxTldt2zZMrv7b775pt58882/vU8AAAAAAOA+r+ZAOHTokJ566ilTfg0iAAAAAADIf14VEDp16qQ///wzv7MAAAAAAACTcvsShu+++872/27dumnIkCHaunWrGjVq5PC1Dz169Mi/hAAAAAAAwOfcLiD07NnTYdmYMWMcllksFmVlZf2tUAAAAAAAwFzcLiBc/VWNAAAAAADg2uHVHAgAAAAAAODa4lUB4amnntLkyZMdlk+ZMkVPP/30380EAAAAAABMxqsCwpdffqm2bds6LG/Tpo2++OKLvx0KAAAAAACYi1cFhOPHj6tUqVIOy8PCwpSWlva3QwEAAAAAAHNxexLFK9WsWVPz589XXFyc3fKffvpJ1atXz5dgAADAc8ljGrnVrkrCpgJOAgAAihqvCgjx8fGKi4vTsWPHdPPNN0uSFi9erDfeeEMTJ07Mz3wAAAAAAMAEvCogPPzww8rIyNBLL72ksWPHSpKio6M1bdo09e7dO18DAgAAAAAA3/OqgCBJjz/+uB5//HEdO3ZMISEhKlGiRH7mAgAAAAAAJuLVJIo333yzTp06JUkqX768rXiQnp5uu6QBAAAAAAAUHV4VEJYtWyar1eqw/OLFi1q+fPnfDgUAAAAAAMzFo0sYNm7caPv/1q1blZKSYruflZWl+fPnKzIyMv/SAQAAAAAAU/CogBATEyOLxSKLxeL0UoWQkBC99dZb+RYOAAAAAACYg0cFhH379skwDFWvXl2rV69W+fLlbesCAwNVoUIF+fv753tIAAAAAADgWx4VEKpWrSpJys7OLpAwAAAAAADAnLz+Gkfp8jwIycnJDhMq9ujR42+FAgAAAAAA5uJVAWHv3r264447tGnTJlksFhmGIUmyWCySLk+oCAAAAAAAig6vvsZx8ODBqlatmo4eParQ0FBt2bJFv/76q1q0aKFly5blc0QAAAAAAOBrXo1ASEpK0pIlS1SuXDn5+fnJz89P7dq107hx4/TUU09p3bp1+Z0TAAAAAAD4kFcjELKyslSyZElJUrly5XT48GFJlydZ3LFjR/6lAwAAAAAApuDVCISGDRtqw4YNqlatmlq1aqVXX31VgYGBmjFjhqpXr57fGQEAAAAAgI95VUAYMWKEzp07J0kaM2aMbrvtNt1www267rrrNHfu3HwNCAAAAAAAfM+rAkKnTp1s/69Zs6a2b9+uEydOqEyZMrZvYgAAAAAAAEWHVwUEZ8qWLZtfXQEAAEBS8phGbrWrkrCpgJMAAOBlAeHixYt66623tHTpUh09elTZ2dl269euXZsv4QAAAAAAgDl4VUDo37+/Fi5cqLvuukstW7bksgUAAAAAAIo4rwoIP/zwg+bNm6e2bdvmdx4AAAAAAGBCft5sFBkZqZIlS+Z3FgAAAAAAYFJeFRDeeOMNDRs2TAcOHMjvPAAAAAAAwIS8uoShRYsWunjxoqpXr67Q0FAFBATYrT9x4kS+hAMAAAAAAObgVQHhvvvu06FDh/Tyyy8rPDycSRQBAAAAACjivCogrFy5UklJSWrSpEl+5wEAAAAAACbk1RwIdevW1YULF/I7CwAAAAAAMCmvCgivvPKKnn32WS1btkzHjx9Xenq63Q0AAAAAABQtXl3C0LlzZ0nSLbfcYrfcMAxZLBZlZWX9/WQAAAAAAMA0vCogLF26NL9zAAAAAAAAE/OqgHDTTTfldw4AAAAAAGBiXs2BMH/+fP3222+2+1OnTlVMTIzuv/9+nTx5Mt/CAQAAAAAAc/CqgDBkyBDbZImbNm1SfHy8unbtqn379ik+Pt7j/qZOnaro6GgFBwerVatWWr16tVvbzZkzRxaLRT179vR4nwAAAAAAwH1eFRD27dun+vXrS5K+/PJLde/eXS+//LKmTp2qn376yaO+5s6dq/j4eI0aNUpr165VkyZN1KlTJx09ejTP7fbv36/nnntON9xwgzeHAAAAAAAAPOBVASEwMFDnz5+XJP3888/q2LGjJKls2bIef43jhAkTNGDAAPXr10/169fX9OnTFRoaqpkzZ+a6TVZWlh544AElJiaqevXq3hwCAAAAAADwgFeTKLZr107x8fFq27atVq9erblz50qSdu7cqcqVK7vdj9Vq1Zo1azR8+HDbMj8/P3Xo0EFJSUm5bjdmzBhVqFBB/fv31/Lly/PcR0ZGhjIyMmz3cwocmZmZyszMdDtrYTEMw5S5JLJ5w6y5JLJ5y6zZzJpLIpu3vM2W5RfkVjtvj7sonrPCYNbHUzLveTNrLols3jLrz0FRPGeFgWyeM2suTzJ5VUCYMmWKnnjiCX3xxReaNm2aIiMjJUk//fSTOnfu7HY/aWlpysrKUnh4uN3y8PBwbd++3ek2v/32m95//32tX7/erX2MGzdOiYmJDssXLlyo0NBQt7MWFqvVqnnz5vk6hlNk85xZc0lk85ZZs5k1l0Q2b3mdrdFIt5pt9PK4i+Q5KwRmfTwl8543s+aSyOYts/4cFMlzVgjI5jmz5sq5usAdFsMwjALMkqfDhw8rMjJSK1euVGxsrG350KFD9csvv2jVqlV27c+cOaPGjRvr7bffVpcuXSRJffv21alTp/TNN9843YezEQhRUVFKS0tTWFhY/h/U31S5cmUdPHjQ1zGcIpvnzJpLIpu3zJrNrLkksnnL22wHx8e6biSp8rDcR/rluV0RPGeFwayPp2Te82bWXBLZvGXWn4OieM4KA9k8Z9Zc6enpKleunE6fPu3yPbLbIxDS09Ntnbma58DdN+blypWTv7+/UlNT7ZanpqYqIiLCof2ePXu0f/9+de/e3bYsOztbklSsWDHt2LFDNWrUsNsmKChIQUGOw54CAgIUEBDgVs7CZLFYTJlLIps3zJpLIpu3zJrNrLkksnnL22z+2RmuG0leH3dRPGeFwayPp2Te82bWXBLZvGXWn4OieM4KA9k8Z9ZcnmRyu4BQpkwZHTlyRBUqVFDp0qVlsVgc2hiGIYvFoqysLLf6DAwMVPPmzbV48WLbVzFmZ2dr8eLFiouLc2hft25dbdq0yW7ZiBEjdObMGU2aNElRUVHuHg4AAAAAAPCA2wWEJUuWqGzZspKkpUuX5luA+Ph49enTRy1atFDLli01ceJEnTt3Tv369ZMk9e7dW5GRkRo3bpyCg4PVsGFDu+1Lly4tSQ7LAQAAAABA/nG7gHDTTTfZ/f/ixYvauHGjjh49aruMwBu9evXSsWPHlJCQoJSUFMXExGj+/Pm2iRWTk5Pl5+fVt00CAAAAAIB84tW3MMyfP1+9e/dWWlqawzpPLmHIERcX5/SSBUlatmxZntt++OGHHu0LAAAAgG81H/Kx222/LlmAQQB4xKuP9p988kndfffdOnLkiLKzs+1unhYPAAAAAACA+XlVQEhNTVV8fLztMgMAAAAAAFC0eVVAuOuuu1xeWgAAAAAAAIoOr+ZAmDJliu6++24tX75cjRo1cvjeyKeeeipfwgEAAAAAAHPwqoDw3//+VwsXLlRwcLCWLVsmi8ViW2exWCggAAAAAABQxHhVQHjxxReVmJio559/nq9YBAAAAADgGuDVu3+r1apevXpRPAAAAAAA4BrhVQWgT58+mjt3bn5nAQAAAAAAJuXVJQxZWVl69dVXtWDBAjVu3NhhEsUJEybkSzgAAAAAAGAOXhUQNm3apKZNm0qSNm/ebLfuygkVAQAAAABA0eBVAWHp0qX5nQMAAAAAAJgYsyACAAAAAACXKCAAAAAAAACXKCAAAAAAAACXKCAAAAAAAACXKCAAAAAAAACXvPoWBgBA0ZA8ppHbbaskbCrAJAAAADA7RiAAAAAAAACXKCAAAAAAAACXKCAAAAAAAACXKCAAAAAAAACXKCAAAAAAAACXKCAAAAAAAACX+BpHAAAAFBl8PS0AFBwKCAA8wh9mAAAAwLWJSxgAAAAAAIBLFBAAAAAAAIBLFBAAAAAAAIBLFBAAAAAAAIBLFBAAAAAAAIBLFBAAAAAAAIBLFBAAAAAAAIBLFBAAAAAAAIBLFBAAAAAAAIBLFBAAAAAAAIBLFBAAAAAAAIBLFBAAAAAAAIBLFBAAAAAAAIBLxXwdAAAAZ5LHNHK7bZWETQWYBAAAABIjEAAAAAAAgBsoIAAAAAAAAJcoIAAAAAAAAJdMUUCYOnWqoqOjFRwcrFatWmn16tW5tv3qq6/UokULlS5dWsWLF1dMTIw++eSTQkwLAAAAAMC1x+cFhLlz5yo+Pl6jRo3S2rVr1aRJE3Xq1ElHjx512r5s2bJ68cUXlZSUpI0bN6pfv37q16+fFixYUMjJAQAAAAC4dvi8gDBhwgQNGDBA/fr1U/369TV9+nSFhoZq5syZTtu3b99ed9xxh+rVq6caNWpo8ODBaty4sX777bdCTg4AAAAAwLXDp1/jaLVatWbNGg0fPty2zM/PTx06dFBSUpLL7Q3D0JIlS7Rjxw6NHz/eaZuMjAxlZGTY7qenp0uSMjMzlZmZ+TePIP8ZhmHKXBLZvGHWXJL32bL8gtxu6+2xF8XzVtCK4uNp5myFoaDPG+escJn18ZTMe9547fDOPyVboL/72/G6RjZPmTWbWXN5ksmnBYS0tDRlZWUpPDzcbnl4eLi2b9+e63anT59WZGSkMjIy5O/vr7ffflu33nqr07bjxo1TYmKiw/KFCxcqNDT07x1AAbBarZo3b56vYzhFNs+ZNZf0N7I1Gul2041eHnuRPG8FrEg+nmbOVggK+rxxzgqXWR9PybznjdcO7/xTsj0fW8rt7TaK1zUzIpvnzJrr/Pnzbre1GIZhFGCWPB0+fFiRkZFauXKlYmNjbcuHDh2qX375RatWrXK6XXZ2tvbu3auzZ89q8eLFGjt2rL755hu1b9/eoa2zEQhRUVFKS0tTWFhYvh/T31W5cmUdPHjQ1zGcIpvnzJpL8j7bwfGxrhvl7GOY65FETrcrguetoBXFx7MoZPM2l2TebGb9GZCKZjYzP9cKWlF87SgM/5RsN478r9vbzS4x2b3+eTwLFdk8Z9Zc6enpKleunE6fPu3yPbJPRyCUK1dO/v7+Sk1NtVuempqqiIiIXLfz8/NTzZo1JUkxMTHatm2bxo0b57SAEBQUpKAgx2FPAQEBCggI+HsHUAAsFospc0lk84ZZc0neZ/PPznDd6P95e+xF8bwVtKL4eBaFbH/nuWLWbGb9GZCKZjYzP9cKWlF87SgM/5Rs1iz3t+N1jWyeMms2s+byJJNPJ1EMDAxU8+bNtXjxYtuy7OxsLV682G5EgivZ2dl2owwAAAAAAED+8ukIBEmKj49Xnz591KJFC7Vs2VITJ07UuXPn1K9fP0lS7969FRkZqXHjxkm6PKdBixYtVKNGDWVkZGjevHn65JNPNG3aNF8eBgAAAAAARZrPCwi9evXSsWPHlJCQoJSUFMXExGj+/Pm2iRWTk5Pl5/e/gRLnzp3TE088oYMHDyokJER169bVrFmz1KtXL18dAgAAAAAARZ7PCwiSFBcXp7i4OKfrli1bZnf/P//5j/7zn/8UQioAAAAAAJDDp3MgAAAAAACAfwYKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCUKCAAAAAAAwCVTfI0jAAAAAN9JHtPIrXZVEjYVcBIAZsYIBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4BIFBAAAAAAA4FIxXwcAfCl5TCO32lVJ2FTASQAAAADA3BiBAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXKKAAAAAAAAAXOJrHAEAAACgCHH3q8olvq4cnmEEAgAAAAAAcIkCAgAAAAAAcMkUBYSpU6cqOjpawcHBatWqlVavXp1r23fffVc33HCDypQpozJlyqhDhw55tgcAAAAAAH+fzwsIc+fOVXx8vEaNGqW1a9eqSZMm6tSpk44ePeq0/bJly3Tfffdp6dKlSkpKUlRUlDp27KhDhw4VcnIAAAAAAK4dPp9EccKECRowYID69esnSZo+fbp+/PFHzZw5U88//7xD+08//dTu/nvvvacvv/xSixcvVu/evQslMwAAAOApJrYD8E/n0wKC1WrVmjVrNHz4cNsyPz8/dejQQUlJSW71cf78eWVmZqps2bJO12dkZCgjI8N2Pz09XZKUmZmpzMzMv5G+YBiGYcpcUtHMluUX5FY7b4/7Wj5nEuetMBXFx7MoZPs7zxWzZjPrz4BUNLOZ+blW0K7l1w7JvNny67kW6O/+dryuFa3nWmEwazaz5vIkk08LCGlpacrKylJ4eLjd8vDwcG3fvt2tPoYNG6ZKlSqpQ4cOTtePGzdOiYmJDssXLlyo0NBQz0MXMKvVqnnz5vk6hlNFMlujkW412+jlcV/L50zivBWmIvl4FoFs3uaSzJvNrD8DUhHNZubnWgG7ll87JPNmy6/n2vOxpdzebqN4XfOYmZ9rhcCs2cya6/z58263tRiGYRRgljwdPnxYkZGRWrlypWJjY23Lhw4dql9++UWrVq3Kc/tXXnlFr776qpYtW6bGjRs7beNsBEJUVJTS0tIUFhaWPweSjypXrqyDBw/6OoZTRTHbwfGxrhtJqjzMvRExDttdw+dM4rwVpqL4eBaFbN7mksybzaw/A1LRzGbm51pBu5ZfOyTzZsuv59qNI//r9nazS0x2r/98OmfuZvt17H1e7c8TRfG5VhjMms2sudLT01WuXDmdPn3a5Xtkn45AKFeunPz9/ZWammq3PDU1VREREXlu+/rrr+uVV17Rzz//nGvxQJKCgoIUFOQ4hCcgIEABAQHeBS9AFovFlLmkopnNPzvDdSPJ6+O+ls+ZxHkrTEXx8SwK2f7Oc8Ws2cz6MyAVzWxmfq4VtGv5tUMyb7b8eq5Zs9zfrrBf19zNVhg/N0XxuVYYzJrNrLk8yeTTb2EIDAxU8+bNtXjxYtuy7OxsLV682G5EwtVeffVVjR07VvPnz1eLFi0KIyoAAAAAANc0n38LQ3x8vPr06aMWLVqoZcuWmjhxos6dO2f7VobevXsrMjJS48aNkySNHz9eCQkJmj17tqKjo5WSkiJJKlGihEqUKOGz4wAAAAAAoCjzeQGhV69eOnbsmBISEpSSkqKYmBjNnz/fNrFicnKy/Pz+N1Bi2rRpslqtuuuuu+z6GTVqlEaPHl2Y0QEAAABco/haTlyLfF5AkKS4uDjFxcU5Xbds2TK7+/v37y/4QAAAAAAAwI5P50AAAAAAAAD/DBQQAAAAAACASxQQAAAAAACASxQQAAAAAACASxQQAAAAAACASxQQAAAAAACASxQQAAAAAACAS8V8HQCAOTQf8rFb7b4uWcBBAAAAAJgSIxAAAAAAAIBLFBAAAAAAAIBLXMIAAIUgeUwjt9pVSdhUwEkAAAAA71BAAFBk8CYdAAAAKDhcwgAAAAAAAFyigAAAAAAAAFyigAAAAAAAAFyigAAAAAAAAFyigAAAAAAAAFyigAAAAAAAAFyigAAAAAAAAFyigAAAAAAAAFyigAAAAAAAAFyigAAAAAAAAFwq5usAAACg6Ese08jttlUSNhVgEgAA4C1GIAAAAAAAAJcYgVBE8MkOAAAAAKAgUUBAgXO3uEFhAwAAAADMiwICAAAAAKBQ8OHiPxsFBAAAAAAATMpMl6sziSIAAAAAAHCJAgIAAAAAAHCJSxgAAAAAANc85mdwjREIAAAAAADAJQoIAAAAAADAJQoIAAAAAADAJQoIAAAAAADAJQoIAAAAAADAJQoIAAAAAADAJQoIAAAAAADAJQoIAAAAAADAJQoIAAAAAADAJQoIAAAAAADAJQoIAAAAAADAJZ8XEKZOnaro6GgFBwerVatWWr16da5tt2zZon//+9+Kjo6WxWLRxIkTCy8oAAAAAADXMJ8WEObOnav4+HiNGjVKa9euVZMmTdSpUycdPXrUafvz58+revXqeuWVVxQREVHIaQEAAAAAuHYV8+XOJ0yYoAEDBqhfv36SpOnTp+vHH3/UzJkz9fzzzzu0v/7663X99ddLktP1nkhKSlLx4sXdbl+nTh2VL1/ebpnVas1zxIQzpUqVUqNGjRyWb926VSdOnJDVatVvv/3mVl/NmjVTaGio3bJT5y9p17GMPLdLvqr/SpUqqXr16g7tVq9eLavVarvvKpufn5/atGnjsPzQKasOn87MM9PVuWrXrq0KFSrYrc/MzNSqVaucbptbtrCwMDVu3Nhh+bZt23T8+HGlHjjnMldOtqZNmzo8Z06ePKktW7bkup2zXBUrVlSNGjUc2v7xxx/KyMj7sbuSxWJR27ZtHZb/9ddfOnDggMvtr8xWq1Yth/VG1iWdO7LXMWdo7ueseJCf6keEOCzPOd/uslqtOnfunMP5PnXqlDZv3pzrds4ezwoli6lq2SCH5X/++acuXrzodiZJateuncOygwcPav/+/S63vTJb1bKBqlAywG79pSxD6w6ed/j5zEuJEiUUExPjsHz79u1KS0tzq4+cXPUjglU8yN9uXfrFLO1I/d85cidbRESEatas6bB8zZo1unDhgluZclRxsiwlPVN/nbQ6LM8rW40aNVSxYkW7ZVlZWUpKSvLoNbd48eJq2rSpw/I9aRk6ce6S021yy9WkSROVLFnSbtnp06e1adMm2313soWHhzv9+d10+IIuZmbnue3V2dq2bSuLxWK37PDhw9q71/51wFWu6tWrq1KlSnbLsrOz9Yebr7c52UJDQ9WsWTOHdTt37sz1g4bcsjVu3FhhYWF2y9LT07Vx40a3M0lShQoVVLt2bYfla9eu1fnz5/Pc9upsbdq0kZ+f/ec4zs63q99TVcoEKjzM/vXEMAytWLEiz+2uzrZ27Vqn53vXrl1KTU11uy9JatSokUqVKmW37MyZM9qwYYNH/Vy65Pznat26dTp3Lvfz4uycNYsKlb+f/fM79UymR6+5klStWjVFRkY6LHf3dSQnW3CAnxpVcvx9uf94ho6dvXzc7mZzdr7Pnj2r9evXu7V9DuuxDNUs7/j7csuRCzpv/d/riTu5WrdurWLF7N9mpKSk2P0cnD2402U/gaXKKbBkWYflub2e5JYtODhYLVq0cFi+Z88eHTlyxOHnM69sweUiVSzY/u+T89ZsbTmS9++4q7Ndd911qlevnkO7DRs26MyZM7b77vwuaNWqlQIC7F8Hjp29pP3H3fu7Midb1apVFRUV5bB+xYoVMgzDYXlu2YKCgmzv2a6Uc749+fu7QYMGKlOmjN3yc+fOad26dXlue3W23M73xo0blZ6ebrvvTraYyqEOy44ePaqdO10/p6/MVaVKFVWp4vjXzsqVK5Wdbf87PK9cAf4Wp5n27t2rw4cPu8wkKc/XVAeGj2RkZBj+/v7G119/bbe8d+/eRo8ePVxuX7VqVePNN9902e7ixYvG6dOnbbe//vrLkOTx7eOPPzasVqvd7cCBAx73c+ONNzr0Y7VajW7dunnc16ZNm2zb7x3b3Ng7trnx3oM1Pe5n8ODBTjNFRkZ61E9oaKjTfuJvqeRxpg8++MChn0OHDnncT5s2bZxmuv322z3ua926dQ79/PDDDx73M2jQIKeZqlat6lE/gYGBTvsZO3asx5nee+89o/Wwj+xuLZ6a6nE/TaOK256Le8c2t2W68847Pe7rzz//dDi2n376yeN+HmxZ3i5TTq4aNWp41I+/v79htVqNChUq2GUaN26cx5nG3V7VIdOGF2M87qd58/+d4ytz3XPPPR739d3j9RwyzX64tsf9PPLIIw6PW4UKFYxatWp53NfVefaObW680Lmyx/1MnTrVIdPJkyc97icmJsbhNXfv2ObG7Y3LetzXypUrHTItXbrU43769evn0M/esc2NWuWDPe7r/PnzDn1NmDDB434mTZrk0M+ZM2c87qdhw4ZOX+Meeughj/v69ddfHfr59ddfPe7noYcecpqpYcOGHvd15swZh34mTZrkcT8JXaPsXm+tVqtx/vx5j/upV6+e02Pr16+fx30tXbrUoZ+VK1d63E9QUJDTTDExMR73tXlkjMPryX96VPG4n1dffdXp7wJP+6l2XZDT17j7WpTzuK9FixY5vOauWrXK435ua1TGaaZGkaEe95WWlubwuE2fPt3jfqq072W0HvaRQyZ/P8/6qVGjhtPn0mOPPeZxpnq9htr+VsrJ8+Ogeh73c+eddzrN1KpVK4/7SklJcejn1Ts8+7tSkjF27FinmQIDAz3qp2rVqk77GTRokMeZfvjhB4d+1q1b53E/t99+u9NMbdq08bivP55v7NDPBx984HE/o0ePdpopNNSzn7mIsACnf38PHjzY40ynT592+f7aZyMQ0tLSlJWVpfDwcLvl4eHh2r59e77tZ9y4cUpMTPzb/axfv97h04sTJ0543M/x48c1b948h+W5fZqSl19//VV79uy5fKfRSEnS/ow/Jf3Ho3727dvnNJOnn85mZWU57SclvL2k2R71tWHDBodq4+nTpz3qQ7o8QsBZJk8/TZGk5cuXO3yy76r66cz+/fudZnL16dXVsrOznfazY8cOjzNt2LBBz99yi92yM2f89JCH/ZwPrayN//9clKSN/58vJSXF40y//fabDh486JDTU8eva6GNjQbaLds4b55nlVZJhmFo3rx5slqtdufdm9erg5Vv08ZGt9otu/z43+9RP6dPn7ZluTLXkSNHPM60q+Yjyr5qZMwebZI00vkGuUhOTnZ4Xlr/f0SJp658LuU4svdbSR941M/mzZsdMnn6+iZd/sTa1s8V2U79/KakXzzqa8WKFQ6v+1u3bvU4019//eX4OtBopC4GPynpL4/6+umnn+Tvbz8KxZtMW7ZscciUmel6FNrVzpw54/Q17urXBXesXLnS4Xe2Vz+7Bw86zXTlp4Xumj9/vsMnhnmNaMvN4UqdtLHRbbbXW+ny72NPnT171umx/fWXZ88j6fIoz6t/Z+/atcvjfnL7PXflp4Xu2tzgeQUHB9stO3R4gaRpHvWzbds2p78LPJURdJ3T17jjy9+WtNCjvn7//Xe711irByOrrnS6dENtbPSsw/ILIc9J2u1RXwsXLnQYJXvlCCt3/atqsO6ILaWNV/0uMnSnpLxHWV3p3LlzTh8vd0ZsXu3e+sXVpEkpSbLl2l9yv6SnPeonJSXFaaZTp055nGnRokUOo9r+qtxD0lse9bNjxw6nma7+NNyV8+fPO+3HnRGbV/vjjz8cRiMlJyd73E9qaqrTTCdPnvS4r631ntWhq/ry5m/UnTt3Os3k6Wt4ZkCY07+/9+3b53Emd/j0EobCMHz4cMXHx9vup6enOx2a40pMTIy6du1qt8ybP9Kvu+46h34k6d133/W4rxtvvFF16tSRJB0cHytJStvv+ZvsatWqOc109S9aV/z9/Z328+tbT3icqUmTJg59HTt2zON+ypQp4zTTBx949gZEkm644QY1aNDAbtnVw/PcER0d7TTT1b9oXfHz83Pajze/oJs0aaJXkuyfO5cunPW4n9DzB9V401jb/crDkiRJH3/8scd9tWvXzuHyk6Agx6GVrlx3/E813mT/Rq3yMM8uYZIuXzLStWtXBQYG2p33bdu2eZyp8sEf1HjT73bLzlz0/A/+UqVK2bJcmWv2bM8KdpJUa/d7anje/jl4fp/nb4qqVKni8LwMDAz0+HxLsnsu5Vh9xPPiX8OGDR0yeVPQCAsLs/WT85orSaVPev4Lum3btg7Daa8eguyOqKgoh2M7OD5WwRc9f73s0qWLw2va1cPp3dGgQQOHTJ5cnpWjZMmSTl/jvvzyS4/7atOmjVq3bm23rGxZx2HRrlSuXNlpphEjRnjcV+fOnR1e07x5M1Pp8AI13rTO9nor5T70Py8lSpRwemzffvutx33FxsY6XGL3559/etxPbr/nRo8e7XFfDbe8otBA+wLZ5kOe/5zUq1fP6e8CTwVlHHf6GnfdCc+fA61bt9ZNN91kux8YGOj0kjtXSp3a7DRTyAX3hkBfqWPHjg4fvHnzYcLSAxe1I+m0ZpeYbLfc4kHxQLp8CZqzx2v+/PkeZ5qz9Zx+On/5b6acXAEpnn0IJF2+5M9ZpnHjxnnc16233urwmrbzo8Ee91OnTh2nma6+3MqV0NBQp/0sWrTI40zXX3+9OnbsaLfMm2JreHi400yvvvqqx33V3/aGmoyxf03zphBRu3Ztp5muLua7EpCZ7vTv76VLl3qcyR0Ww3ByQUshsFqtCg0N1RdffKGePXvalvfp00enTp1y+QsrOjpaTz/9tJ5++mmP9puenq5SpUpp/vz5ppwDoUePHvruu+/c6uvKORCSx1zu0505EML72b+Zc3cOBFfZcpsDISm+jltzIFyZy9M5EHLL5nIOhA96u8yVk82bORCc5TLLHAhXZqtVq5a6vr7Abn1ucyC8HJr7m9Or50CoknC5mOHpHAg9evTQX3/95fkcCE4eT2dzIFRJ2OT1HAgRERF2fwS5PQfCFdnymgPh6p/PvFw5B8KVuTyaA+H/c7kzB4I72ZzNgRAREaEff/zR8zkQljzusCy3ORDyypbXHAievOZeOQdCzmuulPccCLnlcmcOBHeyOZsDIXlMI7fmQLg6m7tzILjKldscCF8PcJwbI69s3syBkFs2M8yBcHU2t+dAcPF7KmcOhJzXW0kez4HQo0cP/fzzz6abA6Fnz55OX8tczoHg5JzlNgdCxu3veZQpZw6Eq38XuD0Hwv9nc2cOBHd/H1x9viMiIrR7927P50CY+7BbcyC4kyu3ORDq169v+znoP9X1m/ecORC+Lvma3fLc5kDILZurORCu/vnMK9uVcyDk5HJnDoSrs7k7B4I7vwuczYGwZmg9t+dAyMnm6RwIuWVzOQeCB39/ezsHwtXZ3J4DwY1sMZVDVSPR/u9Rd+dAuDKXR3Mg5JHr6jkQcn4feDoHQufOnXX69GmH35dX81kBQbr8ZG/ZsqXeeuvy8Jrs7GxVqVJFcXFxLidJ/LsFBHdOji9c/QvJXVf+MevKlX9keKKgs3mbSzJvNm9zFYarszUf4t4fKlf/Es8Lz7X/MetzrSi8dkjmzcZz7X/M/HgWBrM+npJ5z1tRfK4VhWz59Vxz9+8Oyf2/PfLrnF1LfxNJ5s3G79D/KejH05P3yD69hCE+Pl59+vRRixYt1LJlS02cOFHnzp2zfStD7969FRkZaRvKY7VabddjWq1WHTp0SOvXr1eJEiWczvoNAAAAAADyh08LCL169dKxY8eUkJCglJQUxcTEaP78+baJFZOTk+2G9x0+fNjuK7Ref/11vf7667rpppu0bNmywo4PAABwzSqMTxEBAObi80kU4+LiFBcX53Td1UWB6Ohop9ffAAAAAACAguXZlJoAAAAAAOCaRAEBAAAAAAC4RAEBAAAAAAC4RAEBAAAAAAC4RAEBAAAAAAC4RAEBAAAAAAC4RAEBAAAAAAC4RAEBAAAAAAC4RAEBAAAAAAC4RAEBAAAAAAC4RAEBAAAAAAC4RAEBAAAAAAC4RAEBAAAAAAC4RAEBAAAAAAC4RAEBAAAAAAC4RAEBAAAAAAC4RAEBAAAAAAC4RAEBAAAAAAC4RAEBAAAAAAC4RAEBAAAAAAC4RAEBAAAAAAC4RAEBAAAAAAC4RAEBAAAAAAC4RAEBAAAAAAC4RAEBAAAAAAC4RAEBAAAAAAC4VMzXAf5Jksc0crttlYRNBZgEAAAAAIDCxQgEAAAAAADgEgUEAAAAAADgEgUEAAAAAADgEgUEAAAAAADgEgUEAAAAAADgEgUEAAAAAADgEgUEAAAAAADgEgUEAAAAAADgEgUEAAAAAADgEgUEAAAAAADgEgUEAAAAAADgEgUEAAAAAADgEgUEAAAAAADgEgUEAAAAAADgUjFfBwAAV5oP+ditdl+XLOAgAAAAwDXMFAWEqVOn6rXXXlNKSoqaNGmit956Sy1btsy1/eeff66RI0dq//79qlWrlsaPH6+uXbsWYmIAAFBUJI9p5HbbKgmbCjAJAADm5vNLGObOnav4+HiNGjVKa9euVZMmTdSpUycdPXrUafuVK1fqvvvuU//+/bVu3Tr17NlTPXv21ObNmws5OQAAAAAA1w6fFxAmTJigAQMGqF+/fqpfv76mT5+u0NBQzZw502n7SZMmqXPnzhoyZIjq1aunsWPHqlmzZpoyZUohJwcAAAAA4Nrh00sYrFar1qxZo+HDh9uW+fn5qUOHDkpKSnK6TVJSkuLj4+2WderUSd98843T9hkZGcrIyLDdP336tCTpxIkTyszM9CjvKav7p6v48eMe9Z0jKytLx73Ytihk8zaXZN5s3uY69GYHt9tGPvOzx/1Ljtn8Ll1waztfPNfyOxvPtf8pCq8dknmz8Vz7n6LweErmzcZz7X+KwuMpmTdbfj3X3P3dLhX+c83MfxO5qyhk43Xtfwr68Txz5owkyTAM140NHzp06JAhyVi5cqXd8iFDhhgtW7Z0uk1AQIAxe/Zsu2VTp041KlSo4LT9qFGjDEncuHHjxo0bN27cuHHjxo0bt1xuf/31l8v38KaYRLEgDR8+3G7EQnZ2tk6cOKHrrrtOFovlb/efnp6uqKgo/fXXXwoLC/vb/eUXs+aSyOYts2Yzay6JbN4yazaz5pLI5i2zZjNrLols3jJrNrPmksjmLbNmM2suiWzeys9shmHozJkzqlSpksu2Pi0glCtXTv7+/kpNTbVbnpqaqoiICKfbREREeNQ+KChIQUFBdstKly7tfehchIWFme5JJZk3l0Q2b5k1m1lzSWTzllmzmTWXRDZvmTWbWXNJZPOWWbOZNZdENm+ZNZtZc0lk81Z+ZStVqpRb7Xw6iWJgYKCaN2+uxYsX25ZlZ2dr8eLFio2NdbpNbGysXXtJWrRoUa7tAQAAAADA3+fzSxji4+PVp08ftWjRQi1bttTEiRN17tw59evXT5LUu3dvRUZGaty4cZKkwYMH66abbtIbb7yhbt26ac6cOfrzzz81Y8YMXx4GAAAAAABFms8LCL169dKxY8eUkJCglJQUxcTEaP78+QoPD5ckJScny8/vfwMl2rRpo9mzZ2vEiBF64YUXVKtWLX3zzTdq2LChT/IHBQVp1KhRDpdJ+JpZc0lk85ZZs5k1l0Q2b5k1m1lzSWTzllmzmTWXRDZvmTWbWXNJZPOWWbOZNZdENm/5KpvFMNz5rgYAAAAAAHAt8+kcCAAAAAAA4J+BAgIAAAAAAHCJAgIAAAAAAHCJAgIAAAAAAHCJAgIAAAAAAHCJAoKHLl26pA0bNmjBggVasGCBNmzYoMzMTF/HApCLffv26dKlS76OAQDwkd27d2vBggW6cOGCJIkvIMvdmDFjdP78eYflFy5c0JgxY3yQ6J/h1KlTeu+99zR8+HCdOHFCkrR27VodOnTIx8mA/EcBwU3Z2dkaMWKEypcvr6ZNm6pLly7q0qWLmjZtqgoVKmjkyJHKzs72dUzkoz179ujmm2/2yb6PHDmiWbNmad68ebJarXbrzp0759Nf4osWLdKoUaO0ZMkSSdKvv/6qLl266Oabb9YHH3zgs1y5qVOnjnbt2uXrGHYOHz6sUaNG6YEHHtBzzz2n7du3+zoSABQ5x48fV4cOHVS7dm117dpVR44ckST1799fzz77rE+zVa9eXcePH3dYfurUKVWvXt0HiS5LTEzU2bNnHZafP39eiYmJPkj0P//X3n2GRXX1ex//Db13kKI0kWIEwZLYsWKLGnuLqIhRY1CxnyRKMBGNEQtqooiiaNQYI5bEjqKCGkEECyAKGhILFkQFC2XW84KHCeOA7Za9lub/uS6uI3vPyXzvDTPMrFl77fbt26OgoEBl+8OHD7m9XgOAc+fOwdXVFd9//z0WLlyoaNy+fTv+7//+j1vX84qLi3Hp0iVhPlSJiYnBs2fPVLYXFxcjJiaGQ9G/RG4T4nHAyCuZNm0as7S0ZCtXrmRXr15ljx8/Zo8fP2ZXr15lq1atYlZWVmz69Om8M6uVm5vLRo4cyeW+Hz9+zI4fP84uXryosu/Jkyds/fr1HKpeLjU1lampqUl+v6dPn2YmJibMyMiI6erqMhcXF3bhwgXF/lu3bnHpYoyxDRs2MA0NDdaoUSNmYGDAoqOjmYmJCQsMDGQBAQFMS0uL/frrr1zaevfuXeWXmpoa69ixo+J7HnR1ddnt27cZY4xdvHiRGRsbMxcXF9a/f3/m7u7O9PT0WFpaGpe2l7l16xYLDQ3lnVElns9rLyLyMRO5LT8/X9i/B6IeN5GPmQhtw4YNY507d2Z///03MzAwYNnZ2Ywxxvbt28fq16/PtU0mk7G8vDyV7bdu3WJaWlocisrJZDLF36vK4uLimIWFBYeif1V3zPLy8piGhgaHonIdOnRg06ZNY4wxpd+zxMRE5uDgwK2rQlFREQsICGDq6upMXV1d0ffFF1+wefPmcetSU1Or8ud59+5dbq9zK4jcJsLjQMYYzeN6FdbW1li/fj06d+5c5f79+/fD398feXl5Epe9mrS0NDRq1AhlZWWS3m9WVhb8/PyQm5sLmUyGVq1aYcuWLbCxsQEA5OXlwdbWVvIuAIiIiHjh/uvXr2PhwoWSt3Xq1Al16tRBVFQUioqKMGPGDGzduhUHDx6Ej48P12Pm4+ODkSNHYsKECYiLi0OPHj0wd+5cBAcHAwDCw8MRGxuLhIQEydvU1NTQpk0bODk5KW2PiYlBz549YWJiAgBcZkmoqanh1q1bsLKywieffAK5XI7t27dDQ0MDcrkcQ4cORWFhIXbv3i1528vweu54FaK2idoFUNubErVN1C5AjDZra2vs378fDRs2hKGhIdLS0uDs7IycnBx4eXlV+Ul7Tdu1axcA4JNPPsH69ethbGys2FdWVoa4uDgcPHgQly5dkrTL1NQUMpkMDx48gJGREWQymVJXYWEhxo4dixUrVkjaBZR/wg8A3t7eOHz4MMzMzJTa9u3bh1WrVuHatWuStwGAsbExUlJSULduXaXfs7/++gtubm54+vQpl64KEydORGJiIpYsWYIuXbrg3LlzcHZ2xs6dO/HNN9/g7NmzXLrU1NSQl5cHS0tLpe1paWlo166d4lQQHkRsE+lxoFHj9/CeePToEWxtbavdb2Njg6KiIgmLlFX8QapOTk6ORCXKZsyYgQYNGiA5ORkFBQWYNGkSWrZsifj4eNjb23NpqjBp0iTY2NhAS0uryv3PnzoglTNnzmDFihVQU1ODoaEhfvzxR9jb26NDhw7Yv38/1+N2+fJl9OjRAwDQoUMHlJaWokOHDor93bt3x7x587i0bdq0CdOmTcPw4cMxcuRIxfaNGzdi7ty5qF+/Ppeu56WkpODnn3+Ghkb506+amhqmT5+O7t27c+mp+INUHalfxFYm6vOayMdM5LaHDx++cP+jR48kKlEl6nET+ZiJ3FahqKgIenp6Ktvz8/Ohra3Noah84AAAZDIZhg8frrRPU1MTjo6OCA8Pl7xryZIlYIwhICAAoaGhSgMbWlpacHR0RPPmzSXvAsrfMMlkMshksiqnaOvq6mLZsmUcysppa2tX+XjIyspSeQPKw44dO/DLL7+gWbNmSgNDH3zwAbKzsyXv8fHxUfw8O3TooHg9BJS/Eb569Sq6dOkieZfobSI9DmgA4RW1bdsWU6dOxc8//wwLCwulfXfv3sWMGTPQtm1bPnEo/4Mkk8leuDBQ5ScNqZw4cQKHDh2ChYUFLCwssHv3bnz++edo3bo1jhw5An19fcmbKjg4OOD777/HgAEDqtyfmpqKxo0bS1xV7vnR6pkzZ0JDQwN+fn5Yu3Ytlyag/MVN5YEVbW1tGBgYKH1fsUiV1AYNGoRmzZrh008/xe+//46oqCiYmppyaXlexRM+UD5gUPmFGQCYmJjg/v37PNIUf5Cqeu6o2M7juQMQ93lN5GMmcpuJickL75uOmyqRj5nIbRVat26NmJgYfPvttwDKf5ZyuRwLFixAu3btuDRVrJfl5OSEpKQkldeUvFQMZjg5OaFFixbQ1NTkXPSvq1evgjEGZ2dnnD59WulNuZaWFqysrKCurs6tr2fPnpgzZw62bt0KoPz3LDc3FzNmzEDfvn25dVW4c+cOrKysVLYXFRVxeYxWDKKlpqaic+fOSq8jKwareB03kdtEehzQAMIrWrlyJbp16wYbGxt4enqiVq1aAMqn4J8/fx7169fH77//zq3PxsYGP/74I3r16lXlfl5vhp88eaI0eieTyfDTTz/hiy++gK+vLzZt2iR5U4XGjRvjzJkz1Q4gvOyNS01p0KABTpw4AS8vL6XtU6dOhVwux+DBgyVvquDi4oLMzEy4ubkBKD/Nw9DQULE/OzsbtWvX5pUHR0dHHDt2DKGhoWjYsCFWr17N/QUsUP5C2tXVFTKZDIWFhTh37pzSz/fKlSuwtrbm0mZmZoYFCxYozSSp7OLFi4pZJ1IT9XlN5GMmcpuhoSG++uorfPTRR1Xuv3z5MsaMGSNxVTlRj5vIx0zktgoVP9Pk5GQUFxdj+vTpuHjxIvLz85GYmMi17erVq1zvvzq+vr6Qy+XIysrC7du3VRYIb9OmjeRNDg4OACDsYuXh4eHo168frKys8OTJE/j6+uLWrVto3rw55s6dyzsPTZo0wR9//IGgoCAA/w68R0VFcZlVEhISAqD8NdvAgQOho6MjeUN1RG4T6XFAAwivqE6dOorLN546dQq3bt0CAHz44YcICwuDn58f1NT4XdSi4s1wdS+0eb0Zdnd3R3JyMjw8PJS2L1++HED5qC0v1V2qqEL9+vW5/IH39/fH0aNHMXbsWJV906dPB2MMK1eulLwLAL788kulT/WNjIyU9icnJ1c7ICMVNTU1hIaGolOnTvD39xfi3ODn111wcXFR+v7UqVPo3bu3lEkKjRs3xo0bNxR/mJ5XUFDA7ZJnoj6viX7MRG1r1KgRgPI3KFUxMTGh4/YckY+ZyG0VGjRogKysLCxfvhyGhoYoLCxEnz59MH78eMVaTDzFxcUhLi6uyjfqvGYbnjp1CkOGDMFff/2l8vOTyWTc/6ZevnwZR44cqfKYzZ49m0uTsbExDh48iISEBJw7dw6FhYVo1KgROnbsyKXneWFhYejatSvS09NRWlqKpUuXIj09HSdOnMDRo0e5dVXMeikuLq7y58nzlF2R2wD+jwNaRPE9cfz4cRQVFVV7Xk5RURGSk5Or/UNfU+bNm4fjx49jz549Ve7//PPPsXLlSiFG014mMTERTZo04XbeZHVE7QL4txUWFiI7OxseHh4qa13wbnsRKdtiY2NRVFSETz/9tMr99+/fx65du1TO1ZWCqM9rIh8zkdtWr16NJ0+eYMKECVXuz8vLw8qVKxWfAElJ1OMm8jETue1dEBoaijlz5qBJkyawsbFRmS0XGxvLpcvb2xuurq4IDQ2tsuv5U/CktHr1aowbNw4WFhawtrZWapPJZEhJSeHWJrrs7GzMnz8faWlpigGOGTNmwNPTk1vT5cuXERAQgBMnTihtrzj9iedglchtIjwOaADhP+qff/6Bra0t11kTVRG1Cyj/tD01NZXr9ZmrImoXQG1vSuQ2kYn8/EEIkV51i2PKZDLo6OjA3t6e2yCyjY0NFixYgGHDhnG5/+ro6+sjLS1NZaacCBwcHPD5559jxowZvFOUVHdVr4rfMxcXF7Rp04brOg0iatmyJTQ0NDBz5swqB6saNmzIqUzsNhEeB3QKw1vi4eGBrKws7lO7XlX9+vWFfIMiahcA7lMxqyNqF0Btb0rkNpEHN0R9/hD5mInc5unpiT179qBOnTq8U1SIetxEPmY82ioWxwT+fV6t/EZAU1MTAwcOxKpVqyQ/17m4uBgtWrSQ9D5fxUcffYQrV64IOYBw//599O/fn3eGisWLF+POnTt4/Pix4jTP+/fvQ09PDwYGBrh9+zacnZ1x5MgRLo/N6q6YIpPJoK2tXe3VyGpaamoqzpw5A3d3dy73/yIit4nwOKCPad6SefPmcV0d/3WJ+gZF1C5CSDmRH6OitonaBYjddu3aNZSUlPDOqJKox03kY8ajLTY2FvXq1UNkZCTS0tKQlpaGyMhIuLm5YdOmTVizZg0OHz6Mr7/+WtIuAAgMDOS6kHRl586dU3wFBQVhypQpWLduHc6cOaO072WXO61p/fv3x4EDB7g2VCUsLAxNmzbF5cuXce/ePdy7dw9ZWVn46KOPsHTpUuTm5sLa2hrBwcFc+kxMTGBqaqryZWJiAl1dXTg4OCAkJETy04nr16+Pu3fvSnqfr0rkNhEeBzQD4S2puOwHIYQQQgjhb+7cuVi6dCk6d+6s2Obp6YnatWtj1qxZOH36NPT19TFlyhQsXLiwxnsmT56s+LdcLkdkZCQOHToELy8vlcsmLlq0qMZ7KlR1GdOAgADFvytfylTqmbaVTw9wcXHBrFmzcOrUKXh6eqocs+rW46hpX3/9NX777TfUrVtXsc3FxQULFy5E3759kZOTgwULFnC7/N+6devw1VdfYcSIEfjwww8BAKdPn8b69evx9ddf486dO1i4cCG0tbXx5Zdf1mhL5dkQ33//PaZPn46wsLAqf57PL9Rd00RuE+1xQAMIhBBCCCHkvXP+/Pkqr6zh4OCA8+fPAyh/83zz5k1Jes6ePav0vbe3NwDgwoULStulvvywqJeUBMpPD6jMwMAAR48eVbl6gEwm4zaAcPPmTZSWlqpsLy0tVVy1zdbWFo8ePZI6DQCwfv16hIeHK10lq0ePHvD09MSqVasQFxcHe3t7zJ07t8YHEExMTJR+vxljKpfP5TVYJXKbaI8DGkB4SzIyMtC9e3fk5OTwTiE1ROo/6K9K1C6A2t6UyG2EEPKucHd3x/z58xEZGak4z7ukpATz589XnNt8/fp11KpVS5KeI0eOSHI/r6u6y5eKQOTBjQrt2rXDmDFjEBUVBR8fHwDlg0Xjxo1D+/btAZQPZjk5OXHpO3HiRJWX//bx8cHJkycBAK1atUJubm6Nt4j6GADEbhPtcUADCG9JcXEx/vrrL94Zr0zUNyiidgHinvMqahdAbW9K5DaRH6OitonaBYjdJjI6bu+GFStWoGfPnqhduza8vLwAlL+RKysrw++//w4AyMnJweeff84zUyi7du2qcnvlKwrweiMsqjVr1mDYsGFo3LixYjp5aWkpOnTogDVr1gAo/8Q4PDycS1+dOnWwZs0azJ8/X2n7mjVrFIs63rt3T7EAZE2S+rLLr0PkNtHQAMIrqnzeWlXu3LkjUcnbIeobFB5dISEhCAgIeOkIvNRTz0TtAqjtTYnc9qpEfe4AxG0TtQsQu01kdNzeDS1atMDVq1fx888/IysrC0D5AmRDhgyBoaEhAHC7jGLv3r2rHIiq/EZ9yJAhcHNzk7Trk08+UVkPoaKrYvp2q1atsGPHDknecFZW3WvxysesV69eMDMzk7TL2toaBw8eRGZmpuL3zM3NTeln165dO0mbKlu4cCH69++PvXv3omnTpgCA5ORkZGZmYtu2bQCApKQkDBw4UNIukS+zKnKbCI8DGaO/gq9EXV0d3t7e1S6aUVhYiJSUFK6XcSwpKYGuri5SU1PRoEGDF97277//hq2trSTXpBW1q4K3tzcuXLgAX19fjBo1Cn379uX2pPAudAHU9qZEbntVCQkJaNq0qZDdPJ4/XoXIx0zktk2bNqFXr17Q19fnnaJC1OMm8jHj2Zaeno7c3FwUFxcrbe/Zs6fkLRVGjBiBHTt2wMTEBI0bNwYApKSkoKCgAH5+fkhLS8O1a9cQFxeHli1bStYVFxeHr776CnPnzlVacG/WrFn4+uuvYWxsjDFjxuCjjz5SfLoulXbt2ilea1e8Oc/KyoK6ujrc3d1x6dIlyGQyJCQkoH79+pK2ie7atWtYtWoVLl26BKB8gGPMmDFwdHTk1qSmpvbC2Vw8L7MqcpsQjwNGXomrqyvbsGFDtfvPnj3L1NTUJCyqmpOTE0tNTeWdoULUrgopKSksKCiIWVhYMBMTEzZ27Fh2+vRp3lnCdjFGbW9KxLaLFy+ycePGMW9vb2Ztbc2sra2Zt7c3GzduHLt48SLXthe5cuUKa9euHZf7vnHjBtuwYQP7448/2LNnz5T2FRYWstDQUC5djDF24MABNnv2bBYXF8cYY+zo0aOsS5curF27dmzt2rXcuhhjLD09na1du5ZlZGQwxhjLyMhgY8eOZSNHjlT08iLqcRP5mD1+/JgdP368yueJJ0+esPXr13Oo+ld2djbz8vJiMpmMqampKf5vxRdPM2bMYOPGjWNlZWWKbWVlZeyLL75g//d//8fkcjn77LPPWMuWLSXt+uCDD1hiYqLK9oSEBFa/fn3GGGMHDx5kderUkbSLMcYWL17M+vTpwx48eKDYVlBQwPr168eWLFnCioqKWK9evZifn5/kbX///TdbsWIFmzFjBgsODlb6IlXbsWMHc3NzY1FRUezcuXPs3LlzLCoqinl4eLAtW7awjRs3stq1a7MpU6ZQWyUiPA5oAOEVDRkyhE2aNKna/ampqUwmk0lYVLWoqCjWrVs3du/ePd4pSkTtel5xcTH77bff2Mcff8w0NTWZp6cnW7JkCSsoKKAuansv2/bs2cO0tLRYs2bNWEhICPvxxx/Zjz/+yEJCQliLFi2YtrY227dvn6RNryo1NZXLm4DTp08zExMTZmRkxHR1dZmLiwu7cOGCYv+tW7e4vTnZsGED09DQYI0aNWIGBgYsOjqamZiYsMDAQBYQEMC0tLTYr7/+yqVt7969TEtLi5mZmTEdHR22d+9eZmlpyTp27Mjat2/P1NXVub0hFvW4iXzMLl26xBwcHBRvytu0acNu3Lih2M/zcVDh448/Zr169WJ37txhBgYG7OLFi+z48ePsww8/ZMeOHePaZmFhwS5duqSy/dKlS8zc3Jwxxti5c+eYsbGxpF06Ojrs/PnzKtvPnTvHdHR0GGOMXbt2jenq6kraxRhjtra2VQ5WXbhwgdna2jLGGDtz5ozi+Enl0KFDTE9PjzVo0IBpaGgwb29vZmJiwoyNjbkNclelqKiIZWRksLS0NKUvXpo2bVrl64t9+/axpk2bMsYYi42NZc7OzlKnCd0mwuOABhBe0c2bN9m1a9d4Z7yUt7c3MzAwYNra2szV1ZX5+PgofVHXiz179oxt2bKF+fn5MQ0NDdamTRvm4uLCDA0N2ZYtW6iL2t67Ni8vLzZr1qxq94eEhDBPT0/JeipbunTpC7+mT5/O5Q1Kx44d2ciRI1lZWRl7+PAhGzduHDM3N2cpKSmMMb5vnLy9vdnSpUsZY+UvanV1ddmiRYsU+xcuXCj5J5oVmjdvzr766ivGGGObN29mpqam7Msvv1TsnzlzJuvUqROXNlGPm8jH7JNPPmHdu3dnd+7cYZcvX2bdu3dnTk5O7K+//mKMiTGAYG5urniDZGRkxDIzMxljjMXFxTFvb2+eaczExITt3LlTZfvOnTuZiYkJY4yxrKwsxb+l0rJlS9alSxd2+/Ztxbbbt2+zLl26sNatWzPGymcguLq6StrFGGP6+vrsyJEjKtuPHDnCDAwMGGPls04MDQ0l7WratCmbPXs2Y4wxAwMDlp2dzR49esR69uzJfvzxR0lbqnL79m3WvXt3pdk3IszE0dHRUcysqiwjI0MxWHX16lUug1Uit4nwOKABhBqyadMmVlhYKPn9fvPNNy/84kXUrgrJycls/PjxzMzMjNnY2LAZM2awy5cvK/ZHREQwKysr6qK2965NR0dH8aK6KpmZmYo/llKTyWTM1taWOTo6Vvlla2vL5cWPqampyieH8+bNY6ampuz06dNc3zjp6+uznJwcxfeamppKnzBlZGRI/ulcBSMjI8XvellZGdPQ0FAMujDG2Pnz51mtWrW4tIl63EQ+ZlZWVuzcuXOK7+VyORs7diyzt7dn2dnZQgwgmJiYKH6uzs7O7PDhw4yx8tOfeLzwr6ziVLZFixax48ePs+PHj7NFixYxCwsLNmHCBMYYY6tXr5Z84CozM5O5ubkxLS0tVrduXVa3bl2mpaXF3N3dFc97sbGxLCYmRtIuxspnAzs5ObHt27ezv//+m/39999s+/btzNnZmX366aeMsfKBtsaNG0vaZWBgwK5cucIYK/+dq5iRlpqayhwcHCRtqcqQIUNYy5YtWVJSEtPX12cHDhxgGzZsYG5ubuz333/n1uXt7c2GDx+udBpgcXExGz58uGKALyEhgTk6OlJbJSI8DmgAoYYYGhqy7Oxs3hnkFVRMOevWrRuLjY1lpaWlKre5c+eO5KeoiNpFbe9Xm7u7OwsPD692f3h4OHNzc5OspzJHR0f2yy+/VLuf19ozpqamVU77/OGHH5iJiQnbvn07tzdOJiYmSgNCFZ+GVcjJyWF6eno80piRkZHiRTZjqm3Xrl3jNlgl6nET+ZgZGhqy9PR0le3jx49ntWvXZseOHeM+gNCqVSsWGxvLGGNs8ODBrEuXLiwhIYH5+/uzDz74gGtbaWkp++6775i1tTWTyWRMJpMxa2trNnfuXMXfhr/++ov9/fffkreVlZWxvXv3KmZ77du3T2mtBl4ePXrEAgMDmZaWluLTcy0tLTZ69GjFh3Znz55lZ8+elbSrVq1aiseCh4eHYmZJamoq09fXl7SlKtbW1uzPP/9kjJU/bisGgnbu3MltRhpjjCUmJjJzc3NmaWnJOnTowDp06MCsrKyYubk5O3nyJGOMsZiYGLZgwQJqq0SExwFdxrGGMM4Xtzhz5gwyMjIAAB988AF8fHy49lQQsWvAgAEICAiAnZ1dtbexsLCAXC6XsErcLoDa3pSIbXPmzMGQIUMQHx+Pjh07olatWgCAvLw8xMXFYd++fdi0aZNkPZU1btwYZ86cwYABA6rcX9WlxqTQoEEDnDhxQnFd+QpTp06FXC7H4MGDJW+q4OLigszMTMXKzNevX1dcrg4AsrOzUbt2bS5tjo6OuHz5MurWrQsAOHnyJOzt7RX7c3NzYWNjw6VN1OMm8jFzd3dHcnIyPDw8lLYvX74cAN8rHFT4+uuvUVRUBKD8ue7jjz9G69atYW5ujl9++YVrm7q6Or766it89dVXePjwIQCoXOmr8s9aSmpqaujSpQu6dOnC5f6rY2BggNWrV2Px4sXIyckBADg7O8PAwEBxG29vb8m7mjVrhoSEBHh4eKBbt26YMmUKzp8/j+3bt6NZs2aS9zyvqKgIVlZWAABTU1PcuXMHrq6u8PT0REpKCrcukS+zKnKbCI8DGkB4z9y+fRuDBg1CfHw8TExMAAAFBQVo164dtmzZAktLS+qqpKSkBOvWrUO/fv1e+KZOaqJ2AdT2pkRt69+/P+zs7BAREYHw8HDcunULQPl1rZs3b474+Hg0b96cS9ucOXPw+PHjavfXr18fV69elbConL+/P44ePYqxY8eq7Js+fToYY1i5cqXkXQDw5ZdfKl2b/fk3JMnJydUOyNS0cePGKV3q+PnL+u7duxft27eXOguAuMdN5GPWu3dvbN68ucoX0cuXL4dcLuf2OKjQuXNnxb8rBony8/Nhamr6wku0Sa26S4RLJSIiAp999hl0dHQQERHxwttOmDBBoqrqGRgYqAzg8rRo0SIUFhYCAEJDQ1FYWIhffvkF9erVw6JFizjXlV+y8dKlS3B0dETDhg2xatUqODo6YuXKldwGICsYGhpW+bdUBCK3AXwfBzLG+6Py95ShoSHS0tLg7Ows6f0OHDgQOTk5iImJUXwqkJ6ejuHDh8PFxQWbN2+WtEf0LgCws7PDoUOHVD5F4U3ULoDa3pTIba8qMTERTZo0gba2Nu8UFaK2idoFiN32zz//wNbWFmpqarxTVIh63EQ+ZiK3SaVRo0aIi4uDqakpfHx8XjiIIeUnw05OTkhOToa5uTmcnJyqvZ1MJlN84imVPn36YN26dTAyMkKfPn1eeNvt27dLVPVmNm/ejJ49e0JfX1/S+924cSNKS0sxYsQInDlzBl26dEF+fj60tLSwbt06DBw4ULKWXbt2oWvXrtDU1MSuXbteeFupZzGJ3Cba44AGEGoIrwEEY2NjHDp0CE2bNlXafvr0afj5+aGgoEDSHtG7ACAsLAxZWVmIioqChoY4k3JE7QKo7U2J3PaqjIyMkJqaKvlz26sQtU3ULoDa3pSobaJ2AWK3SSU0NBTTpk2Dnp4eQkNDX3jbkJAQiarENnLkSERERMDQ0BAjR4584W2jo6MlqnozojwGHj9+jMzMTNjb28PCwkLS+1ZTU8OtW7dgZWX1wsFEmUymNPtKCiK3ifY4eDdfwZJqyeVyaGpqqmzX1NTkcs53BVG7ACApKQlxcXE4cOAAPD09VUaGeY1oi9oFUNubErntVYk85ixqm6hdALW9KVHbRO0CxG6TSuVBAdEHCIqLi3H16lXUrVuX64B35TdDog8QvIwojwE9PT00atRIZbsUAxyVX/Pzfv3/PJHbRHsc0ADCaygrK0NiYiK8vLwU5/FXx8HBoco3zDWtffv2mDhxIjZv3gxbW1sA5YtBBQcHo0OHDpL3iN4FACYmJujbty/XhqqI2gVQ25sSuY0QQoi0CgoKsG3bNmRnZ2PatGkwMzNDSkoKatWqxW2tnMePHyMoKAjr168HAGRlZcHZ2RlBQUGws7PDzJkzuXRVKC0tRXx8PLKzsxUL2t24cQNGRkZKi8iR18dzgOPp06fQ0dHhdv8vImIb98dBjV3f4T2lra2tdK1o0eTm5jJvb2+mqanJnJ2dmbOzM9PU1GQ+Pj5cLgUkehch5PU8fxk5kYjaJmoXY9T2pkRtE7WLMbHbeEhLS2OWlpbMxcWFaWhoKI7NV199xYYNG8ata8KECaxx48bs+PHjTF9fX9G1Y8cO5u3tza2LsfLLlrq7uzM9PT2mrq6uaJswYQIbM2YM17ZXIfpjQOq+0tJSNmfOHGZra6v08/z6669ZVFSUZB3vWpsIj4P/7ko2b6hBgwaSLyDzOurUqYOUlBT88ccfmDRpEiZNmoQ9e/YgJSWF26W7RO4CymdHVLUGw8OHD7mtbg2I2wVQ25sSuY0QQoh0Jk+ejBEjRuDy5ctKn25269YNx44d49a1Y8cOLF++HK1atVJa5PGDDz5AdnY2ty4AmDhxIpo0aYL79+9DV1dXsb13796Ii4vjWEbexNy5c7Fu3TosWLAAWlpaiu0NGjRAVFQUxzKx20R4HNApDK/pu+++w9SpU/Htt9+icePGKucw874UD1C+uEenTp3QqVMn3ilKRO2Kj49HcXGxyvanT5/i+PHjHIrKidoFUNubErntVYl06bPnidomahdAbW9K1DZRuwCx23hISkrCqlWrVLbb2dkpLqfLw507d2BlZaWyvaioiPvP8Pjx4zhx4oTSGzoAcHR0xPXr1zlVkTcVExODyMhIdOjQQelyiQ0bNkRmZibHMrHbRHgc0ADCa+rWrRuA8st3VH4iZYxxWZUTwEuv2VuZlNfvFbWrwrlz5xT/Tk9PV/qDXVZWhn379nE5B1HULoDa3pTIba+LCbIIVFVEbRO1C6C2NyVqm6hdgNhtPGhra+Phw4cq27OysmBpacmhqFyTJk3wxx9/ICgoCMC/Az9RUVFo3rw5ty6gfGG7ql5n//PPPzA0NORQ9G6sj/aqpB4gun79OlxcXFS2y+VylJSUSNryPJHbRHgc0ADCazpy5AjvBBWLFy9+pdvJZDJJ36iL2lXB29sbMpkMMpmsyunjurq6WLZsGXVVQm1vRuS2CiEhIQgICICDg8MLb/fo0SOJiv4lapuoXYDYbdHR0Rg4cCD09PReeLv09HTFortSEfW4iXzMRG4TWc+ePTFnzhxs3boVQPlrodzcXMyYMYPrYrthYWHo2rUr0tPTUVpaiqVLlyI9PR0nTpzA0aNHuXUBgJ+fH5YsWYLIyEgA5cessLAQISEhig/4pKaurg4/Pz9kZGS8dADhwoUL0kS9IakH+erXr4/jx4+rPN9u27YNPj4+krY8T+Q2IR4Hkqy0QIiArl27xq5evcpkMhlLSkpi165dU3zduHGDlZaWUhe1vfdtFRo2bMjU1dVZ+/bt2c8//8yePn3KO0lB1DZRuxgTu83KyooZGhqygIAAlpiYyDtHiajHTeRjJnKbyAoKCljHjh2ZiYkJU1dXZ3Xq1GGampqsdevWrLCwkGtbdnY2CwwMZE2bNmUeHh5s6NCh7Ny5c1ybGGPs77//ZvXr12ceHh5MQ0ODNWvWjJmbmzM3NzeWl5fHratx48bs0KFD3O7/bTl+/Likz3k7duxgxsbGbP78+UxPT4/98MMPLDAwkGlpabEDBw5I1vGutYnwOKABhDdw7NgxNnToUNa8eXP2zz//MMYYi4mJYcePH+dcpkwulzO5XM47Q4WoXYT816WkpLCgoCBmYWHBTExM2NixY9np06d5ZzHGxG0TtYsxcdtKSkrY9u3bWc+ePZmmpiZzc3Nj8+fPZzdv3uSdxhgT87iJfMxEbnsXJCQksBUrVrDvv/+eHTx4kHcOGzZsGFu7di27cuUK75QqlZSUsA0bNrBp06axcePGsdWrV7PHjx9zbdq7dy/z9vZmu3fvZjdu3GAPHjxQ+uLp4sWLbNy4cczb25tZW1sza2tr5u3tzcaNG8cuXrzItY2x8vdUHTt2ZJaWlkxXV5e1bNmS7d+/n3cWY0zsNt6PAxljdFLa6/jtt98wbNgwDB06FBs2bEB6ejqcnZ2xfPly7NmzB3v27OGdiJiYGPzwww+4fPkyAMDV1RXTpk3DsGHDqKsaly9fxpEjR3D79m3I5XKlfbNnz+ZUJW4XQG1vSuS2CiUlJdi9ezeio6Oxf/9+uLu7Y9SoURgxYgSMjY2p7R3qEr0tLy8PGzduxPr165GZmYkuXbpg1KhR6NGjB9TU+F4oStTjJvIxE7lNRHFxcYiLi6vy78HatWu5NAUGBuLYsWPIzs6Gra0tfH190bZtW/j6+qJevXpcmkRX+XdblPXRAGDv3r345JNP0KhRI3Tu3Bm1atUCUP44PXjwIM6cOYOdO3eic+fOXPrIu4sGEF6Tj48PgoOD4e/vD0NDQ6SlpcHZ2Rlnz55F165dua6cCwCLFi3CrFmz8MUXX6Bly5YAgISEBKxYsQLfffcdgoODqes5q1evxrhx42BhYQFra2ulJ3+ZTIaUlBTqorb3vq2y4uJixMbGYu3atTh8+DBatGiBGzduIC8vD6tXr8bAgQOp7R3pEr0NAP7880+sXbsW69evh42NDe7fvw9TU1NER0ejbdu23LpEPm6iHjPR20QSGhqKOXPmoEmTJrCxsVFZwC42NpZTWbnr16/j2LFjOHr0KI4ePYqsrCzY2Njgn3/+4dZkb2+vGMxo164dnJ2dubVU9rK1IXx9fSUqUdawYUP06tULc+bMqXL/N998g+3btyst9Cyl2bNno127dmjevLnSpUxFIHIbIMCHUZLNdXhP6OrqsqtXrzLGGDMwMGDZ2dmMsfLzxbS1tTmWlXN0dGTr169X2b5u3Trm6OjIoaicqF2MMWZvb8/mz5/PtaEqonYxRm1vSuQ2xhhLTk5m48ePZ2ZmZszGxobNmDGDXb58WbE/IiKCWVlZUds70CV6261bt9gPP/zA6tevz3R0dNigQYMU07cLCwvZ9OnTmb29PZc2UY+byMdM5DZRWVtbs5iYGN4Z1SoqKmL79+9nM2fOZM2aNWNaWlrM29uba9OGDRvY6NGjWb169ZhMJmO1a9dmQ4cOZZGRkSwrK4trm4h0dHRYZmZmtfszMzOZjo6OhEXKOnbsyPT19Zm2tjZr1aoV++qrr9jBgwe5n5IieltkZCRTV1dntWrVYg0bNmTe3t6KLx8fH0kaaADhNTk5OSn+KFYeQFi/fj3z8PDgmcYYY0xbW1vphU6FrKwsrgMconYxxpihoaHi5ygSUbsYo7Y3JXJbgwYNmIaGBuvWrRuLjY2tcmHHO3fuMJlMRm2Cd4ne9vHHHzNNTU32wQcfsMWLF7N79+6p3CYvL4+OWyUiHzOR20RmZmYm5DoD//d//8eaN2/OdHR0mI+PD5s0aRLbsWMHy8/P552m5MaNG2zz5s1s6NChTENDg6mpqXHtEXF9NHd3dxYeHl7t/vDwcObm5iZhkaqSkhKWkJDAwsLCWOfOnZmhoSHT0tJiLVu25NolcpsIH0bRZRxf0+jRozFx4kSsXbsWMpkMN27cwMmTJzF16lTMmjWLdx5cXFywdetWfPnll0rbf/nlF67nronaBQD9+/fHgQMHMHbsWK4dzxO1C6C2NyVy24ABAxAQEAA7O7tqb2NhYaEyVU4KoraJ2gWI3WZlZYWjR4++8JrylpaWuHr1qoRV5UQ9biIfM5HbRBYYGIhNmzYJ8dqxsvnz58PS0hIhISHo06cPXF1deScpefz4MRISEhAfH48jR47g7NmzaNCgAdfTYyqvj5aSkoJnz54BAB48eICwsDBu66PNmTMHQ4YMQXx8PDp27Ki0BkJcXBz27duHTZs2cWmroKGhgZYtW8LS0hJmZmYwNDTEjh07kJmZybVL5Lb79++jf//+XBtoAOE1zZw5E3K5HB06dMDjx4/Rpk0baGtrY+rUqQgKCuKdh9DQUAwcOBDHjh1TrDWQmJiIuLg4xbWGqUuZi4sLZs2ahVOnTsHT0xOamppK+ydMmEBdz6G2NyNqW0lJCdatW4d+/fq98I0TD6K2idoFiN927do1WFhYvPB2MplM5frbNU3U4yb6MRO1TUSTJ09W/FsulyMyMhKHDh2Cl5eXyt+DRYsWSZ0HADh79iyOHj2K+Ph4hIeHQ0tLS7GQYtu2bbkOKLRo0QJnz56Fh4cH2rZti5kzZ6JNmzYwNTXl1gQA3333HVauXAl/f39s2bJFsb1ly5b47rvvuHX1798fdnZ2iIiIQHh4uGKdNmtrazRv3hzx8fEvHPiraZGRkYiPj8fRo0fx7NkztG7dGm3btsXXX38NLy8vbl2it4nwYRQtoviGiouLceXKFRQWFqJ+/fowMDDgnaRw5swZLF68GBkZGQAADw8PTJkyBT4+PtRVBScnp2r3yWQy5OTkSFjzL1G7AGp7UyK32dnZ4dChQ/Dw8ODWUB1R20TtAsRus7S0xIkTJ7jPPquKqMdN5GMmcpto2rVr90q3k8lkOHz4cA3XvJq0tDQsXrwYP//8M+RyObcrCgCAmZkZ1NTU4OfnJ8SARgU9PT2kp6fD0dFRaYH1nJwc1K9fH0+fPuWd+EoSExPRpEkTaGtrS3J/ampqsLS0xJQpU/D5558L9V5KtLaIiAjFv4uKirBo0SJ0796d24dRNIBACCEEYWFhyMrKQlRUFDQ0xJqcJmqbqF2A2G3BwcHQ1tbG/PnzeaeoEPW4iXzMRG4jr48xhrNnzyI+Ph7x8fFISEjAw4cP4eXlBV9fXyxevJhr2/nz5xWfDB87dkwxQ6Jdu3YYPXo0ly5nZ2dERkaiY8eOSgMIMTExmD9/PtLT07l0vS4jIyOkpqZKdnWLHTt24NixY4iPj0dGRgZ8fHwUA0OtWrWCnp6eJB3vQtuLPoCqTKoPo2gA4RX06dPnlW+7ffv2Gix5uT179kBdXV3lmq779++HXC5H165dqYsQoqJ3796Ii4uDgYEBPD09oa+vr7Sf53ObqG2idgFitwUFBSEmJgb16tVD48aNVdp4Td0GxD1uIh8zkdvI6zM1NUVhYSEaNmyoOHWhdevWMDEx4Z2mhDGGM2fOYPny5dxnR8ybNw8bN27E2rVr0alTJ+zZswd//fUXgoODMWvWLCFOcX4VlQc/pPbgwQMcP34cv/76KzZv3gw1NTVhZm6I3MaLOMPrAjM2Nlb8mzGG2NhYGBsbo0mTJgDKp+YXFBS81kBDTZk5c2aVnwIwxjBz5kxub9RF7QKAgICAF+5fu3atRCXKRO0CqO1NidxmYmKCvn37crv/FxG1TdQuQOy2CxcuoFGjRgCArKwspX0ymYxHkoKox03kYyZyG3l9GzduROvWrWFkZMQ7RUVKSorSzIhHjx7B09MTQUFB8PX15dYl+vpoIrt3755izY34+HhcvHgRpqamaN26Ne80odteRU3OKKEZCK9pxowZyM/Px8qVK6Gurg4AKCsrw+effw4jIyP88MMPXPt0dXWRkZEBR0dHpe3Xrl3DBx98gKKiIup6Tu/evZW+LykpwYULF1BQUID27dtz/XRTxC6A2t6UyG2EEEKIyDQ0NODj4wNfX1/4+vqiTZs2Sh/y8Sby+mivQuoZCJ6ensjIyICpqSnatGmDtm3bwtfXl/sihaK3vaqa/HnSDITXtHbtWiQkJCgGDwBAXV0dkydPRosWLbgPIBgbGyMnJ0fljfqVK1dUphVKSdQuAIiNjVXZJpfLMW7cONStW5dDUTlRuwBqe1MitxFCCCEiy8/Pf6WZEZs3b0bPnj0lf32ppaWF+vXrS3qf77KxY8fC19cXDRo04J2iQuQ2EdAMhNdkamqKdevWoVevXkrbd+7ciREjRuD+/fucysqNGTMGJ0+eRGxsrOINyZUrV9C3b180bdoUUVFR1PWKLl26hLZt2+LmzZu8U5SI2gVQ25sSpW3btm3YunUrcnNzUVxcrLQvJSWFU1U5UdtE7QLEbktOTq62jfdMHFGPm8jHTOQ28t8jxWKA79L6aK9K6kUUX5WoXYDYbTU5A0Htrf8X33MjR47EqFGjsGjRIiQkJCAhIQHh4eEIDAzEyJEjeedhwYIF0NfXh7u7O5ycnODk5AQPDw+Ym5tj4cKF1PUasrOzUVpayjtDhahdALW9KRHaIiIiMHLkSNSqVQtnz57Fhx9+CHNzc+Tk5HBf5FTUNlG7RG/bsmULWrRogYyMDMTGxqKkpAQXL17E4cOHuU9HFvW4iXzMRG4j/01SfDZqbGys+DIyMkJcXBySk5MV+8+cOYO4uLh36jEg6mfKonYBYrfVJDqF4TUtXLgQ1tbWCA8PV3xaaGNjg2nTpmHKlCmc68qf0E6cOIGDBw8iLS0Nurq68PLyQps2bairGpMnT1b6njGGmzdv4o8//sDw4cM5VYnbBVDbmxK57ccff0RkZCQGDx6MdevWYfr06XB2dsbs2bORn59Pbe9Ql+htYWFhWLx4McaPHw9DQ0MsXboUTk5OGDNmDGxsbLi2iXrcRD5mIrcRUlOio6MV/54xYwYGDBhQ7fpovIWEhCAgIAAODg4vvN2jR48kKiJSqMlFbOkUhv/Bw4cPAUCIJwegfEE2XV1dpKamCnXOjqhdFdq1a6f0vZqaGiwtLdG+fXsEBARwuxa4qF0Atb0pkdv09PSQkZEBBwcHWFlZ4eDBg2jYsCEuX76MZs2a4d69e9T2jnSJ3qavr4+LFy/C0dER5ubmiI+PVyxY1b59e66n8oh63EQ+ZiK3kf8mqRcDtLS0REJCAtzc3JS2X7p0CS1atOD6fAsA3t7euHDhAnx9fTFq1Cj07dsX2traXJteB8/LS77Mf7WNZiD8D0QZOKigqakJe3t7btfBrY6oXRWOHDnCO6FKonYB1PamRG6ztrZGfn4+HBwcYG9vj1OnTqFhw4a4evUq9yl6oraJ2iV6m6mpqeKTLjs7O1y4cAGenp4oKCjA48ePubaJetxEPmYitxEihdLSUmRmZqoMIGRmZkIul3Oq+ldqairOnj2L6OhoTJw4EePHj8egQYMQEBCApk2b8s4jNWTv3r2ws7Orkf82rYHwmvLy8jBs2DDY2tpCQ0MD6urqSl+8ffXVV/jyyy+5T1F9nqhdld25c0exrsWdO3d45yiI2gVQ25sSsa19+/bYtWsXgPK1XoKDg9GpUycMHDhQ5fKT1CZ2l+htbdq0wcGDBwEA/fv3x8SJEzF69GgMHjwYHTp04Nom6nET+ZiJ3EaIFERfHw0AfHx8EBERgRs3bmDNmjX4559/0LJlS3h5eWHp0qV48OAB78Rq1eRU/P+V1G03b97Exo0bsWfPHpUFa4uKijBnzhzF961ataqxmSZ0CsNr6tq1K3Jzc/HFF1/AxsZG5Rfn+aszSM3HxwdXrlxBSUkJHBwcVC5hw2sFaVG7gPIHXFBQEGJiYhQjxerq6vD398eyZcugp6dHXdT23rfJ5XLI5XLFaRRbtmzBiRMnUK9ePYwZMwZaWlrU9o50id6Wn5+Pp0+fwtbWFnK5HAsWLFC0ff311zA1NeXWJupxE/mYidxG/psaNGiAvXv3ok6dOpLcn1wux8KFC7F06VKl9dEmTpyIKVOmCPEBY4Xi4mLExsZi7dq1OHz4MFq0aIEbN24gLy8Pq1evxsCBA3knqvivnibwvKSkJPj5+UEul6OkpAR2dnbYsWMHPvjgAwDlH3Lb2tpKMuObBhBek6GhIY4fPw5vb2/eKVUKDQ194f6QkBCJSpSJ2gWUX2Ly0KFDWL58OVq2bAkASEhIwIQJE9CpUyf89NNP1EVt730bIYQQIjJnZ2ckJSXB3NxcaXtBQQEaNWqEnJwcTmX/Em19tApnzpxBdHQ0Nm/eDG1tbfj7+yMwMBAuLi4AgGXLluG7775DXl4e51JVCQkJaNq0qZDrNkjZ1qlTJ9SpUwdRUVEoKirCjBkzsHXrVhw8eBA+Pj40gCCy+vXr4+eff4aPjw/vFPKWWFhYYNu2bWjbtq3S9iNHjmDAgAHcppiL2gVQ25sSuQ0ofxF2+vRp3L59W+W8TX9/f05V5URtE7ULELtNLpfjypUrVbbxvjqPqMdN5GMmcht5f6ipqeHWrVuwsrJS2p6Xlwd7e3s8e/aMU5nYPD09kZmZCT8/P4wePRo9evRQmRVx9+5dWFlZSbZmw8GDB5GQkABfX1+0b98ex44dw7x58/Ds2TMMGzaM66kfN2/eRFxcHMzMzNCxY0elmWdFRUUIDw/H7NmzJe8yMzPDqVOn4Orqqtg2f/58LFiwAPv374e9vb1kAwi0iOJrWrJkCWbOnIlVq1bB0dGRdw55Cx4/foxatWqpbLeysuK6AJSoXQC1vSmR23bv3o2hQ4eisLAQRkZGSqdnyWQyrm+cRG0TtUv0tlOnTmHIkCH466+/VBYmlMlkXBfcFfW4iXzMRG4j74eKdUkAYP/+/TA2NlZ8X1ZWhri4OK6vyfPy8jB16lTExcXh9u3bKo8D3o+BAQMGICAg4IUL6llYWEg2eLBx40aMHDkSXl5eWLRoEZYtW4bg4GD069cPcrkcY8eOhaGhIfr16ydJT2UvO02gsLAQoaGhXAYQAODp06dK38+cORMaGhrw8/PD2rVrJeugGQivydTUFI8fP0ZpaSn09PSgqamptJ/HIoFmZmbIysqChYUFTE1NX7igh5R9onY9r0OHDjA3N0dMTAx0dHQAAE+ePMHw4cORn5+PQ4cOURe1vfdtrq6u6NatG8LCwriuxVAVUdtE7QLEbvP29oarqytCQ0OrXEuo8psDqYl63EQ+ZiK3kfeDmlr5mu8ymUzlzbmmpiYcHR0RHh6Ojz/+mEee0OujlZSUwN3dHb///js8PDy4dVTm4+ODkSNHYsKECYiLi0OPHj0wd+5cBAcHAwDCw8MRGxuLhIQEydtEOk3geW3atMGQIUMwduxYlX0LFizA7NmzUVJSQqcwiGj9+vUv3D98+HCJSv61fv16DBo0CNra2kL1idr1vPPnz6NLly549uwZGjZsCABIS0uDtrY2Dhw4oBh1pC5qe5/b9PX1cf78eSEXKRK1TdQuQPy2tLQ0xbm3IhH1uIl+zERtI+8XJycnJCUlwcLCgneKEtHXR7Ozs8OhQ4eEGUAwMDDA+fPn4eTkBADQ0tJCcnIyvLy8AJRf/rJVq1a4e/eu5G0inSbwvKioKBw9ehQbNmyocv/333+PlStX4urVqzXeQgMIhKB8avnPP/+MzMxMAICHhweGDh0KXV1d6qoGtb0ZUdv69OmDQYMGYcCAAVw7qiJqm6hdgNht7du3x/Tp09GlSxfeKSpEPW4iHzOR2wiRgujro4WFhSErKwtRUVGKK8zwZGpqilOnTsHNzQ2A6pUMrl69igYNGqCoqEjyNjMzM8THxysGMyosXLgQc+fOxdq1a9GvXz/up6W8isTERDRp0qRGFnjk/1v0DsrOzkZ0dDSys7OxdOlSWFlZYe/evbC3t+f6CeLznj59qnKNUBFWhRWta968eahVqxZGjx6ttH3t2rW4c+cOZsyYQV3PobY3I3Jb9+7dMW3aNKSnp8PT01Pl9KyePXtyKhO3TdQuQOy2oKAgTJkyBbdu3aqy7fkXblIS9biJfMxEbiPvn7i4OMVaA8+fsy/lOeCVib4+WlJSEuLi4nDgwAF4enqqXEp9+/btkva4uLggMzNTMYBw/fp1GBoaKvZnZ2ejdu3akjZVaNCgAU6cOKHyvDV16lTI5XIMHjyYS9eb6Nq1K1JTU2tkRh3NQHhNR48eRdeuXdGyZUscO3YMGRkZcHZ2xvz585GcnIxt27Zx7at8vs69e/dU9vMaMRO1CwAcHR2xadMmtGjRQmn7n3/+iUGDBkkyFehd6gKo7U2J3FZxjmlVeC+EJmqbqF3Au9dWcW6ziG0VRPtdE/mYidJG3i+hoaGYM2cOmjRpUuVaA7GxsVy6RFwfrbKXXdEgOjpaopJysbGxMDc3r/YKLfPnz0dRURG+/fZbSbsAsU4T+F89P7PjbaIBhNfUvHlz9O/fH5MnT1b6wZw+fRp9+vTBP//8w7Vv/PjxOHLkCL799lsMGzYMK1aswPXr17Fq1SrMnz8fQ4cOpa7n6OjoICMjQ3EuVoWcnBzUr19fZcXT/3oXQG1vSuQ2QqTy119/vXC/g4ODRCXvDpGPmcht5P1iY2ODBQsWYNiwYbxTlIi8ztf7oCan4v+vRG6ryQEEOoXhNZ0/fx6bNm1S2W5lZcVlsY/n7d69GzExMWjbti1GjhyJ1q1bw8XFBQ4ODvj555+5vVEXtQsA6tSpg8TERJU3dYmJibC1teVUJW4XQG1vSuQ2QqRCbyhfn8jHTOQ28n4pLi5WmcEnAhogqFk1ORX/fyVyW02iAYTXZGJigps3b6q8ATh79uwLr68qlfz8fMUvsZGRkWLaVKtWrTBu3DjqqsLo0aMxadIklJSUoH379gDKz7GbPn06pkyZQl3U9t62RURE4LPPPoOOjg4iIiJeeNsJEyZIVFVO1DZRuwCx23bt2oWuXbtCU1NT6ZruVZF6nQFRj5vIx0zkNvL+CgwMxKZNmzBr1izeKSpEXx9t27Zt2Lp1K3Jzc1XWIUtJSeFU9WpEniwvcluNYuS1TJkyhbVq1YrdvHmTGRoassuXL7OEhATm7OzMvvnmG955zNPTk8XHxzPGGOvQoQObMmUKY4yxpUuXMjs7O+qqglwuZ9OnT2c6OjpMTU2NqampMT09PRYaGkpd1PZetzk6OrK7d+8q/l3dl5OTE7UJ3iV6m0wmY3l5eYp/V/elpqYmeZuox03kYyZyG3m/BAcHK74mTpzITExMWJs2bdgXX3yhtC84OJhbY3x8PNPV1WUdO3ZkWlpaLDs7mzHG2Lx581jfvn25dVVYunQpMzAwYF988QXT0tJiY8aMYR07dmTGxsbsyy+/5J33UgYGBopjKhqR2wwNDWusjdZAeE3FxcUYP3481q1bh7KyMmhoaKC0tBRDhw7FunXroK6uzrVv8eLFUFdXx4QJE3Do0CH06NEDjDGUlJRg0aJFmDhxInVVo7CwEBkZGdDV1UW9evWEOZ9J1C6A2t6UyG3AvyPqzy9QJQJR20TtAsRuI4SQF2nXrt0r3U4mk+Hw4cM1XFM10ddHc3d3R0hICAYPHqzUN3v2bOTn52P58uVc+16mJs/l/1/9V9toAOEN/f333zh//jwKCwvh4+ODevXq8U6q0l9//YUzZ87AxcVFqEspidpFyH/ZmjVrsHjxYly+fBkAUK9ePUyaNAmBgYGcy8RtE7ULELvtXUADL4SQV2FgYIDz58/DyclJ6U3btWvX4O7uzn2BZD09PWRkZMDBwQFWVlY4ePAgGjZsiMuXL6NZs2ZVXh1NJP/VN+nVCQkJQUBAANf1Z2gNhNc0efJklW2nTp2CTCaDjo4OXFxc0KtXL5iZmXGoKyfiNXIBcbsIIcDs2bOxaNEiBAUFoXnz5gCAkydPIjg4GLm5uZgzZw61vSNdorcB5X8PFi9ejIyMDACAh4cHJk2ahI4dO3LtAsQdeBH5mIncRkhNE319NGtra+Tn58PBwQH29vY4deoUGjZsiKtXr74T5/CLPIjLo23nzp2YO3cufH19MWrUKPTt21fymaw0A+E1tWvXDikpKSgrK4ObmxsAICsrC+rq6nB3d8elS5cgk8mQkJCA+vXrS94n6jVyRe0ihJSztLREREQEBg8erLR98+bNCAoK4nqVGVHbRO0CxG778ccfMXHiRPTr108xuHHq1Cls27YNixcvxvjx47m1VTfwsnz5cgQHB3MbeBH5mIncRt4vvXv3rvINW+UP8YYMGaJ4fS6VqVOn4s8//8Svv/4KV1dXpKSkIC8vD/7+/vD390dISIikPc8LDAxEnTp1EBISghUrVmDatGlo2bIlkpOT0adPH6xZs4Zr38vQDARVZ8+eRXR0NDZv3ozS0lIMGjQIAQEBaNq0qTQBNbKywnts8eLFrE+fPuzBgweKbQUFBaxfv35syZIlrKioiPXq1Yv5+flx6bO2tmYxMTFc7vtFRO0ihJQzNjZmWVlZKtsvXbrEjI2NpQ+qRNQ2UbsYE7vNzs6OLVu2TGX78uXLma2tLYeif1lYWLBNmzapbN+0aRMzNzfnUFRO5GMmcht5vwwfPpwZGxszBwcH1qdPH9anTx/m6OjITExM2IABA5ibmxvT1tZmCQkJknY9e/aMBQYGMg0NDSaTyZimpiaTyWTs008/ZaWlpZK2VKWsrIyVlJQovt+8eTMLCgpiERER7NmzZ9y6Zs+eza5du8bt/l9E5LbKiouL2W+//cY+/vhjpqmpyTw9PdmSJUtYQUFBjd6vmjTDFO+PH374Ad9++y2MjIwU24yNjfHNN99gwYIF0NPTw+zZs3HmzBkufaJeI1fULkJIuWHDhuGnn35S2R4ZGYmhQ4dyKPqXqG2idgFitxUUFKBLly4q2/38/PDgwQMORf8qKSlBkyZNVLY3btwYpaWlHIrKiXzMRG4j7xdra2sMGTIEOTk5+O233/Dbb78hOzsbn376KerWrYuMjAwMHz4cM2bMkLRLS0sLq1evRk5ODn7//Xds3LgRly5dwoYNG7gvrg4Aampq0ND496z1QYMGISIiAkFBQdDS0uLWtXPnTtStWxcdOnTApk2b8OzZM24tzxO5rTL2/xekLy4uBmMMpqamWL58OerUqYNffvmlxu6XTmF4TQYGBvj999/Rtm1bpe3x8fHo0aMHHj16hJycHHh7e+Phw4eS982YMQMGBgbCXSNX1C5C/ssqr+lSWlqKdevWwd7eHs2aNQMA/Pnnn8jNzYW/vz+WLVtGbQJ3id5W2ZAhQ+Dj44Np06YpbV+4cCGSk5OxZcsWTmVAUFAQNDU1sWjRIqXtU6dOxZMnT7BixQouXSIfM5HbyPvF0tISiYmJcHV1VdqelZWFFi1a4O7duzh//jxat26NgoICybqqWh8NgFDroxUUFOD06dNVrkPm7+/PqUqAqfjvaNuZM2cUbdra2vD390dgYCBcXFwAAMuWLcN3332HvLy8Grl/GkB4TUOHDsXJkycRHh6u+AVKSkrC1KlT0aJFC2zYsAFbtmxR/OGUQuUnLrlcjvXr18PLywteXl7Q1NRUuu3zL4r+i12EkHIiXx5L1DZRuwCx2yIiIhT/fvjwIRYuXIiWLVsqnTOfmJiIKVOm4Ouvv5a0TdSBF5GPmcht5P1lamqK9evXo2fPnkrbd+3aheHDh+P+/fu4fPkyPvzwQ9y/f1+yLtHXR9u9ezeGDh2KwsJCGBkZKa0jIZPJkJ+fL3nT80pKSrB7925ER0dj//79cHd3x6hRozBixAgYGxtTWyWenp7IzMyEn58fRo8ejR49eqjMdLl79y6srKxUBoveFhpAeE2FhYUIDg5GTEyMYjqjhoYGhg8fjsWLF0NfXx+pqakAAG9vb0maRH3RKGoXIYQQaT2/Onl1ZDIZcnJyarhGmah/q0Q+ZiK3kffXhAkTsHnzZnz55ZdKH+KFhYVhyJAhWLp0KaKiorBu3TokJCRI1rVkyRIcP34c0dHRilOcHzx4gMDAQLRq1QqjR4/GkCFD8OTJE+zfv1+yrgqurq7o1q0bwsLCoKenJ/n9v4ri4mLExsZi7dq1OHz4MFq0aIEbN24gLy8Pq1evxsCBA6nt//v2228REBDA9QofNIDwhgoLCxV/FJ2dnWFgYMC5iBBCCCFS+Oeff2Braws1NVpKihCplJWVYf78+Vi+fLlianatWrUQFBSEGTNmQF1dHbm5uVBTU0Pt2rUl67Kzs8PBgwdVZhdcvHgRfn5+uH79OlJSUuDn58flCjj6+vo4f/68kFcx4D0V/11rKykpgbu7O37//Xd4eHhIdr/PowEEQgghhAjHyMgIqampQr7oFbVN1C5A7Dby7qlYZ6zyoua8iL4+Wp8+fTBo0CAMGDBA8vt+ERGm4r+LbXZ2djh06BDXAQSNl9+EEEIIIURaIn++IWqbqF2A2G3k3SPCwEGFXr16ISAgoMr10T755BMAwOnTp1UWf5RK9+7dMW3aNKSnp8PT01NlHbLn15SQyoABA146Fd/CwkLyN+iA2G3jx4/H999/j6ioKKWra0iJZiAQQgghRDiGhoZIS0sT8hNrUdtE7QLEbiPiatSoEeLi4mBqagofHx+lBQCfl5KSImHZv0RcH62yF51qJZPJUFZWJmFNOVGm4ldF5DYA6N27N+Li4mBgYABPT0/o6+sr7d++fXuNN9AMBEIIIYQQQohwevXqBW1tbQBQfJovGgMDA6xevRqLFy+udn00HgMHFXh8Sv4ympqaePr0Ke+MKoncBgAmJibo27cv1waagUAIIYQQ4Yj8ibWobaJ2AWK3EUKkFxYWhqysLK5T8asjcpsI6IgQQgghRDgvmqrMm6htonYBYreRd0dBQQG2bduG7OxsTJs2DWZmZkhJSUGtWrW4XtZONBEREfjss8+go6ODiIiIF952woQJElUpS0pKQlxcHA4cOMBtKn51RG4TAQ0gEEIIIUQ4Ik+QFLVN1C5A7Dbybjh37hw6duwIY2NjXLt2DaNHj4aZmRm2b9+O3NxcxMTE8E4UxuLFizF06FDo6Ohg8eLF1d5OJpNxG0AQYSp+dURuA4Bt27Zh69atyM3NRXFxsdI+KdYCoVMYCCGEECKchIQENG3aVHH+s0j+/vtv2NraqlzWizeRj5nIbeTd0LFjRzRq1AgLFixQOiXmxIkTGDJkCK5du8Y7UXgVb/toRtC7KyIiAl999RVGjBiByMhIjBw5EtnZ2UhKSsL48eMxd+7cGm+ofllOQgghhJC3KD09HZ9//jl8fHxgY2MDGxsb+Pj44PPPP0d6errSbVu1aiXMm83s7Gy0b99e8X2dOnUkGzy4efMmNm7ciD179qh80lRUVIQ5c+Yovpf6mL2rP0/ybkpKSsKYMWNUttvZ2eHWrVscit4da9asQYMGDaCjowMdHR00aNAAUVFRvLPIG/jxxx8RGRmJZcuWQUtLC9OnT8fBgwcxYcIEPHjwQJIGOoWBEEIIITVu7969+OSTT9CoUSP06tULtWrVAgDk5eXh4MGDaNSoEXbu3InOnTtzLlVVWFiIo0ePSn6/SUlJ8PPzg1wuR0lJCezs7LBjxw588MEHiq7Q0FDMnj1b8rZ3+edJ3k3a2tp4+PChyvasrCxYWlpyKHo3zJ49G4sWLUJQUBCaN28OADh58iSCg4ORm5urNAgpNd5T8V9E1Lbc3Fy0aNECAKCrq4tHjx4BAIYNG4ZmzZph+fLlNd5ApzAQQgghpMY1bNgQvXr1qvbF6jfffIPt27fj3LlzEpfhpYuMXb9+HQsXLpT8eumdOnVCnTp1EBUVhaKiIsyYMQNbt27FwYMH4ePjg7y8PNja2nK5jrvIP0/yfgoMDMS9e/ewdetWmJmZ4dy5c1BXV8cnn3yCNm3aYMmSJbwThWRpaYmIiAgMHjxYafvmzZsRFBSEu3fvcukSYSr+u9jm7OyM3377DT4+PmjSpAlGjx6NMWPG4MCBAxg0aBDy8/NrvIEGEAghhBBS43R1dZGamgo3N7cq91+6dAne3t548uSJxGWAmpoabGxsoKWlVeX+4uJi3Lp1S/I36mZmZjh16hRcXV0V2+bPn48FCxZg//79sLe35zaAIPLPk7yfHjx4gH79+iE5ORmPHj2Cra0tbt26hWbNmmHv3r0qK+WTciYmJkhKSkK9evWUtmdlZeHDDz9EQUEBly53d3eEhIRg8ODBSmtazJ49G/n5+ZJ8kv4utgUGBqJOnToICQnBihUrMG3aNLRs2RLJycno06cP1qxZU+MNdAoDIYQQQmqco6Mj/vjjj2rfcP7xxx9wcHCQuKqcg4MDvv/+ewwYMKDK/ampqWjcuLHEVeWePn2q9P3MmTOhoaEBPz8/rF27lksTIPbPk7yfjI2NcfDgQSQmJiItLQ2FhYVo1KgROnbsyDtNaMOGDcNPP/2ERYsWKW2PjIzE0KFDOVWJMRX/XWyLjIyEXC4HAIwfPx7m5uY4ceIEevbsWeUaITWBBhAIIYQQUuPmzJmDIUOGID4+Hh07dlQ6Zz4uLg779u3Dpk2buLQ1btwYZ86cqXYAQSaTcbkMYYMGDXDixAl4eXkpbZ86dSrkcrnKlGQpifzzJO+vuLg4xMXF4fbt25DL5cjMzFT8nvEcUBPN5MmTFf+WyWSIiorCgQMH0KxZMwDAn3/+idzcXPj7+/NKhLW1NfLz8+Hg4AB7e3ucOnUKDRs2xNWrV7lf9lXkNjU1Naip/XsdhEGDBmHQoEGSNtAAAiGEEEJqXP/+/WFnZ4eIiAiEh4crVk23trZG8+bNER8fr1jgS2pz5szB48ePq91fv359XL16VcKicv7+/jh69CjGjh2rsm/69OlgjGHlypWSdwFi/zzJ+yk0NBRz5sxBkyZNYGNjQ5cifIGzZ88qfV8xgyo7OxsAYGFhAQsLC1y8eFHytgrt27fHrl274OPjg5EjRyI4OBjbtm1TTMXnSeQ2ACgoKMDp06cVA2mVSTEoRGsgEEIIIUQ4iYmJaNKkiZCX/hO1TdQuQOw28m6wsbHBggULMGzYMN4p5C2Qy+WQy+XQ0Cj/PHvLli04ceIE6tWrhzFjxlS7Js1/vW337t0YOnQoCgsLYWRkpDSQJpPJaBFFQgghhPw3GRkZITU1Fc7OzrxTVIjaJmoXIHYbeTeYm5vj9OnTqFu3Lu8UQrhxdXVFt27dEBYWBj09PS4NdAoDIYQQQoQj8ucboraJ2gWI3UbeDYGBgdi0aRNmzZrFO4W8Jbyn4r+IqG3Xr1/HhAkTuA0eADSAQAghhBBCCBFQ5cUA5XI5IiMjcejQIXh5eUFTU1Ppts9fZYCI7WVT8Xm+SRe5rXPnzkhOTuY6m4sGEAghhBBCCCHCeX4xQG9vbwDAhQsXlLbTgorvnilTpiAgIIDrVPzqiNzWvXt3TJs2Denp6fD09FQZSOvZs2eNN9AaCIQQQggRjqGhIdLS0oQ8Z17UNlG7ALHbCCHS09fXx/nz54V8ThC5rfIlHJ8nk8lQVlZW8w01fg+EEEIIIa9J5E8URW0TtQsQu40QIr2KqfgiErmt4goRVX1JMXgA0CkMhBBCCBGQyBMkRW0TtQsQu40QIj0RpuJXR+Q2EdApDIQQQgiRTEhICAICAuDg4MA7RYWobaJ2AWK3EULEJcJU/OqI1hYREYHPPvsMOjo6iIiIeOFtJ0yYUOM9NIBACCGEEMl4e3vjwoUL8PX1xahRo9C3b19oa2vzzgIgbpuoXYDYbYQQ8j5wcnJCcnIyzM3N4eTkVO3tZDIZcnJyaryHBhAIIYQQIqmzZ88iOjoamzdvRmlpKQYNGoSAgAA0bdqUd5qwbaJ2id5GCCHvq4q38VKvMUMDCIQQQgjhoqSkBLt370Z0dDT2798Pd3d3jBo1CiNGjICxsTG1vUNdorcRQvgTbSp+ZSK3PW/NmjVYvHgxLl++DACoV68eJk2ahMDAQEnunwYQCCGEEMJFcXExYmNjsXbtWhw+fBgtWrTAjRs3kJeXh9WrV2PgwIHU9o50id5GCOFPtKn4lYncVtns2bOxaNEiBAUFoXnz5gCAkydPYvny5QgODsacOXNqvIEGEAghhBAiqTNnziimvGtra8Pf3x+BgYFwcXEBACxbtgzfffcd8vLyqE3wLtHbCCHi4zUV/1WI1mZpaYmIiAgMHjxYafvmzZsRFBSEu3fv1ngDDSAQQgghRDKenp7IzMyEn58fRo8ejR49ekBdXV3pNnfv3oWVlRXkcjm1CdwlehshRGy8p+K/iKhtJiYmSEpKQr169ZS2Z2Vl4cMPP0RBQUGNN2jU+D0QQgghhPx/AwYMQEBAAOzs7Kq9jYWFBZc3m6K2idoFiN1GCBFXdVPxg4ODkZubK8lU/HexbdiwYfjpp5+waNEipe2RkZEYOnSoJA00A4EQQgghkigpKYG7uzt+//13eHh48M5RImqbqF2A2G2EELGJMBW/OqK1TZ48WfHv0tJSrFu3Dvb29mjWrBkA4M8//0Rubi78/f2xbNmyGu+hGQiEEEIIkYSmpiaePn3KO6NKoraJ2gWI3UYIEVtJSQmaNGmisr1x48YoLS3lUPQv0drOnj2r0gEA2dnZAMpneVlYWODixYuS9NAMBEIIIYRIJiwsDFlZWYiKioKGhlifY4jaJmoXIHYbIURcQUFB0NTUVJmKP3XqVDx58gQrVqzgVCZ2mwjomZ4QQgghkklKSkJcXBwOHDgAT09P6OvrK+3fvn07pzJx20TtAsRuI4SIpfJUfJlMhqioKBw4cKDKqfjUJi4aQCCEEEKIZExMTNC3b1/eGVUStU3ULkDsNkKIWESbiv+utImGTmEghBBCCCGEEELIS6nxDiCEEEIIIYQQQoj46BQGQgghhEhq27Zt2Lp1K3Jzc1FcXKy0LyUlhVNVOVHbRO0CxG4jhBDydtEMBEIIIYRIJiIiAiNHjkStWrVw9uxZfPjhhzA3N0dOTg66du1Kbe9Ql+hthBBC3j5aA4EQQgghknF3d0dISAgGDx4MQ0NDpKWlwdnZGbNnz0Z+fj6WL19Obe9Il+hthBBC3j6agUAIIYQQyeTm5qJFixYAAF1dXTx69AgAMGzYMGzevJlnmrBtonYBYrcRQgh5+2gAgRBCCCGSsba2Rn5+PgDA3t4ep06dAgBcvXoVvCdFitomahcgdhshhJC3jwYQCCGEECKZ9u3bY9euXQCAkSNHIjg4GJ06dcLAgQPRu3dvanuHukRvI4QQ8vbRGgiEEEIIkYxcLodcLoeGRvmFoLZs2YITJ06gXr16GDNmDLS0tKjtHekSvY0QQsjbRwMIhBBCCCGEEEIIeSkN3gGEEEII+W8pKCjA6dOncfv2bcjlcqV9/v7+nKrKidomahcgdhshhJC3i2YgEEIIIUQyu3fvxtChQ1FYWAgjIyPIZDLFPplMpliQj9rE7xK9jRBCyNtHAwiEEEIIkYyrqyu6deuGsLAw6Onp8c5RImqbqF2A2G2EEELePhpAIIQQQohk9PX1cf78eTg7O/NOUSFqm6hdgNhthBBC3j66jCMhhBBCJNO5c2ckJyfzzqiSqG2idgFitxFCCHn7aBFFQgghhEime/fumDZtGtLT0+Hp6QlNTU2l/T179uRUJm6bqF2A2G2EEELePjqFgRBCCCGSUVOrfvKjTCZDWVmZhDXKRG0TtQsQu40QQsjbRwMIhBBCCCGEEEIIeSlaA4EQQgghhBBCCCEvRWsgEEIIIaRGRURE4LPPPoOOjg4iIiJeeNsJEyZIVFVO1DZRuwCx2wghhNQsOoWBEEIIITXKyckJycnJMDc3h5OTU7W3k8lkyMnJkbBM3DZRuwCx2wghhNQsGkAghBBCCBcVL0FkMhnnElWitonaBYjdRggh5O2gNRAIIYQQIqk1a9agQYMG0NHRgY6ODho0aICoqCjeWQDEbRO1CxC7jRBCyNtFayAQQgghRDKzZ8/GokWLEBQUhObNmwMATp48ieDgYOTm5mLOnDnU9o50id5GCCHk7aNTGAghhBAiGUtLS0RERGDw4MFK2zdv3oygoCDcvXuXU5m4baJ2AWK3EUIIefvoFAZCCCGESKakpARNmjRR2d64cWOUlpZyKPqXqG2idgFitxFCCHn7aACBEEIIIZIZNmwYfvrpJ5XtkZGRGDp0KIeif4naJmoXIHYbIYSQt4/WQCCEEEJIjZo8ebLi3zKZDFFRUThw4ACaNWsGAPjzzz+Rm5sLf39/ahO8S/Q2QgghNYvWQCCEEEJIjWrXrt0r3U4mk+Hw4cM1XKNM1DZRuwCx2wghhNQsGkAghBBCCCGEEELIS9EaCIQQQgghhBBCCHkpGkAghBBCCCGEEELIS9EAAiGEEEIIIYQQQl6KBhAIIYQQUi3GGD777DOYmZlBJpMhNTWVdxIhhBBCOKFFFAkhhBBSrb1796JXr16Ij4+Hs7MzLCwsoKHxv10FesSIESgoKMCOHTveTiQhhBBCJPG/vQIghBBCyHstOzsbNjY2aNGiBe8UFWVlZZDJZFBTowmVhBBCiBToLy4hhBBCqjRixAgEBQUhNzcXMpkMjo6OkMvlmDdvHpycnKCrq4uGDRti27Ztiv+fsrIyjBo1SrHfzc0NS5cuVez/5ptvsH79euzcuRMymQwymQzx8fGIj4+HTCZDQUGB4rapqamQyWS4du0aAGDdunUwMTHBrl27UL9+fWhrayM3NxfPnj3D1KlTYWdnB319fXz00UeIj4+X6CgRQggh/x00A4EQQgghVVq6dCnq1q2LyMhIJCUlQV1dHfPmzcPGjRuxcuVK1KtXD8eOHcOnn34KS0tL+Pr6Qi6Xo3bt2vj1119hbm6OEydO4LPPPoONjQ0GDBiAqVOnIiMjAw8fPkR0dDQAwMzMDCdOnHilpsePH+P7779HVFQUzM3NYWVlhS+++ALp6enYsmULbG1tERsbiy5duuD8+fOoV69eTR4iQggh5D+FBhAIIYQQUiVjY2MYGhpCXV0d1tbWePbsGcLCwnDo0CE0b94cAODs7IyEhASsWrUKvr6+0NTURGhoqOK/4eTkhJMnT2Lr1q0YMGAADAwMoKuri2fPnsHa2vq1m0pKSvDjjz+iYcOGAIDc3FxER0cjNzcXtra2AICpU6di3759iI6ORlhY2Fs4EoQQQggBaACBEEIIIa/oypUrePz4MTp16qS0vbi4GD4+PorvV6xYgbVr1yI3NxdPnjxBcXExvL2930qDlpYWvLy8FN+fP38eZWVlcHV1Vbrds2fPYG5u/lbukxBCCCHlaACBEEIIIa+ksLAQAPDHH3/Azs5OaZ+2tjYAYMuWLZg6dSrCw8PRvHlzGBoa4ocffsCff/75wv92xUKIlS8OVVJSonI7XV1dyGQypSZ1dXWcOXMG6urqSrc1MDB4jf91hBBCCHkZGkAghBBCyCupvHChr69vlbdJTExEixYt8Pnnnyu2ZWdnK91GS0sLZWVlStssLS0BADdv3oSpqSmA8kUUX8bHxwdlZWW4ffs2Wrdu/Tr/cwghhBDymmgAgRBCCCGvxNDQEFOnTkVwcDDkcjlatWqFBw8eIDExEUZGRhg+fDjq1auHmJgY7N+/H05OTtiwYQOSkpLg5OSk+O84Ojpi//79uHTpEszNzWFsbAwXFxfUqVMH33zzDebOnYusrCyEh4e/tMnV1RVDhw6Fv78/wsPD4ePjgzt37iAuLg5eXl7o3r17TR4SQggh5D+FLuNICCGEkFf27bffYtasWZg3bx48PDzQpUsX/PHHH4oBgjFjxqBPnz4YOHAgPvroI9y7d09pNgIAjB49Gm5ubmjSpAksLS2RmJgITU1NbN68GZmZmfDy8sL333+P77777pWaoqOj4e/vjylTpsDNzQ2ffPIJkpKSYG9v/9b/9xNCCCH/ZTJW+WRDQgghhBBCCCGEkCrQDARCCCGEEEIIIYS8FA0gEEIIIYQQQggh5KVoAIEQQgghhBBCCCEvRQMIhBBCCCGEEEIIeSkaQCCEEEIIIYQQQshL0QACIYQQQgghhBBCXooGEAghhBBCCCGEEPJSNIBACCGEEEIIIYSQl6IBBEIIIYQQQgghhLwUDSAQQgghhBBCCCHkpWgAgRBCCCGEEEIIIS9FAwiEEEIIIYQQQgh5qf8H69ScTKwOJBkAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -2931,8 +3379,8 @@ "INFO [matcher.py:139] \t* penalty: l2\n", "INFO [matcher.py:139] \t* solver: saga\n", "INFO [matcher.py:140] \tScore (gamma): 0.0472\n", - "INFO [matcher.py:141] \tSolution time: 0.003 min\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 3/50, 0.003 min) ...\n", + "INFO [matcher.py:141] \tSolution time: 0.004 min\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 3/50, 0.004 min) ...\n", "INFO [matcher.py:136] Best propensity score match found:\n", "INFO [matcher.py:137] \tModel: LogisticRegression\n", "INFO [matcher.py:139] \t* C: 0.0909955270741388\n", @@ -2943,8 +3391,8 @@ "INFO [matcher.py:140] \tScore (gamma): 0.0448\n", "INFO [matcher.py:141] \tSolution time: 0.005 min\n", "INFO [matcher.py:180] Training model SGDClassifier (iter 4/50, 0.005 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 5/50, 0.006 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 6/50, 0.007 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 5/50, 0.007 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 6/50, 0.008 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", "INFO [matcher.py:136] Best propensity score match found:\n", @@ -2955,11 +3403,11 @@ "INFO [matcher.py:139] \t* penalty: l1\n", "INFO [matcher.py:139] \t* solver: saga\n", "INFO [matcher.py:140] \tScore (gamma): 0.0347\n", - "INFO [matcher.py:141] \tSolution time: 0.030 min\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 7/50, 0.030 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 8/50, 0.031 min) ...\n", + "INFO [matcher.py:141] \tSolution time: 0.031 min\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 7/50, 0.031 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 8/50, 0.032 min) ...\n", "INFO [matcher.py:180] Training model LogisticRegression (iter 9/50, 0.033 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 10/50, 0.036 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 10/50, 0.037 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", "INFO [matcher.py:136] Best propensity score match found:\n", @@ -2970,18 +3418,18 @@ "INFO [matcher.py:139] \t* penalty: l1\n", "INFO [matcher.py:139] \t* solver: saga\n", "INFO [matcher.py:140] \tScore (gamma): 0.0331\n", - "INFO [matcher.py:141] \tSolution time: 0.057 min\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 11/50, 0.057 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 12/50, 0.066 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 13/50, 0.067 min) ...\n", + "INFO [matcher.py:141] \tSolution time: 0.061 min\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 11/50, 0.061 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 12/50, 0.071 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 13/50, 0.072 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 14/50, 0.086 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 15/50, 0.089 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 16/50, 0.090 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 17/50, 0.091 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 18/50, 0.094 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 19/50, 0.095 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 14/50, 0.094 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 15/50, 0.097 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 16/50, 0.099 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 17/50, 0.100 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 18/50, 0.103 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 19/50, 0.104 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", "INFO [matcher.py:136] Best propensity score match found:\n", @@ -2992,46 +3440,46 @@ "INFO [matcher.py:139] \t* penalty: l1\n", "INFO [matcher.py:139] \t* solver: saga\n", "INFO [matcher.py:140] \tScore (gamma): 0.0308\n", - "INFO [matcher.py:141] \tSolution time: 0.115 min\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 20/50, 0.116 min) ...\n", + "INFO [matcher.py:141] \tSolution time: 0.130 min\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 20/50, 0.130 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 21/50, 0.135 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 22/50, 0.136 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 23/50, 0.137 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 21/50, 0.151 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 22/50, 0.153 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 23/50, 0.154 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 24/50, 0.158 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 25/50, 0.159 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 26/50, 0.160 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 27/50, 0.172 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 28/50, 0.173 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 29/50, 0.174 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 30/50, 0.179 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 31/50, 0.180 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 32/50, 0.181 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 33/50, 0.184 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 24/50, 0.177 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 25/50, 0.178 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 26/50, 0.179 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 27/50, 0.194 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 28/50, 0.195 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 29/50, 0.196 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 30/50, 0.202 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 31/50, 0.203 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 32/50, 0.204 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 33/50, 0.208 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 34/50, 0.205 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 35/50, 0.214 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 36/50, 0.215 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 37/50, 0.216 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 38/50, 0.217 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 39/50, 0.227 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 40/50, 0.228 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 41/50, 0.229 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 42/50, 0.235 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 43/50, 0.236 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 44/50, 0.237 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 45/50, 0.238 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 46/50, 0.239 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 47/50, 0.240 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 48/50, 0.242 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 34/50, 0.231 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 35/50, 0.241 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 36/50, 0.242 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 37/50, 0.243 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 38/50, 0.244 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 39/50, 0.256 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 40/50, 0.257 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 41/50, 0.258 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 42/50, 0.265 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 43/50, 0.266 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 44/50, 0.267 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 45/50, 0.269 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 46/50, 0.270 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 47/50, 0.271 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 48/50, 0.273 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 49/50, 0.264 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 50/50, 0.265 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 49/50, 0.295 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 50/50, 0.297 min) ...\n", "INFO [matcher.py:136] Best propensity score match found:\n", "INFO [matcher.py:137] \tModel: LogisticRegression\n", "INFO [matcher.py:139] \t* C: 0.7964686611607528\n", @@ -3040,7 +3488,7 @@ "INFO [matcher.py:139] \t* penalty: l1\n", "INFO [matcher.py:139] \t* solver: saga\n", "INFO [matcher.py:140] \tScore (gamma): 0.0308\n", - "INFO [matcher.py:141] \tSolution time: 0.115 min\n", + "INFO [matcher.py:141] \tSolution time: 0.130 min\n", "INFO [matcher.py:577] Hint achieves objective value = 100400.\n", "INFO [matcher.py:579] Applying hints ...\n", "INFO [matcher.py:611] Solving with 4 workers ...\n", @@ -3053,7 +3501,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 2, time = 0.14 m\n", + "INFO [matcher.py:97] Solution 2, time = 0.13 m\n", "INFO [matcher.py:101] Objective:\t115400000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0349\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -3067,7 +3515,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 4, time = 0.15 m\n", + "INFO [matcher.py:97] Solution 4, time = 0.14 m\n", "INFO [matcher.py:101] Objective:\t114400000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0346\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -3088,21 +3536,21 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 7, time = 0.18 m\n", + "INFO [matcher.py:97] Solution 7, time = 0.17 m\n", "INFO [matcher.py:101] Objective:\t101400000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0308\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 8, time = 0.20 m\n", + "INFO [matcher.py:97] Solution 8, time = 0.19 m\n", "INFO [matcher.py:101] Objective:\t100800000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0306\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 9, time = 0.21 m\n", + "INFO [matcher.py:97] Solution 9, time = 0.20 m\n", "INFO [matcher.py:101] Objective:\t100400000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0305\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -3116,14 +3564,14 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 11, time = 0.27 m\n", + "INFO [matcher.py:97] Solution 11, time = 0.26 m\n", "INFO [matcher.py:101] Objective:\t97200000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0298\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 12, time = 0.32 m\n", + "INFO [matcher.py:97] Solution 12, time = 0.31 m\n", "INFO [matcher.py:101] Objective:\t97000000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0298\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -3144,7 +3592,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 15, time = 0.38 m\n", + "INFO [matcher.py:97] Solution 15, time = 0.37 m\n", "INFO [matcher.py:101] Objective:\t90800000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0282\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -3158,7 +3606,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 17, time = 0.43 m\n", + "INFO [matcher.py:97] Solution 17, time = 0.42 m\n", "INFO [matcher.py:101] Objective:\t80800000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0249\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -3172,28 +3620,28 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 19, time = 0.45 m\n", + "INFO [matcher.py:97] Solution 19, time = 0.44 m\n", "INFO [matcher.py:101] Objective:\t80400000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0247\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 20, time = 0.49 m\n", + "INFO [matcher.py:97] Solution 20, time = 0.48 m\n", "INFO [matcher.py:101] Objective:\t19000000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0070\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 21, time = 0.65 m\n", + "INFO [matcher.py:97] Solution 21, time = 0.64 m\n", "INFO [matcher.py:101] Objective:\t18800000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0069\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 22, time = 0.67 m\n", + "INFO [matcher.py:97] Solution 22, time = 0.66 m\n", "INFO [matcher.py:101] Objective:\t18400000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0068\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -3417,7 +3865,7 @@ "" ], "text/plain": [ - "" + "" ] }, "execution_count": 12, diff --git a/.doctrees/nbsphinx/demos_card_matcher_10_0.png b/.doctrees/nbsphinx/demos_card_matcher_10_0.png deleted file mode 100644 index 729ef26..0000000 Binary files a/.doctrees/nbsphinx/demos_card_matcher_10_0.png and /dev/null differ diff --git a/.doctrees/nbsphinx/demos_card_matcher_10_1.png b/.doctrees/nbsphinx/demos_card_matcher_10_1.png deleted file mode 100644 index 4437adc..0000000 Binary files a/.doctrees/nbsphinx/demos_card_matcher_10_1.png and /dev/null differ diff --git a/.doctrees/nbsphinx/demos_card_matcher_13_0.png b/.doctrees/nbsphinx/demos_card_matcher_13_0.png index d776f3a..729ef26 100644 Binary files a/.doctrees/nbsphinx/demos_card_matcher_13_0.png and b/.doctrees/nbsphinx/demos_card_matcher_13_0.png differ diff --git a/.doctrees/nbsphinx/demos_card_matcher_13_1.png b/.doctrees/nbsphinx/demos_card_matcher_13_1.png index 4c2cc7c..4437adc 100644 Binary files a/.doctrees/nbsphinx/demos_card_matcher_13_1.png and b/.doctrees/nbsphinx/demos_card_matcher_13_1.png differ diff --git a/.doctrees/nbsphinx/demos_card_matcher_17_0.png b/.doctrees/nbsphinx/demos_card_matcher_17_0.png new file mode 100644 index 0000000..d776f3a Binary files /dev/null and b/.doctrees/nbsphinx/demos_card_matcher_17_0.png differ diff --git a/.doctrees/nbsphinx/demos_card_matcher_17_1.png b/.doctrees/nbsphinx/demos_card_matcher_17_1.png new file mode 100644 index 0000000..4c2cc7c Binary files /dev/null and b/.doctrees/nbsphinx/demos_card_matcher_17_1.png differ diff --git a/.doctrees/nbsphinx/demos_card_matcher_7_0.png b/.doctrees/nbsphinx/demos_card_matcher_7_0.png deleted file mode 100644 index 7044597..0000000 Binary files a/.doctrees/nbsphinx/demos_card_matcher_7_0.png and /dev/null differ diff --git a/.doctrees/nbsphinx/demos_card_matcher_9_0.png b/.doctrees/nbsphinx/demos_card_matcher_9_0.png new file mode 100644 index 0000000..35772ab Binary files /dev/null and b/.doctrees/nbsphinx/demos_card_matcher_9_0.png differ diff --git a/.doctrees/nbsphinx/demos_card_matcher_7_1.png b/.doctrees/nbsphinx/demos_card_matcher_9_1.png similarity index 100% rename from .doctrees/nbsphinx/demos_card_matcher_7_1.png rename to .doctrees/nbsphinx/demos_card_matcher_9_1.png diff --git a/.doctrees/nbsphinx/demos_lp_matcher_14_0.png b/.doctrees/nbsphinx/demos_lp_matcher_14_0.png index df743b9..c5c96aa 100644 Binary files a/.doctrees/nbsphinx/demos_lp_matcher_14_0.png and b/.doctrees/nbsphinx/demos_lp_matcher_14_0.png differ diff --git a/02_demos.html b/02_demos.html index 7a5190b..6a05f6b 100644 --- a/02_demos.html +++ b/02_demos.html @@ -129,8 +129,8 @@

Demos
  • Cardinality matching
    • diff --git a/03_api.html b/03_api.html index bcbf252..4ee51e6 100644 --- a/03_api.html +++ b/03_api.html @@ -800,7 +800,7 @@

    Constraint Satisfacti

    The constraints and optimization target are specified to the solver via the options pool_size, target_size, and max_mismatch. The behavior of the solver depends on which are these options are specified as given below:

    -

    (pool_size, target_size, max_mismatch) –> optimize balance subject to size and +

    (pool_size, target_size, max_mismatch) –> optimize balance subject to size and balance constraints

    (pool_size, target_size) –> optimize balance subject to size constraints

    (max_mismatch) –> optimize pool size subject to target_size = n_target and diff --git a/_images/demos_card_matcher_10_0.png b/_images/demos_card_matcher_10_0.png deleted file mode 100644 index 729ef26..0000000 Binary files a/_images/demos_card_matcher_10_0.png and /dev/null differ diff --git a/_images/demos_card_matcher_10_1.png b/_images/demos_card_matcher_10_1.png deleted file mode 100644 index 4437adc..0000000 Binary files a/_images/demos_card_matcher_10_1.png and /dev/null differ diff --git a/_images/demos_card_matcher_13_0.png b/_images/demos_card_matcher_13_0.png index d776f3a..729ef26 100644 Binary files a/_images/demos_card_matcher_13_0.png and b/_images/demos_card_matcher_13_0.png differ diff --git a/_images/demos_card_matcher_13_1.png b/_images/demos_card_matcher_13_1.png index 4c2cc7c..4437adc 100644 Binary files a/_images/demos_card_matcher_13_1.png and b/_images/demos_card_matcher_13_1.png differ diff --git a/_images/demos_card_matcher_17_0.png b/_images/demos_card_matcher_17_0.png new file mode 100644 index 0000000..d776f3a Binary files /dev/null and b/_images/demos_card_matcher_17_0.png differ diff --git a/_images/demos_card_matcher_17_1.png b/_images/demos_card_matcher_17_1.png new file mode 100644 index 0000000..4c2cc7c Binary files /dev/null and b/_images/demos_card_matcher_17_1.png differ diff --git a/_images/demos_card_matcher_7_0.png b/_images/demos_card_matcher_7_0.png deleted file mode 100644 index 7044597..0000000 Binary files a/_images/demos_card_matcher_7_0.png and /dev/null differ diff --git a/_images/demos_card_matcher_9_0.png b/_images/demos_card_matcher_9_0.png new file mode 100644 index 0000000..35772ab Binary files /dev/null and b/_images/demos_card_matcher_9_0.png differ diff --git a/_images/demos_card_matcher_7_1.png b/_images/demos_card_matcher_9_1.png similarity index 100% rename from _images/demos_card_matcher_7_1.png rename to _images/demos_card_matcher_9_1.png diff --git a/_images/demos_lp_matcher_14_0.png b/_images/demos_lp_matcher_14_0.png index df743b9..c5c96aa 100644 Binary files a/_images/demos_lp_matcher_14_0.png and b/_images/demos_lp_matcher_14_0.png differ diff --git a/_modules/pybalance/lp/matcher.html b/_modules/pybalance/lp/matcher.html index 5208256..8a98dce 100644 --- a/_modules/pybalance/lp/matcher.html +++ b/_modules/pybalance/lp/matcher.html @@ -239,16 +239,16 @@

    Source code for pybalance.lp.matcher

         options pool_size, target_size, and max_mismatch. The behavior of the solver depends
     on which are these options are specified as given below:
 
-    (pool_size, target_size, max_mismatch) --> optimize balance subject to size and 
+    (pool_size, target_size, max_mismatch) --> optimize balance subject to size and
     balance constraints
-    
+
     (pool_size, target_size) --> optimize balance subject to size constraints
 
     (max_mismatch) --> optimize pool size subject to target_size = n_target and
     balance constraints
 
     () --> optimize balance subject to size constraints with pool_size = target_size = n_target
- 
+
     Optimizing pool_size subject to balance constraint is known as "cardinality
     matching". See https://kosukeimai.github.io/MatchIt/reference/method_cardinality.html
     and references therein.
diff --git a/_sources/demos/card_matcher.ipynb.txt b/_sources/demos/card_matcher.ipynb.txt
index d91dad4..9520a10 100644
--- a/_sources/demos/card_matcher.ipynb.txt
+++ b/_sources/demos/card_matcher.ipynb.txt
@@ -8,6 +8,26 @@
     "# Cardinality matching"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "14c518ee-3bc0-493a-9eb3-e2a289642823",
+   "metadata": {},
+   "source": [
+    "Cardinality matching is the process of finding the size of the largest subset $\\hat{P}$ of a pool of patient $P$ within some \"distance\" of a given target population:\n",
+    "\n",
+    "\\begin{equation}\n",
+    "\\begin{aligned}\n",
+    "& \\underset{\\hat{P}}{\\text{maximize}}\n",
+    "& & |\\hat{P}| \\\\\n",
+    "& \\text{subject to}\n",
+    "& & |\\mu_{\\hat{P},k} - \\mu_{T,k}| \\leq \\delta \\textrm{ for all }k\n",
+    "\\end{aligned}\n",
+    "\\end{equation}\n",
+    "\n",
+    "where $k$ indexes the covariates of $P$ and $T$. In cardinality matching, at least as implemented here, we search only for the size of the largest subset.\n",
+    "Then in a second step, we optimize the balance (distance) among all subsets of the determined size."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 1,
@@ -253,7 +273,7 @@
        "
    " ], "text/plain": [ - "" + "" ] }, "execution_count": 3, @@ -271,7 +291,7 @@ "id": "4e699cd6-9f4c-4493-a261-0a704f288c64", "metadata": {}, "source": [ - "## Optimize pool size subject to balance constraint" + "## Optimize pool size with balance constraint" ] }, { @@ -294,93 +314,109 @@ "INFO:pybalance.lp.matcher:Calculating bounds on feature variables ...\n", "INFO:pybalance.lp.matcher:Applying size constraints on pool and target ...\n", "INFO:pybalance.lp.matcher:Solving with 4 workers ...\n", - "INFO:pybalance.lp.matcher:Initial balance score: 0.2095\n", + "INFO:pybalance.lp.matcher:Initial balance score: 0.1236\n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 1, time = 0.34 m\n", + "INFO:pybalance.lp.matcher:Solution 1, time = 0.36 m\n", "INFO:pybalance.lp.matcher:Objective:\t13153.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0117\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0068\n", "INFO:pybalance.lp.matcher:Patients (pool):\t1847\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 2, time = 0.45 m\n", + "INFO:pybalance.lp.matcher:Solution 2, time = 0.47 m\n", "INFO:pybalance.lp.matcher:Objective:\t12981.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0280\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0163\n", "INFO:pybalance.lp.matcher:Patients (pool):\t2019\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 3, time = 0.47 m\n", - "INFO:pybalance.lp.matcher:Objective:\t12979.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0382\n", - "INFO:pybalance.lp.matcher:Patients (pool):\t2021\n", + "INFO:pybalance.lp.matcher:Solution 3, time = 0.53 m\n", + "INFO:pybalance.lp.matcher:Objective:\t12937.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0171\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t2063\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 4, time = 0.49 m\n", - "INFO:pybalance.lp.matcher:Objective:\t12909.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0380\n", - "INFO:pybalance.lp.matcher:Patients (pool):\t2091\n", + "INFO:pybalance.lp.matcher:Solution 4, time = 0.55 m\n", + "INFO:pybalance.lp.matcher:Objective:\t12910.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0178\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t2090\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 5, time = 0.51 m\n", - "INFO:pybalance.lp.matcher:Objective:\t12879.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0383\n", - "INFO:pybalance.lp.matcher:Patients (pool):\t2121\n", + "INFO:pybalance.lp.matcher:Solution 5, time = 0.98 m\n", + "INFO:pybalance.lp.matcher:Objective:\t12907.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0179\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t2093\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 6, time = 0.85 m\n", - "INFO:pybalance.lp.matcher:Objective:\t12827.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0387\n", - "INFO:pybalance.lp.matcher:Patients (pool):\t2173\n", + "INFO:pybalance.lp.matcher:Solution 6, time = 1.28 m\n", + "INFO:pybalance.lp.matcher:Objective:\t12906.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0250\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t2094\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 7, time = 1.94 m\n", - "INFO:pybalance.lp.matcher:Objective:\t11000.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0648\n", - "INFO:pybalance.lp.matcher:Patients (pool):\t4000\n", + "INFO:pybalance.lp.matcher:Solution 7, time = 2.22 m\n", + "INFO:pybalance.lp.matcher:Objective:\t12689.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0259\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t2311\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 8, time = 2.10 m\n", + "INFO:pybalance.lp.matcher:Solution 8, time = 2.39 m\n", + "INFO:pybalance.lp.matcher:Objective:\t12632.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0260\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t2368\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 9, time = 2.39 m\n", "INFO:pybalance.lp.matcher:Objective:\t10818.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0704\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0413\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:Status = FEASIBLE\n", - "INFO:pybalance.lp.matcher:Number of solutions found: 8\n" + "INFO:pybalance.lp.matcher:Number of solutions found: 9\n" ] } ], "source": [ + "# Note that by default, gamma uses the standardized mean difference \n", + "# to calculate distance. The ConstraintSatisfactionMatcher, however,\n", + "# can only optimize linear objectives. It is not an error to pass \n", + "# gamma with standardized_difference=True, at this is only affects\n", + "# reporting, but to make the reporting consistent with what we're \n", + "# optimizing, we explicitly pass standardized_difference=False here.\n", + "\n", + "gamma = GammaBalance(m, standardize_difference=False)\n", "matcher = ConstraintSatisfactionMatcher(\n", " matching_data=m, \n", - " objective='gamma', \n", - " max_mismatch=0.05, \n", + " objective=gamma,\n", + " max_mismatch=0.05,\n", " time_limit=600\n", ")\n", "match_card = matcher.match()" ] }, + { + "cell_type": "markdown", + "id": "47da2013-6ffe-4d68-a9b6-d87f89e0ccf4", + "metadata": {}, + "source": [ + "Note that as the optimization progresses, the size of the matched population increases and the balance also increases. This will generally be the case, since it is harder to find a larger set of patients (they have more degrees of freedom) that match a given target. Increased mismatch is the tradeoff of having a larger matched population.\n", + "\n", + "Let's check that the found solution satisfies the balance constraint:" + ] + }, { "cell_type": "code", "execution_count": 5, "id": "a76e9375-d27f-4f9d-aea4-27d1f7e7a483", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pybalance.utils.preprocess:Discretized age with bins [18.02, 27.51, 37.01, 46.51, 56.0, 65.5, 75.0].\n", - "INFO:pybalance.utils.preprocess:Discretized height with bins [125.0, 136.67, 148.33, 159.99, 171.66, 183.32, 194.99].\n", - "INFO:pybalance.utils.preprocess:Discretized weight with bins [50.01, 61.67, 73.34, 85.0, 96.67, 108.33, 120.0].\n" - ] - }, { "data": { "text/plain": [ @@ -393,7 +429,6 @@ } ], "source": [ - "gamma = GammaBalance(m, standardize_difference=False)\n", "gamma.per_feature_loss(match_card.get_population('pool')).max()" ] }, @@ -405,7 +440,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] @@ -435,7 +470,15 @@ "id": "ce715a25-d006-419d-ab1b-c6dfe3e77c29", "metadata": {}, "source": [ - "## Optimize balance with balance constraint" + "## Optimize balance with size and balance constraints" + ] + }, + { + "cell_type": "markdown", + "id": "5dde7ed9-75af-486c-82c6-2e69ae040ab0", + "metadata": {}, + "source": [ + "Now that we have determined the optimal size of the matched population, let's optimize the balance for all subsets of that size. For this, we create a second matcher object, setting size constraints and keeping the balance constraint (max_mismatch)." ] }, { @@ -448,9 +491,6 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO:pybalance.utils.preprocess:Discretized age with bins [18.02, 27.51, 37.01, 46.51, 56.0, 65.5, 75.0].\n", - "INFO:pybalance.utils.preprocess:Discretized height with bins [125.0, 136.67, 148.33, 159.99, 171.66, 183.32, 194.99].\n", - "INFO:pybalance.utils.preprocess:Discretized weight with bins [50.01, 61.67, 73.34, 85.0, 96.67, 108.33, 120.0].\n", "INFO:pybalance.lp.matcher:Scaling features by factor 200.00 in order to use integer solver with <= 0.0000% loss.\n", "INFO:pybalance.lp.matcher:Solving for match population with pool size = 4182 and target size = 1000 subject to 0.05 balance constraint.\n", "INFO:pybalance.lp.matcher:Matching on 27 dimensions ...\n", @@ -458,46 +498,46 @@ "INFO:pybalance.lp.matcher:Calculating bounds on feature variables ...\n", "INFO:pybalance.lp.matcher:Applying size constraints on pool and target ...\n", "INFO:pybalance.lp.matcher:Solving with 4 workers ...\n", - "INFO:pybalance.lp.matcher:Initial balance score: 0.2095\n", + "INFO:pybalance.lp.matcher:Initial balance score: 0.1236\n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 1, time = 0.25 m\n", + "INFO:pybalance.lp.matcher:Solution 1, time = 0.29 m\n", "INFO:pybalance.lp.matcher:Objective:\t825443200.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0644\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0366\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 2, time = 0.31 m\n", + "INFO:pybalance.lp.matcher:Solution 2, time = 0.37 m\n", "INFO:pybalance.lp.matcher:Objective:\t825304800.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0644\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0365\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 3, time = 0.47 m\n", + "INFO:pybalance.lp.matcher:Solution 3, time = 0.55 m\n", "INFO:pybalance.lp.matcher:Objective:\t733533600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0557\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0325\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 4, time = 3.09 m\n", + "INFO:pybalance.lp.matcher:Solution 4, time = 3.59 m\n", "INFO:pybalance.lp.matcher:Objective:\t733527200.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0557\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0325\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 5, time = 3.59 m\n", + "INFO:pybalance.lp.matcher:Solution 5, time = 4.10 m\n", "INFO:pybalance.lp.matcher:Objective:\t733465600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0557\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0325\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 6, time = 3.73 m\n", + "INFO:pybalance.lp.matcher:Solution 6, time = 4.24 m\n", "INFO:pybalance.lp.matcher:Objective:\t733395200.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0557\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0325\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", @@ -509,7 +549,7 @@ "source": [ "matcher = ConstraintSatisfactionMatcher(\n", " matching_data=m, \n", - " objective='gamma', \n", + " objective=gamma, \n", " max_mismatch=0.05, \n", " pool_size=len(match_card.get_population('pool')),\n", " target_size=len(match_card.get_population('target')),\n", @@ -559,6 +599,14 @@ "## Optimize balance without balance constraint" ] }, + { + "cell_type": "markdown", + "id": "dea30112-beb0-49b8-95bc-c7f95444fcaf", + "metadata": {}, + "source": [ + "You can also remove the balance constraint, if you don't care about individual mismatched features. Here we run a matcher fixed to the size of the optimal subset size but relax the mismatch constraint." + ] + }, { "cell_type": "code", "execution_count": 9, @@ -569,9 +617,6 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO:pybalance.utils.preprocess:Discretized age with bins [18.02, 27.51, 37.01, 46.51, 56.0, 65.5, 75.0].\n", - "INFO:pybalance.utils.preprocess:Discretized height with bins [125.0, 136.67, 148.33, 159.99, 171.66, 183.32, 194.99].\n", - "INFO:pybalance.utils.preprocess:Discretized weight with bins [50.01, 61.67, 73.34, 85.0, 96.67, 108.33, 120.0].\n", "INFO:pybalance.lp.matcher:Scaling features by factor 200.00 in order to use integer solver with <= 0.0000% loss.\n", "INFO:pybalance.lp.matcher:Solving for match population with pool size = 4182 and target size = 1000 subject to None balance constraint.\n", "INFO:pybalance.lp.matcher:Matching on 27 dimensions ...\n", @@ -579,81 +624,81 @@ "INFO:pybalance.lp.matcher:Calculating bounds on feature variables ...\n", "INFO:pybalance.lp.matcher:Applying size constraints on pool and target ...\n", "INFO:pybalance.lp.matcher:Solving with 4 workers ...\n", - "INFO:pybalance.lp.matcher:Initial balance score: 0.2095\n", + "INFO:pybalance.lp.matcher:Initial balance score: 0.1236\n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 1, time = 0.07 m\n", "INFO:pybalance.lp.matcher:Objective:\t2127925600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1582\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0942\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 2, time = 0.11 m\n", "INFO:pybalance.lp.matcher:Objective:\t2020125600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1489\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0895\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 3, time = 0.13 m\n", "INFO:pybalance.lp.matcher:Objective:\t2019725600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1489\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0894\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 4, time = 0.20 m\n", "INFO:pybalance.lp.matcher:Objective:\t2016325600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1487\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0893\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 5, time = 0.26 m\n", "INFO:pybalance.lp.matcher:Objective:\t2015325600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1486\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0892\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 6, time = 0.32 m\n", "INFO:pybalance.lp.matcher:Objective:\t2012125600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1483\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0891\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 7, time = 0.32 m\n", "INFO:pybalance.lp.matcher:Objective:\t2011725600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1482\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0891\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 8, time = 0.34 m\n", "INFO:pybalance.lp.matcher:Objective:\t2011525600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1482\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0891\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 9, time = 0.36 m\n", "INFO:pybalance.lp.matcher:Objective:\t2011325600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1482\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0891\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 10, time = 0.66 m\n", + "INFO:pybalance.lp.matcher:Solution 10, time = 0.65 m\n", "INFO:pybalance.lp.matcher:Objective:\t478921600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0346\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0212\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 11, time = 1.19 m\n", + "INFO:pybalance.lp.matcher:Solution 11, time = 1.18 m\n", "INFO:pybalance.lp.matcher:Objective:\t478920000.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0346\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0212\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", @@ -665,7 +710,7 @@ "source": [ "matcher = ConstraintSatisfactionMatcher(\n", " matching_data=m, \n", - " objective='gamma', \n", + " objective=gamma, \n", " pool_size=len(match_card.get_population('pool')),\n", " target_size=len(match_card.get_population('target')),\n", " time_limit=600\n", @@ -706,25 +751,24 @@ "fig = plot_categoric_features(match_dist2)" ] }, + { + "cell_type": "markdown", + "id": "e82f82fb-eab8-4966-99fd-bd4d5d87e7cc", + "metadata": {}, + "source": [ + "Note that the solution no longer satisfies the max_mismatch constraint." + ] + }, { "cell_type": "code", "execution_count": 11, "id": "014a2b7e-d2a5-46be-bd25-299ff3bf52df", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pybalance.utils.preprocess:Discretized age with bins [18.02, 27.51, 37.01, 46.51, 56.0, 65.5, 75.0].\n", - "INFO:pybalance.utils.preprocess:Discretized height with bins [125.0, 136.67, 148.33, 159.99, 171.66, 183.32, 194.99].\n", - "INFO:pybalance.utils.preprocess:Discretized weight with bins [50.01, 61.67, 73.34, 85.0, 96.67, 108.33, 120.0].\n" - ] - }, { "data": { "text/plain": [ - "tensor(0.0500)" + "tensor(0.1696)" ] }, "execution_count": 11, @@ -733,8 +777,7 @@ } ], "source": [ - "beta = GammaBalance(m, standardize_difference=False)\n", - "beta.per_feature_loss(match_dist.get_population('pool')).max()" + "gamma.per_feature_loss(match_dist2.get_population('pool')).max()" ] } ], diff --git a/_sources/demos/lp_matcher.ipynb.txt b/_sources/demos/lp_matcher.ipynb.txt index 81937a7..0f97e8d 100644 --- a/_sources/demos/lp_matcher.ipynb.txt +++ b/_sources/demos/lp_matcher.ipynb.txt @@ -7,7 +7,21 @@ "source": [ "# Constraint Satisfaction Matcher\n", "\n", - "The ConstraintSatisfactionMatcher can be used to optimize any linear function of the baseline covariates. In this demo notebook, we show how to call the matcher in the PyBalance library." + "The ConstraintSatisfactionMatcher can be used to optimize any linear function of the baseline covariates. We support constraints on the size of the subset populations and the allowed mismatch.\n", + "\n", + "Here, we demonstrate the optimization of balance subject to size constraints only. Namely, we solve:\n", + "\n", + "\\begin{equation}\n", + "\\begin{aligned}\n", + "& \\underset{\\hat{P}}{\\text{minimize}}\n", + "& & \\sum_k |\\mu_{\\hat{P},k} - \\mu_{T,k}| \\\\\n", + "& \\text{subject to}\n", + "& & |\\hat{P}| = P^* \\\\\n", + "& & & |\\hat{T}| = T^* \\\\\n", + "\\end{aligned}\n", + "\\end{equation}\n", + "\n", + "where $P$ and $T$ refer to two populations we are trying to match, $\\hat{P}$ and $\\hat{T}$ are the subsets of $P$ and $T$ we are seeking, $P^*$ and $T^*$ are fixed integers, and $k$ indexes the covariates of $P$ and $T$." ] }, { @@ -269,7 +283,7 @@ "" ], "text/plain": [ - "" + "" ] }, "execution_count": 3, @@ -497,21 +511,21 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 22, time = 0.55 m\n", + "INFO [matcher.py:97] Solution 22, time = 0.56 m\n", "INFO [matcher.py:101] Objective:\t22084000.0\n", "INFO [matcher.py:120] Balance (beta):\t0.0122\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 23, time = 3.16 m\n", + "INFO [matcher.py:97] Solution 23, time = 3.14 m\n", "INFO [matcher.py:101] Objective:\t22083000.0\n", "INFO [matcher.py:120] Balance (beta):\t0.0101\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 24, time = 5.78 m\n", + "INFO [matcher.py:97] Solution 24, time = 5.71 m\n", "INFO [matcher.py:101] Objective:\t22082000.0\n", "INFO [matcher.py:120] Balance (beta):\t0.0102\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -735,7 +749,7 @@ "" ], "text/plain": [ - "" + "" ] }, "execution_count": 5, @@ -975,7 +989,7 @@ "" ], "text/plain": [ - "" + "" ] }, "execution_count": 6, @@ -1133,7 +1147,7 @@ "INFO [preprocess.py:442] Added cross term binary_2 * binary_3 to matching features.\n", "INFO [preprocess.py:442] Added cross term binary_2 * height to matching features.\n", "INFO [preprocess.py:442] Added cross term binary_0 * binary_2 to matching features.\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 1/50, 0.000 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 1/50, 0.001 min) ...\n", "INFO [matcher.py:136] Best propensity score match found:\n", "INFO [matcher.py:137] \tModel: SGDClassifier\n", "INFO [matcher.py:139] \t* alpha: 0.1045355473186929\n", @@ -1183,48 +1197,48 @@ "INFO [matcher.py:180] Training model LogisticRegression (iter 6/50, 0.024 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 7/50, 0.044 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 7/50, 0.046 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 8/50, 0.065 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 9/50, 0.066 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 8/50, 0.067 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 9/50, 0.068 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 10/50, 0.083 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 11/50, 0.102 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 12/50, 0.103 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 13/50, 0.115 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 10/50, 0.085 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 11/50, 0.104 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 12/50, 0.105 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 13/50, 0.118 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 14/50, 0.137 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 15/50, 0.138 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 16/50, 0.139 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 14/50, 0.139 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 15/50, 0.140 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 16/50, 0.141 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 17/50, 0.161 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 18/50, 0.162 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 19/50, 0.163 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 20/50, 0.164 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 21/50, 0.165 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 17/50, 0.163 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 18/50, 0.164 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 19/50, 0.165 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 20/50, 0.166 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 21/50, 0.167 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 22/50, 0.186 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 23/50, 0.187 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 24/50, 0.188 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 25/50, 0.189 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 26/50, 0.190 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 27/50, 0.195 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 28/50, 0.196 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 22/50, 0.188 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 23/50, 0.189 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 24/50, 0.190 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 25/50, 0.191 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 26/50, 0.192 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 27/50, 0.196 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 28/50, 0.198 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 29/50, 0.216 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 30/50, 0.217 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 31/50, 0.232 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 29/50, 0.214 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 30/50, 0.215 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 31/50, 0.230 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 32/50, 0.254 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 33/50, 0.255 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 34/50, 0.258 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 32/50, 0.251 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 33/50, 0.252 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 34/50, 0.254 min) ...\n", "INFO [matcher.py:136] Best propensity score match found:\n", "INFO [matcher.py:137] \tModel: SGDClassifier\n", "INFO [matcher.py:139] \t* alpha: 0.02606111348517078\n", @@ -1235,24 +1249,24 @@ "INFO [matcher.py:139] \t* max_iter: 1500\n", "INFO [matcher.py:139] \t* penalty: l2\n", "INFO [matcher.py:140] \tScore (beta_x): 0.0603\n", - "INFO [matcher.py:141] \tSolution time: 0.259 min\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 35/50, 0.259 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 36/50, 0.260 min) ...\n", + "INFO [matcher.py:141] \tSolution time: 0.255 min\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 35/50, 0.255 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 36/50, 0.256 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 37/50, 0.282 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 38/50, 0.284 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 39/50, 0.285 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 37/50, 0.278 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 38/50, 0.280 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 39/50, 0.281 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 40/50, 0.306 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 41/50, 0.322 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 42/50, 0.331 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 43/50, 0.333 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 44/50, 0.334 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 45/50, 0.346 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 46/50, 0.352 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 47/50, 0.353 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 40/50, 0.302 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 41/50, 0.319 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 42/50, 0.328 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 43/50, 0.330 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 44/50, 0.331 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 45/50, 0.344 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 46/50, 0.351 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 47/50, 0.352 min) ...\n", "INFO [matcher.py:180] Training model SGDClassifier (iter 48/50, 0.354 min) ...\n", "INFO [matcher.py:180] Training model SGDClassifier (iter 49/50, 0.355 min) ...\n", "INFO [matcher.py:180] Training model SGDClassifier (iter 50/50, 0.356 min) ...\n", @@ -1266,7 +1280,7 @@ "INFO [matcher.py:139] \t* max_iter: 1500\n", "INFO [matcher.py:139] \t* penalty: l2\n", "INFO [matcher.py:140] \tScore (beta_x): 0.0603\n", - "INFO [matcher.py:141] \tSolution time: 0.259 min\n", + "INFO [matcher.py:141] \tSolution time: 0.255 min\n", "INFO [matcher.py:577] Hint achieves objective value = 147332.\n", "INFO [matcher.py:579] Applying hints ...\n", "INFO [matcher.py:611] Solving with 4 workers ...\n", @@ -1321,7 +1335,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 8, time = 0.12 m\n", + "INFO [matcher.py:97] Solution 8, time = 0.13 m\n", "INFO [matcher.py:101] Objective:\t145229000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0596\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1405,7 +1419,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 20, time = 0.27 m\n", + "INFO [matcher.py:97] Solution 20, time = 0.26 m\n", "INFO [matcher.py:101] Objective:\t143574000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0591\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1426,7 +1440,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 23, time = 0.30 m\n", + "INFO [matcher.py:97] Solution 23, time = 0.29 m\n", "INFO [matcher.py:101] Objective:\t142588000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0589\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1461,7 +1475,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 28, time = 0.36 m\n", + "INFO [matcher.py:97] Solution 28, time = 0.35 m\n", "INFO [matcher.py:101] Objective:\t141681000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0587\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1489,7 +1503,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 32, time = 0.40 m\n", + "INFO [matcher.py:97] Solution 32, time = 0.39 m\n", "INFO [matcher.py:101] Objective:\t141229000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0586\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1503,7 +1517,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 34, time = 0.44 m\n", + "INFO [matcher.py:97] Solution 34, time = 0.43 m\n", "INFO [matcher.py:101] Objective:\t140938000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0584\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1573,7 +1587,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 44, time = 0.68 m\n", + "INFO [matcher.py:97] Solution 44, time = 0.67 m\n", "INFO [matcher.py:101] Objective:\t139980000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0583\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1636,7 +1650,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 53, time = 0.77 m\n", + "INFO [matcher.py:97] Solution 53, time = 0.78 m\n", "INFO [matcher.py:101] Objective:\t138879000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0580\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1769,7 +1783,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 72, time = 1.11 m\n", + "INFO [matcher.py:97] Solution 72, time = 1.10 m\n", "INFO [matcher.py:101] Objective:\t136838000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0574\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1783,28 +1797,28 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 74, time = 1.25 m\n", + "INFO [matcher.py:97] Solution 74, time = 1.24 m\n", "INFO [matcher.py:101] Objective:\t136654000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0574\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 75, time = 1.25 m\n", + "INFO [matcher.py:97] Solution 75, time = 1.24 m\n", "INFO [matcher.py:101] Objective:\t136559000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0574\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 76, time = 1.26 m\n", + "INFO [matcher.py:97] Solution 76, time = 1.25 m\n", "INFO [matcher.py:101] Objective:\t136503000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0573\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 77, time = 1.26 m\n", + "INFO [matcher.py:97] Solution 77, time = 1.25 m\n", "INFO [matcher.py:101] Objective:\t136457000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0573\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1818,14 +1832,14 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 79, time = 1.37 m\n", + "INFO [matcher.py:97] Solution 79, time = 1.36 m\n", "INFO [matcher.py:101] Objective:\t136386000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0574\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 80, time = 1.38 m\n", + "INFO [matcher.py:97] Solution 80, time = 1.37 m\n", "INFO [matcher.py:101] Objective:\t136349000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0573\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1839,735 +1853,1169 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 82, time = 1.39 m\n", + "INFO [matcher.py:97] Solution 82, time = 1.38 m\n", "INFO [matcher.py:101] Objective:\t136286000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0573\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 83, time = 1.39 m\n", + "INFO [matcher.py:97] Solution 83, time = 1.38 m\n", "INFO [matcher.py:101] Objective:\t136020000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0573\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 84, time = 1.43 m\n", + "INFO [matcher.py:97] Solution 84, time = 1.41 m\n", "INFO [matcher.py:101] Objective:\t135535000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0570\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 85, time = 1.48 m\n", + "INFO [matcher.py:97] Solution 85, time = 1.47 m\n", "INFO [matcher.py:101] Objective:\t135513000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0570\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 86, time = 1.49 m\n", + "INFO [matcher.py:97] Solution 86, time = 1.48 m\n", "INFO [matcher.py:101] Objective:\t135473000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0570\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 87, time = 1.49 m\n", + "INFO [matcher.py:97] Solution 87, time = 1.48 m\n", "INFO [matcher.py:101] Objective:\t135452000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0570\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 88, time = 1.53 m\n", + "INFO [matcher.py:97] Solution 88, time = 1.51 m\n", "INFO [matcher.py:101] Objective:\t135375000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0570\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 89, time = 1.54 m\n", + "INFO [matcher.py:97] Solution 89, time = 1.53 m\n", "INFO [matcher.py:101] Objective:\t135312000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0569\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 90, time = 1.55 m\n", + "INFO [matcher.py:97] Solution 90, time = 1.54 m\n", "INFO [matcher.py:101] Objective:\t134988000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0568\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 91, time = 1.59 m\n", + "INFO [matcher.py:97] Solution 91, time = 1.58 m\n", "INFO [matcher.py:101] Objective:\t134977000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0568\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 92, time = 1.60 m\n", + "INFO [matcher.py:97] Solution 92, time = 1.59 m\n", "INFO [matcher.py:101] Objective:\t134937000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0568\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 93, time = 1.60 m\n", + "INFO [matcher.py:97] Solution 93, time = 1.59 m\n", "INFO [matcher.py:101] Objective:\t134931000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0568\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 94, time = 1.62 m\n", + "INFO [matcher.py:97] Solution 94, time = 1.61 m\n", "INFO [matcher.py:101] Objective:\t134909000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0567\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 95, time = 1.68 m\n", + "INFO [matcher.py:97] Solution 95, time = 1.66 m\n", "INFO [matcher.py:101] Objective:\t134887000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0566\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 96, time = 1.69 m\n", + "INFO [matcher.py:97] Solution 96, time = 1.67 m\n", "INFO [matcher.py:101] Objective:\t134614000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0566\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 97, time = 1.69 m\n", + "INFO [matcher.py:97] Solution 97, time = 1.68 m\n", "INFO [matcher.py:101] Objective:\t134579000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0566\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 98, time = 1.69 m\n", + "INFO [matcher.py:97] Solution 98, time = 1.68 m\n", "INFO [matcher.py:101] Objective:\t134522000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0566\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 99, time = 1.70 m\n", + "INFO [matcher.py:97] Solution 99, time = 1.68 m\n", "INFO [matcher.py:101] Objective:\t134400000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0565\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 100, time = 1.70 m\n", + "INFO [matcher.py:97] Solution 100, time = 1.69 m\n", "INFO [matcher.py:101] Objective:\t134234000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0565\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 101, time = 1.71 m\n", + "INFO [matcher.py:97] Solution 101, time = 1.69 m\n", "INFO [matcher.py:101] Objective:\t134107000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0564\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 102, time = 1.75 m\n", + "INFO [matcher.py:97] Solution 102, time = 1.73 m\n", "INFO [matcher.py:101] Objective:\t133877000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0564\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 103, time = 1.75 m\n", + "INFO [matcher.py:97] Solution 103, time = 1.74 m\n", "INFO [matcher.py:101] Objective:\t133872000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0564\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 104, time = 1.79 m\n", + "INFO [matcher.py:97] Solution 104, time = 1.77 m\n", "INFO [matcher.py:101] Objective:\t133834000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0562\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 105, time = 1.81 m\n", + "INFO [matcher.py:97] Solution 105, time = 1.79 m\n", "INFO [matcher.py:101] Objective:\t133706000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0561\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 106, time = 1.86 m\n", + "INFO [matcher.py:97] Solution 106, time = 1.84 m\n", "INFO [matcher.py:101] Objective:\t133469000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0560\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 107, time = 1.89 m\n", + "INFO [matcher.py:97] Solution 107, time = 1.87 m\n", "INFO [matcher.py:101] Objective:\t133214000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 108, time = 1.89 m\n", + "INFO [matcher.py:97] Solution 108, time = 1.87 m\n", "INFO [matcher.py:101] Objective:\t133090000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 109, time = 1.89 m\n", + "INFO [matcher.py:97] Solution 109, time = 1.87 m\n", "INFO [matcher.py:101] Objective:\t133063000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 110, time = 1.90 m\n", + "INFO [matcher.py:97] Solution 110, time = 1.88 m\n", "INFO [matcher.py:101] Objective:\t133033000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 111, time = 1.92 m\n", + "INFO [matcher.py:97] Solution 111, time = 1.89 m\n", "INFO [matcher.py:101] Objective:\t133028000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 112, time = 1.92 m\n", + "INFO [matcher.py:97] Solution 112, time = 1.90 m\n", "INFO [matcher.py:101] Objective:\t133008000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0558\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 113, time = 1.93 m\n", + "INFO [matcher.py:97] Solution 113, time = 1.91 m\n", "INFO [matcher.py:101] Objective:\t132983000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 114, time = 1.93 m\n", + "INFO [matcher.py:97] Solution 114, time = 1.91 m\n", "INFO [matcher.py:101] Objective:\t132978000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 115, time = 1.98 m\n", + "INFO [matcher.py:97] Solution 115, time = 1.95 m\n", "INFO [matcher.py:101] Objective:\t132841000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0558\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 116, time = 1.98 m\n", + "INFO [matcher.py:97] Solution 116, time = 1.96 m\n", "INFO [matcher.py:101] Objective:\t132785000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0558\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 117, time = 1.98 m\n", + "INFO [matcher.py:97] Solution 117, time = 1.96 m\n", "INFO [matcher.py:101] Objective:\t132779000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0558\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 118, time = 2.04 m\n", + "INFO [matcher.py:97] Solution 118, time = 2.02 m\n", "INFO [matcher.py:101] Objective:\t132600000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 119, time = 2.05 m\n", + "INFO [matcher.py:97] Solution 119, time = 2.02 m\n", "INFO [matcher.py:101] Objective:\t132480000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 120, time = 2.05 m\n", + "INFO [matcher.py:97] Solution 120, time = 2.03 m\n", "INFO [matcher.py:101] Objective:\t132453000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 121, time = 2.06 m\n", + "INFO [matcher.py:97] Solution 121, time = 2.04 m\n", "INFO [matcher.py:101] Objective:\t132264000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 122, time = 2.17 m\n", + "INFO [matcher.py:97] Solution 122, time = 2.16 m\n", "INFO [matcher.py:101] Objective:\t132136000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 123, time = 2.21 m\n", + "INFO [matcher.py:97] Solution 123, time = 2.19 m\n", "INFO [matcher.py:101] Objective:\t132122000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 124, time = 2.22 m\n", + "INFO [matcher.py:97] Solution 124, time = 2.21 m\n", "INFO [matcher.py:101] Objective:\t132117000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 125, time = 2.23 m\n", + "INFO [matcher.py:97] Solution 125, time = 2.21 m\n", "INFO [matcher.py:101] Objective:\t132079000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 126, time = 2.33 m\n", + "INFO [matcher.py:97] Solution 126, time = 2.31 m\n", "INFO [matcher.py:101] Objective:\t132025000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 127, time = 2.35 m\n", + "INFO [matcher.py:97] Solution 127, time = 2.33 m\n", "INFO [matcher.py:101] Objective:\t132007000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 128, time = 2.35 m\n", + "INFO [matcher.py:97] Solution 128, time = 2.33 m\n", "INFO [matcher.py:101] Objective:\t131985000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 129, time = 2.35 m\n", + "INFO [matcher.py:97] Solution 129, time = 2.33 m\n", "INFO [matcher.py:101] Objective:\t131979000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 130, time = 2.37 m\n", + "INFO [matcher.py:97] Solution 130, time = 2.35 m\n", "INFO [matcher.py:101] Objective:\t131957000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 131, time = 2.42 m\n", + "INFO [matcher.py:97] Solution 131, time = 2.39 m\n", "INFO [matcher.py:101] Objective:\t131715000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 132, time = 2.49 m\n", + "INFO [matcher.py:97] Solution 132, time = 2.47 m\n", "INFO [matcher.py:101] Objective:\t131695000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 133, time = 2.51 m\n", + "INFO [matcher.py:97] Solution 133, time = 2.49 m\n", "INFO [matcher.py:101] Objective:\t131689000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 134, time = 2.53 m\n", + "INFO [matcher.py:97] Solution 134, time = 2.51 m\n", "INFO [matcher.py:101] Objective:\t131687000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 135, time = 2.53 m\n", + "INFO [matcher.py:97] Solution 135, time = 2.51 m\n", "INFO [matcher.py:101] Objective:\t131585000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 136, time = 2.54 m\n", + "INFO [matcher.py:97] Solution 136, time = 2.52 m\n", "INFO [matcher.py:101] Objective:\t131572000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 137, time = 2.54 m\n", + "INFO [matcher.py:97] Solution 137, time = 2.52 m\n", "INFO [matcher.py:101] Objective:\t131526000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 138, time = 2.54 m\n", + "INFO [matcher.py:97] Solution 138, time = 2.52 m\n", "INFO [matcher.py:101] Objective:\t131488000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 139, time = 2.60 m\n", + "INFO [matcher.py:97] Solution 139, time = 2.58 m\n", "INFO [matcher.py:101] Objective:\t131421000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 140, time = 2.61 m\n", + "INFO [matcher.py:97] Solution 140, time = 2.58 m\n", "INFO [matcher.py:101] Objective:\t131418000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 141, time = 2.63 m\n", + "INFO [matcher.py:97] Solution 141, time = 2.60 m\n", "INFO [matcher.py:101] Objective:\t131344000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 142, time = 2.63 m\n", + "INFO [matcher.py:97] Solution 142, time = 2.61 m\n", "INFO [matcher.py:101] Objective:\t131338000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 143, time = 2.64 m\n", + "INFO [matcher.py:97] Solution 143, time = 2.61 m\n", "INFO [matcher.py:101] Objective:\t131174000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 144, time = 2.64 m\n", + "INFO [matcher.py:97] Solution 144, time = 2.62 m\n", "INFO [matcher.py:101] Objective:\t131116000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 145, time = 2.76 m\n", + "INFO [matcher.py:97] Solution 145, time = 2.73 m\n", "INFO [matcher.py:101] Objective:\t131101000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 146, time = 2.76 m\n", + "INFO [matcher.py:97] Solution 146, time = 2.73 m\n", "INFO [matcher.py:101] Objective:\t131083000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 147, time = 2.76 m\n", + "INFO [matcher.py:97] Solution 147, time = 2.74 m\n", "INFO [matcher.py:101] Objective:\t131069000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 148, time = 2.77 m\n", + "INFO [matcher.py:97] Solution 148, time = 2.74 m\n", "INFO [matcher.py:101] Objective:\t131061000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 149, time = 2.77 m\n", + "INFO [matcher.py:97] Solution 149, time = 2.74 m\n", "INFO [matcher.py:101] Objective:\t131055000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 150, time = 2.77 m\n", + "INFO [matcher.py:97] Solution 150, time = 2.74 m\n", "INFO [matcher.py:101] Objective:\t131053000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 151, time = 2.78 m\n", + "INFO [matcher.py:97] Solution 151, time = 2.75 m\n", "INFO [matcher.py:101] Objective:\t131017000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 152, time = 2.80 m\n", + "INFO [matcher.py:97] Solution 152, time = 2.77 m\n", "INFO [matcher.py:101] Objective:\t130827000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0553\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 153, time = 2.81 m\n", + "INFO [matcher.py:97] Solution 153, time = 2.77 m\n", "INFO [matcher.py:101] Objective:\t130822000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0553\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 154, time = 2.83 m\n", + "INFO [matcher.py:97] Solution 154, time = 2.79 m\n", "INFO [matcher.py:101] Objective:\t130586000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0553\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 155, time = 2.84 m\n", + "INFO [matcher.py:97] Solution 155, time = 2.81 m\n", "INFO [matcher.py:101] Objective:\t130560000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0552\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 156, time = 2.86 m\n", + "INFO [matcher.py:97] Solution 156, time = 2.82 m\n", "INFO [matcher.py:101] Objective:\t130554000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0553\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 157, time = 2.86 m\n", + "INFO [matcher.py:97] Solution 157, time = 2.83 m\n", "INFO [matcher.py:101] Objective:\t130462000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0553\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 158, time = 2.87 m\n", + "INFO [matcher.py:97] Solution 158, time = 2.84 m\n", "INFO [matcher.py:101] Objective:\t130390000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0552\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 159, time = 2.91 m\n", + "INFO [matcher.py:97] Solution 159, time = 2.87 m\n", "INFO [matcher.py:101] Objective:\t130376000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0552\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 160, time = 2.96 m\n", + "INFO [matcher.py:97] Solution 160, time = 2.93 m\n", "INFO [matcher.py:101] Objective:\t130053000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0552\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 161, time = 2.96 m\n", + "INFO [matcher.py:97] Solution 161, time = 2.93 m\n", "INFO [matcher.py:101] Objective:\t130016000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0551\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 162, time = 2.96 m\n", + "INFO [matcher.py:97] Solution 162, time = 2.93 m\n", "INFO [matcher.py:101] Objective:\t129852000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0551\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 163, time = 2.97 m\n", + "INFO [matcher.py:97] Solution 163, time = 2.94 m\n", "INFO [matcher.py:101] Objective:\t129796000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0551\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 164, time = 2.97 m\n", + "INFO [matcher.py:97] Solution 164, time = 2.94 m\n", "INFO [matcher.py:101] Objective:\t129752000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0551\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 165, time = 2.98 m\n", + "INFO [matcher.py:97] Solution 165, time = 2.94 m\n", "INFO [matcher.py:101] Objective:\t129638000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0550\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 166, time = 3.02 m\n", + "INFO [matcher.py:97] Solution 166, time = 2.98 m\n", "INFO [matcher.py:101] Objective:\t129415000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0550\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 167, time = 3.08 m\n", + "INFO [matcher.py:97] Solution 167, time = 3.04 m\n", "INFO [matcher.py:101] Objective:\t129413000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0549\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 168, time = 3.08 m\n", + "INFO [matcher.py:97] Solution 168, time = 3.05 m\n", "INFO [matcher.py:101] Objective:\t129338000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0549\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 169, time = 3.11 m\n", + "INFO [matcher.py:97] Solution 169, time = 3.07 m\n", "INFO [matcher.py:101] Objective:\t129216000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0548\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 170, time = 3.20 m\n", + "INFO [matcher.py:97] Solution 170, time = 3.11 m\n", "INFO [matcher.py:101] Objective:\t129055000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0539\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 171, time = 3.26 m\n", - "INFO [matcher.py:101] Objective:\t129023000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0548\n", + "INFO [matcher.py:97] Solution 171, time = 3.17 m\n", + "INFO [matcher.py:101] Objective:\t128661000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0546\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", "INFO [matcher.py:97] Solution 172, time = 3.27 m\n", - "INFO [matcher.py:101] Objective:\t128812000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0548\n", + "INFO [matcher.py:101] Objective:\t128657000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0545\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 173, time = 3.27 m\n", - "INFO [matcher.py:101] Objective:\t128809000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0547\n", + "INFO [matcher.py:97] Solution 173, time = 3.28 m\n", + "INFO [matcher.py:101] Objective:\t128319000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0544\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 174, time = 3.28 m\n", - "INFO [matcher.py:101] Objective:\t128793000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0547\n", + "INFO [matcher.py:97] Solution 174, time = 3.46 m\n", + "INFO [matcher.py:101] Objective:\t128266000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0543\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 175, time = 3.38 m\n", - "INFO [matcher.py:101] Objective:\t128688000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0547\n", + "INFO [matcher.py:97] Solution 175, time = 3.67 m\n", + "INFO [matcher.py:101] Objective:\t127794000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0539\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 176, time = 3.39 m\n", - "INFO [matcher.py:101] Objective:\t128255000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0546\n", + "INFO [matcher.py:97] Solution 176, time = 3.72 m\n", + "INFO [matcher.py:101] Objective:\t127703000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0542\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 177, time = 3.55 m\n", - "INFO [matcher.py:101] Objective:\t128243000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0553\n", + "INFO [matcher.py:97] Solution 177, time = 3.73 m\n", + "INFO [matcher.py:101] Objective:\t127624000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0542\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 178, time = 3.56 m\n", - "INFO [matcher.py:101] Objective:\t127543000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0550\n", + "INFO [matcher.py:97] Solution 178, time = 3.77 m\n", + "INFO [matcher.py:101] Objective:\t127604000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0542\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 179, time = 4.02 m\n", - "INFO [matcher.py:101] Objective:\t127017000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0547\n", + "INFO [matcher.py:97] Solution 179, time = 3.78 m\n", + "INFO [matcher.py:101] Objective:\t127576000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0542\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 180, time = 4.49 m\n", - "INFO [matcher.py:101] Objective:\t127008000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0546\n", + "INFO [matcher.py:97] Solution 180, time = 3.78 m\n", + "INFO [matcher.py:101] Objective:\t127565000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 181, time = 4.72 m\n", - "INFO [matcher.py:101] Objective:\t126858000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0545\n", + "INFO [matcher.py:97] Solution 181, time = 3.78 m\n", + "INFO [matcher.py:101] Objective:\t127533000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 182, time = 4.93 m\n", - "INFO [matcher.py:101] Objective:\t125797000.0\n", + "INFO [matcher.py:97] Solution 182, time = 3.78 m\n", + "INFO [matcher.py:101] Objective:\t127526000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 183, time = 3.79 m\n", + "INFO [matcher.py:101] Objective:\t127520000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 184, time = 3.79 m\n", + "INFO [matcher.py:101] Objective:\t127464000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 185, time = 3.79 m\n", + "INFO [matcher.py:101] Objective:\t127463000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 186, time = 3.82 m\n", + "INFO [matcher.py:101] Objective:\t127450000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 187, time = 3.82 m\n", + "INFO [matcher.py:101] Objective:\t127394000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 188, time = 3.83 m\n", + "INFO [matcher.py:101] Objective:\t127388000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 189, time = 3.83 m\n", + "INFO [matcher.py:101] Objective:\t127253000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0540\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 190, time = 3.84 m\n", + "INFO [matcher.py:101] Objective:\t127241000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0540\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 191, time = 3.84 m\n", + "INFO [matcher.py:101] Objective:\t127209000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0539\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 192, time = 3.84 m\n", + "INFO [matcher.py:101] Objective:\t127189000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0539\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 183, time = 5.12 m\n", - "INFO [matcher.py:101] Objective:\t125342000.0\n", + "INFO [matcher.py:97] Solution 193, time = 3.84 m\n", + "INFO [matcher.py:101] Objective:\t126998000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0540\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 194, time = 3.86 m\n", + "INFO [matcher.py:101] Objective:\t126837000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0539\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 195, time = 3.86 m\n", + "INFO [matcher.py:101] Objective:\t126768000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0539\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 184, time = 5.18 m\n", - "INFO [matcher.py:101] Objective:\t54272000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0309\n", + "INFO [matcher.py:97] Solution 196, time = 3.88 m\n", + "INFO [matcher.py:101] Objective:\t126686000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0538\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 197, time = 3.88 m\n", + "INFO [matcher.py:101] Objective:\t126679000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0538\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 198, time = 3.89 m\n", + "INFO [matcher.py:101] Objective:\t126673000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0538\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 199, time = 3.93 m\n", + "INFO [matcher.py:101] Objective:\t126450000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0536\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 200, time = 4.02 m\n", + "INFO [matcher.py:101] Objective:\t126359000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0536\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 201, time = 4.02 m\n", + "INFO [matcher.py:101] Objective:\t126346000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0537\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 202, time = 4.02 m\n", + "INFO [matcher.py:101] Objective:\t126318000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0536\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 203, time = 4.04 m\n", + "INFO [matcher.py:101] Objective:\t125810000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0535\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 204, time = 4.04 m\n", + "INFO [matcher.py:101] Objective:\t125799000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0535\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 205, time = 4.05 m\n", + "INFO [matcher.py:101] Objective:\t125767000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0535\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 206, time = 4.05 m\n", + "INFO [matcher.py:101] Objective:\t125760000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0534\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 207, time = 4.08 m\n", + "INFO [matcher.py:101] Objective:\t125507000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0534\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 208, time = 4.10 m\n", + "INFO [matcher.py:101] Objective:\t125496000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0533\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 209, time = 4.10 m\n", + "INFO [matcher.py:101] Objective:\t125464000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0533\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 210, time = 4.15 m\n", + "INFO [matcher.py:101] Objective:\t125016000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0532\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 211, time = 4.15 m\n", + "INFO [matcher.py:101] Objective:\t124988000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0532\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 212, time = 4.16 m\n", + "INFO [matcher.py:101] Objective:\t124956000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0532\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 213, time = 4.39 m\n", + "INFO [matcher.py:101] Objective:\t124605000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0529\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 214, time = 4.57 m\n", + "INFO [matcher.py:101] Objective:\t124569000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0530\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 215, time = 4.60 m\n", + "INFO [matcher.py:101] Objective:\t124537000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0532\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 216, time = 4.63 m\n", + "INFO [matcher.py:101] Objective:\t124416000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0532\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 217, time = 4.64 m\n", + "INFO [matcher.py:101] Objective:\t124370000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0531\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 218, time = 4.66 m\n", + "INFO [matcher.py:101] Objective:\t123956000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0530\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 219, time = 4.67 m\n", + "INFO [matcher.py:101] Objective:\t123910000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0530\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 220, time = 4.71 m\n", + "INFO [matcher.py:101] Objective:\t123851000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0530\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 221, time = 4.77 m\n", + "INFO [matcher.py:101] Objective:\t123830000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0530\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 222, time = 4.77 m\n", + "INFO [matcher.py:101] Objective:\t123810000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0530\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 223, time = 4.80 m\n", + "INFO [matcher.py:101] Objective:\t123045000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0527\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 224, time = 4.98 m\n", + "INFO [matcher.py:101] Objective:\t122999000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0527\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 225, time = 5.20 m\n", + "INFO [matcher.py:101] Objective:\t122997000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0528\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 226, time = 5.20 m\n", + "INFO [matcher.py:101] Objective:\t122958000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0528\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 227, time = 5.25 m\n", + "INFO [matcher.py:101] Objective:\t122833000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0528\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 228, time = 5.25 m\n", + "INFO [matcher.py:101] Objective:\t122802000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0528\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 229, time = 5.26 m\n", + "INFO [matcher.py:101] Objective:\t122708000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0527\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 230, time = 5.30 m\n", + "INFO [matcher.py:101] Objective:\t122646000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0527\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 231, time = 5.30 m\n", + "INFO [matcher.py:101] Objective:\t122600000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 232, time = 5.31 m\n", + "INFO [matcher.py:101] Objective:\t122464000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 233, time = 5.33 m\n", + "INFO [matcher.py:101] Objective:\t122463000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 234, time = 5.34 m\n", + "INFO [matcher.py:101] Objective:\t122453000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 235, time = 5.34 m\n", + "INFO [matcher.py:101] Objective:\t122421000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0525\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 236, time = 5.35 m\n", + "INFO [matcher.py:101] Objective:\t122333000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 237, time = 5.35 m\n", + "INFO [matcher.py:101] Objective:\t122319000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 238, time = 5.35 m\n", + "INFO [matcher.py:101] Objective:\t122280000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 239, time = 5.35 m\n", + "INFO [matcher.py:101] Objective:\t122118000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 240, time = 5.44 m\n", + "INFO [matcher.py:101] Objective:\t122093000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 241, time = 5.44 m\n", + "INFO [matcher.py:101] Objective:\t121931000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 242, time = 5.44 m\n", + "INFO [matcher.py:101] Objective:\t121912000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 243, time = 5.54 m\n", + "INFO [matcher.py:101] Objective:\t121870000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 244, time = 5.55 m\n", + "INFO [matcher.py:101] Objective:\t121820000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0525\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 185, time = 5.36 m\n", - "INFO [matcher.py:101] Objective:\t54271000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0309\n", + "INFO [matcher.py:97] Solution 245, time = 5.56 m\n", + "INFO [matcher.py:101] Objective:\t121793000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0525\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 246, time = 5.58 m\n", + "INFO [matcher.py:101] Objective:\t120770000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0521\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 247, time = 5.79 m\n", + "INFO [matcher.py:101] Objective:\t120522000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0521\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:618] Status = FEASIBLE\n", - "INFO [matcher.py:619] Number of solutions found: 185\n" + "INFO [matcher.py:619] Number of solutions found: 247\n" ] }, { @@ -2719,34 +3167,34 @@ " 9933\n", " \n", " \n", - " 9965\n", - " 41.035792\n", - " 130.021437\n", - " 80.495109\n", - " 0.0\n", - " 0\n", - " 1\n", + " 9947\n", + " 64.290077\n", + " 168.091011\n", + " 63.511962\n", + " 1.0\n", + " 2\n", + " 2\n", " pool\n", " 0\n", + " 0\n", + " 0\n", " 1\n", - " 1\n", - " 1\n", - " 9965\n", + " 9947\n", " \n", " \n", - " 9981\n", - " 39.006118\n", - " 133.419182\n", - " 71.135407\n", + " 9958\n", + " 51.722321\n", + " 170.350117\n", + " 80.695438\n", " 0.0\n", - " 1\n", + " 2\n", " 4\n", " pool\n", " 0\n", + " 1\n", " 0\n", - " 0\n", - " 0\n", - " 9981\n", + " 1\n", + " 9958\n", " \n", " \n", " 9982\n", @@ -2784,7 +3232,7 @@ "" ], "text/plain": [ - "" + "" ] }, "execution_count": 9, @@ -2804,7 +3252,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] @@ -2931,8 +3379,8 @@ "INFO [matcher.py:139] \t* penalty: l2\n", "INFO [matcher.py:139] \t* solver: saga\n", "INFO [matcher.py:140] \tScore (gamma): 0.0472\n", - "INFO [matcher.py:141] \tSolution time: 0.003 min\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 3/50, 0.003 min) ...\n", + "INFO [matcher.py:141] \tSolution time: 0.004 min\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 3/50, 0.004 min) ...\n", "INFO [matcher.py:136] Best propensity score match found:\n", "INFO [matcher.py:137] \tModel: LogisticRegression\n", "INFO [matcher.py:139] \t* C: 0.0909955270741388\n", @@ -2943,8 +3391,8 @@ "INFO [matcher.py:140] \tScore (gamma): 0.0448\n", "INFO [matcher.py:141] \tSolution time: 0.005 min\n", "INFO [matcher.py:180] Training model SGDClassifier (iter 4/50, 0.005 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 5/50, 0.006 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 6/50, 0.007 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 5/50, 0.007 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 6/50, 0.008 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", "INFO [matcher.py:136] Best propensity score match found:\n", @@ -2955,11 +3403,11 @@ "INFO [matcher.py:139] \t* penalty: l1\n", "INFO [matcher.py:139] \t* solver: saga\n", "INFO [matcher.py:140] \tScore (gamma): 0.0347\n", - "INFO [matcher.py:141] \tSolution time: 0.030 min\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 7/50, 0.030 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 8/50, 0.031 min) ...\n", + "INFO [matcher.py:141] \tSolution time: 0.031 min\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 7/50, 0.031 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 8/50, 0.032 min) ...\n", "INFO [matcher.py:180] Training model LogisticRegression (iter 9/50, 0.033 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 10/50, 0.036 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 10/50, 0.037 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", "INFO [matcher.py:136] Best propensity score match found:\n", @@ -2970,18 +3418,18 @@ "INFO [matcher.py:139] \t* penalty: l1\n", "INFO [matcher.py:139] \t* solver: saga\n", "INFO [matcher.py:140] \tScore (gamma): 0.0331\n", - "INFO [matcher.py:141] \tSolution time: 0.057 min\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 11/50, 0.057 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 12/50, 0.066 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 13/50, 0.067 min) ...\n", + "INFO [matcher.py:141] \tSolution time: 0.061 min\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 11/50, 0.061 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 12/50, 0.071 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 13/50, 0.072 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 14/50, 0.086 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 15/50, 0.089 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 16/50, 0.090 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 17/50, 0.091 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 18/50, 0.094 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 19/50, 0.095 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 14/50, 0.094 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 15/50, 0.097 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 16/50, 0.099 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 17/50, 0.100 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 18/50, 0.103 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 19/50, 0.104 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", "INFO [matcher.py:136] Best propensity score match found:\n", @@ -2992,46 +3440,46 @@ "INFO [matcher.py:139] \t* penalty: l1\n", "INFO [matcher.py:139] \t* solver: saga\n", "INFO [matcher.py:140] \tScore (gamma): 0.0308\n", - "INFO [matcher.py:141] \tSolution time: 0.115 min\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 20/50, 0.116 min) ...\n", + "INFO [matcher.py:141] \tSolution time: 0.130 min\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 20/50, 0.130 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 21/50, 0.135 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 22/50, 0.136 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 23/50, 0.137 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 21/50, 0.151 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 22/50, 0.153 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 23/50, 0.154 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 24/50, 0.158 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 25/50, 0.159 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 26/50, 0.160 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 27/50, 0.172 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 28/50, 0.173 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 29/50, 0.174 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 30/50, 0.179 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 31/50, 0.180 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 32/50, 0.181 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 33/50, 0.184 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 24/50, 0.177 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 25/50, 0.178 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 26/50, 0.179 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 27/50, 0.194 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 28/50, 0.195 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 29/50, 0.196 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 30/50, 0.202 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 31/50, 0.203 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 32/50, 0.204 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 33/50, 0.208 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 34/50, 0.205 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 35/50, 0.214 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 36/50, 0.215 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 37/50, 0.216 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 38/50, 0.217 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 39/50, 0.227 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 40/50, 0.228 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 41/50, 0.229 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 42/50, 0.235 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 43/50, 0.236 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 44/50, 0.237 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 45/50, 0.238 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 46/50, 0.239 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 47/50, 0.240 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 48/50, 0.242 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 34/50, 0.231 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 35/50, 0.241 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 36/50, 0.242 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 37/50, 0.243 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 38/50, 0.244 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 39/50, 0.256 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 40/50, 0.257 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 41/50, 0.258 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 42/50, 0.265 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 43/50, 0.266 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 44/50, 0.267 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 45/50, 0.269 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 46/50, 0.270 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 47/50, 0.271 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 48/50, 0.273 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 49/50, 0.264 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 50/50, 0.265 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 49/50, 0.295 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 50/50, 0.297 min) ...\n", "INFO [matcher.py:136] Best propensity score match found:\n", "INFO [matcher.py:137] \tModel: LogisticRegression\n", "INFO [matcher.py:139] \t* C: 0.7964686611607528\n", @@ -3040,7 +3488,7 @@ "INFO [matcher.py:139] \t* penalty: l1\n", "INFO [matcher.py:139] \t* solver: saga\n", "INFO [matcher.py:140] \tScore (gamma): 0.0308\n", - "INFO [matcher.py:141] \tSolution time: 0.115 min\n", + "INFO [matcher.py:141] \tSolution time: 0.130 min\n", "INFO [matcher.py:577] Hint achieves objective value = 100400.\n", "INFO [matcher.py:579] Applying hints ...\n", "INFO [matcher.py:611] Solving with 4 workers ...\n", @@ -3053,7 +3501,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 2, time = 0.14 m\n", + "INFO [matcher.py:97] Solution 2, time = 0.13 m\n", "INFO [matcher.py:101] Objective:\t115400000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0349\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -3067,7 +3515,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 4, time = 0.15 m\n", + "INFO [matcher.py:97] Solution 4, time = 0.14 m\n", "INFO [matcher.py:101] Objective:\t114400000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0346\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -3088,21 +3536,21 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 7, time = 0.18 m\n", + "INFO [matcher.py:97] Solution 7, time = 0.17 m\n", "INFO [matcher.py:101] Objective:\t101400000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0308\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 8, time = 0.20 m\n", + "INFO [matcher.py:97] Solution 8, time = 0.19 m\n", "INFO [matcher.py:101] Objective:\t100800000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0306\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 9, time = 0.21 m\n", + "INFO [matcher.py:97] Solution 9, time = 0.20 m\n", "INFO [matcher.py:101] Objective:\t100400000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0305\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -3116,14 +3564,14 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 11, time = 0.27 m\n", + "INFO [matcher.py:97] Solution 11, time = 0.26 m\n", "INFO [matcher.py:101] Objective:\t97200000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0298\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 12, time = 0.32 m\n", + "INFO [matcher.py:97] Solution 12, time = 0.31 m\n", "INFO [matcher.py:101] Objective:\t97000000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0298\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -3144,7 +3592,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 15, time = 0.38 m\n", + "INFO [matcher.py:97] Solution 15, time = 0.37 m\n", "INFO [matcher.py:101] Objective:\t90800000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0282\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -3158,7 +3606,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 17, time = 0.43 m\n", + "INFO [matcher.py:97] Solution 17, time = 0.42 m\n", "INFO [matcher.py:101] Objective:\t80800000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0249\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -3172,28 +3620,28 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 19, time = 0.45 m\n", + "INFO [matcher.py:97] Solution 19, time = 0.44 m\n", "INFO [matcher.py:101] Objective:\t80400000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0247\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 20, time = 0.49 m\n", + "INFO [matcher.py:97] Solution 20, time = 0.48 m\n", "INFO [matcher.py:101] Objective:\t19000000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0070\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 21, time = 0.65 m\n", + "INFO [matcher.py:97] Solution 21, time = 0.64 m\n", "INFO [matcher.py:101] Objective:\t18800000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0069\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 22, time = 0.67 m\n", + "INFO [matcher.py:97] Solution 22, time = 0.66 m\n", "INFO [matcher.py:101] Objective:\t18400000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0068\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -3417,7 +3865,7 @@ "" ], "text/plain": [ - "" + "" ] }, "execution_count": 12, diff --git a/demos/card_matcher.html b/demos/card_matcher.html index 1d85537..60fcce0 100644 --- a/demos/card_matcher.html +++ b/demos/card_matcher.html @@ -59,8 +59,8 @@
  • Genetic Matcher
  • Constraint Satisfaction Matcher
  • Cardinality matching
    • @@ -104,6 +104,16 @@

    Cardinality matching

    +

    Cardinality matching is the process of finding the size of the largest subset \(\hat{P}\) of a pool of patient \(P\) within some “distance” of a given target population:

    +

    \begin{equation} +\begin{aligned} +& \underset{\hat{P}}{\text{maximize}} +& & |\hat{P}| \\ +& \text{subject to} +& & |\mu_{\hat{P},k} - \mu_{T,k}| \leq \delta \textrm{ for all }k +\end{aligned} +\end{equation}

    +

    where \(k\) indexes the covariates of \(P\) and \(T\). In cardinality matching, at least as implemented here, we search only for the size of the largest subset. Then in a second step, we optimize the balance (distance) among all subsets of the determined size.

    [1]:
    @@ -348,15 +358,23 @@

    Cardinality matching16000 rows × 12 columns

    -
    -

    Optimize pool size subject to balance constraint

    +
    +

    Optimize pool size with balance constraint

    [4]:
    -
    matcher = ConstraintSatisfactionMatcher(
+
    # Note that by default, gamma uses the standardized mean difference
+# to calculate distance. The ConstraintSatisfactionMatcher, however,
+# can only optimize linear objectives. It is not an error to pass
+# gamma with standardized_difference=True, at this is only affects
+# reporting, but to make the reporting consistent with what we're
+# optimizing, we explicitly pass standardized_difference=False here.
+
+gamma = GammaBalance(m, standardize_difference=False)
+matcher = ConstraintSatisfactionMatcher(
     matching_data=m,
-    objective='gamma',
+    objective=gamma,
     max_mismatch=0.05,
     time_limit=600
 )
@@ -379,86 +397,84 @@ 
    Optimize pool size subject to balance constraint
 
    [5]:
 
    
 
    
-
    gamma = GammaBalance(m, standardize_difference=False)
-gamma.per_feature_loss(match_card.get_population('pool')).max()
+
    gamma.per_feature_loss(match_card.get_population('pool')).max()
 
    
 
    
 
    
-
    
-
    
-
    
-
    
-
    -INFO:pybalance.utils.preprocess:Discretized age with bins [18.02, 27.51, 37.01, 46.51, 56.0, 65.5, 75.0].
-INFO:pybalance.utils.preprocess:Discretized height with bins [125.0, 136.67, 148.33, 159.99, 171.66, 183.32, 194.99].
-INFO:pybalance.utils.preprocess:Discretized weight with bins [50.01, 61.67, 73.34, 85.0, 96.67, 108.33, 120.0].
-
    
-
    
 
    
 
    [5]:
 
    
@@ -482,26 +498,27 @@ 
    Optimize pool size subject to balance constraint
 
    
 
    
-../_images/demos_card_matcher_7_0.png
+../_images/demos_card_matcher_9_0.png
 
    
 
    
 
    
 
    
 
    
 
    
-../_images/demos_card_matcher_7_1.png
+../_images/demos_card_matcher_9_1.png
    -
    -

    Optimize balance with balance constraint

    +
    +

    Optimize balance with size and balance constraints

    +

    Now that we have determined the optimal size of the matched population, let’s optimize the balance for all subsets of that size. For this, we create a second matcher object, setting size constraints and keeping the balance constraint (max_mismatch).

    [7]:
 
    matcher = ConstraintSatisfactionMatcher(
     matching_data=m,
-    objective='gamma',
+    objective=gamma,
     max_mismatch=0.05,
     pool_size=len(match_card.get_population('pool')),
     target_size=len(match_card.get_population('target')),
@@ -516,9 +533,6 @@ 
    Optimize balance with balance constraint
 
    -INFO:pybalance.utils.preprocess:Discretized age with bins [18.02, 27.51, 37.01, 46.51, 56.0, 65.5, 75.0].
-INFO:pybalance.utils.preprocess:Discretized height with bins [125.0, 136.67, 148.33, 159.99, 171.66, 183.32, 194.99].
-INFO:pybalance.utils.preprocess:Discretized weight with bins [50.01, 61.67, 73.34, 85.0, 96.67, 108.33, 120.0].
 INFO:pybalance.lp.matcher:Scaling features by factor 200.00 in order to use integer solver with <= 0.0000% loss.
 INFO:pybalance.lp.matcher:Solving for match population with pool size = 4182 and target size = 1000 subject to 0.05 balance constraint.
 INFO:pybalance.lp.matcher:Matching on 27 dimensions ...
@@ -526,46 +540,46 @@ 
    Optimize balance with balance constraint
 
    
 
    
-../_images/demos_card_matcher_10_0.png
+../_images/demos_card_matcher_13_0.png
    -../_images/demos_card_matcher_10_1.png +../_images/demos_card_matcher_13_1.png

    Optimize balance without balance constraint

    +

    You can also remove the balance constraint, if you don’t care about individual mismatched features. Here we run a matcher fixed to the size of the optimal subset size but relax the mismatch constraint.

    [9]:
 
    matcher = ConstraintSatisfactionMatcher(
     matching_data=m,
-    objective='gamma',
+    objective=gamma,
     pool_size=len(match_card.get_population('pool')),
     target_size=len(match_card.get_population('target')),
     time_limit=600
@@ -620,9 +635,6 @@ 
    Optimize balance without balance constraint
 
    -INFO:pybalance.utils.preprocess:Discretized age with bins [18.02, 27.51, 37.01, 46.51, 56.0, 65.5, 75.0].
-INFO:pybalance.utils.preprocess:Discretized height with bins [125.0, 136.67, 148.33, 159.99, 171.66, 183.32, 194.99].
-INFO:pybalance.utils.preprocess:Discretized weight with bins [50.01, 61.67, 73.34, 85.0, 96.67, 108.33, 120.0].
 INFO:pybalance.lp.matcher:Scaling features by factor 200.00 in order to use integer solver with <= 0.0000% loss.
 INFO:pybalance.lp.matcher:Solving for match population with pool size = 4182 and target size = 1000 subject to None balance constraint.
 INFO:pybalance.lp.matcher:Matching on 27 dimensions ...
@@ -630,81 +642,81 @@ 
    Optimize balance without balance constraint
 
    
 
    
-../_images/demos_card_matcher_13_0.png
+../_images/demos_card_matcher_17_0.png
    -../_images/demos_card_matcher_13_1.png +../_images/demos_card_matcher_17_1.png
    +

    Note that the solution no longer satisfies the max_mismatch constraint.

    [11]:
    -
    beta = GammaBalance(m, standardize_difference=False)
-beta.per_feature_loss(match_dist.get_population('pool')).max()
+
    gamma.per_feature_loss(match_dist2.get_population('pool')).max()
    -
    -
    -
    -
    -
    -INFO:pybalance.utils.preprocess:Discretized age with bins [18.02, 27.51, 37.01, 46.51, 56.0, 65.5, 75.0].
-INFO:pybalance.utils.preprocess:Discretized height with bins [125.0, 136.67, 148.33, 159.99, 171.66, 183.32, 194.99].
-INFO:pybalance.utils.preprocess:Discretized weight with bins [50.01, 61.67, 73.34, 85.0, 96.67, 108.33, 120.0].
-
    -
    [11]:
 
    -tensor(0.0500)
+tensor(0.1696)
    diff --git a/demos/card_matcher.ipynb b/demos/card_matcher.ipynb index d91dad4..9520a10 100644 --- a/demos/card_matcher.ipynb +++ b/demos/card_matcher.ipynb @@ -8,6 +8,26 @@ "# Cardinality matching" ] }, + { + "cell_type": "markdown", + "id": "14c518ee-3bc0-493a-9eb3-e2a289642823", + "metadata": {}, + "source": [ + "Cardinality matching is the process of finding the size of the largest subset $\\hat{P}$ of a pool of patient $P$ within some \"distance\" of a given target population:\n", + "\n", + "\\begin{equation}\n", + "\\begin{aligned}\n", + "& \\underset{\\hat{P}}{\\text{maximize}}\n", + "& & |\\hat{P}| \\\\\n", + "& \\text{subject to}\n", + "& & |\\mu_{\\hat{P},k} - \\mu_{T,k}| \\leq \\delta \\textrm{ for all }k\n", + "\\end{aligned}\n", + "\\end{equation}\n", + "\n", + "where $k$ indexes the covariates of $P$ and $T$. In cardinality matching, at least as implemented here, we search only for the size of the largest subset.\n", + "Then in a second step, we optimize the balance (distance) among all subsets of the determined size." + ] + }, { "cell_type": "code", "execution_count": 1, @@ -253,7 +273,7 @@ "" ], "text/plain": [ - "" + "" ] }, "execution_count": 3, @@ -271,7 +291,7 @@ "id": "4e699cd6-9f4c-4493-a261-0a704f288c64", "metadata": {}, "source": [ - "## Optimize pool size subject to balance constraint" + "## Optimize pool size with balance constraint" ] }, { @@ -294,93 +314,109 @@ "INFO:pybalance.lp.matcher:Calculating bounds on feature variables ...\n", "INFO:pybalance.lp.matcher:Applying size constraints on pool and target ...\n", "INFO:pybalance.lp.matcher:Solving with 4 workers ...\n", - "INFO:pybalance.lp.matcher:Initial balance score: 0.2095\n", + "INFO:pybalance.lp.matcher:Initial balance score: 0.1236\n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 1, time = 0.34 m\n", + "INFO:pybalance.lp.matcher:Solution 1, time = 0.36 m\n", "INFO:pybalance.lp.matcher:Objective:\t13153.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0117\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0068\n", "INFO:pybalance.lp.matcher:Patients (pool):\t1847\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 2, time = 0.45 m\n", + "INFO:pybalance.lp.matcher:Solution 2, time = 0.47 m\n", "INFO:pybalance.lp.matcher:Objective:\t12981.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0280\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0163\n", "INFO:pybalance.lp.matcher:Patients (pool):\t2019\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 3, time = 0.47 m\n", - "INFO:pybalance.lp.matcher:Objective:\t12979.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0382\n", - "INFO:pybalance.lp.matcher:Patients (pool):\t2021\n", + "INFO:pybalance.lp.matcher:Solution 3, time = 0.53 m\n", + "INFO:pybalance.lp.matcher:Objective:\t12937.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0171\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t2063\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 4, time = 0.49 m\n", - "INFO:pybalance.lp.matcher:Objective:\t12909.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0380\n", - "INFO:pybalance.lp.matcher:Patients (pool):\t2091\n", + "INFO:pybalance.lp.matcher:Solution 4, time = 0.55 m\n", + "INFO:pybalance.lp.matcher:Objective:\t12910.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0178\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t2090\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 5, time = 0.51 m\n", - "INFO:pybalance.lp.matcher:Objective:\t12879.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0383\n", - "INFO:pybalance.lp.matcher:Patients (pool):\t2121\n", + "INFO:pybalance.lp.matcher:Solution 5, time = 0.98 m\n", + "INFO:pybalance.lp.matcher:Objective:\t12907.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0179\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t2093\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 6, time = 0.85 m\n", - "INFO:pybalance.lp.matcher:Objective:\t12827.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0387\n", - "INFO:pybalance.lp.matcher:Patients (pool):\t2173\n", + "INFO:pybalance.lp.matcher:Solution 6, time = 1.28 m\n", + "INFO:pybalance.lp.matcher:Objective:\t12906.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0250\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t2094\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 7, time = 1.94 m\n", - "INFO:pybalance.lp.matcher:Objective:\t11000.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0648\n", - "INFO:pybalance.lp.matcher:Patients (pool):\t4000\n", + "INFO:pybalance.lp.matcher:Solution 7, time = 2.22 m\n", + "INFO:pybalance.lp.matcher:Objective:\t12689.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0259\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t2311\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 8, time = 2.10 m\n", + "INFO:pybalance.lp.matcher:Solution 8, time = 2.39 m\n", + "INFO:pybalance.lp.matcher:Objective:\t12632.0\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0260\n", + "INFO:pybalance.lp.matcher:Patients (pool):\t2368\n", + "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", + "INFO:pybalance.lp.matcher: \n", + "INFO:pybalance.lp.matcher:=========================================\n", + "INFO:pybalance.lp.matcher:Solution 9, time = 2.39 m\n", "INFO:pybalance.lp.matcher:Objective:\t10818.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0704\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0413\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:Status = FEASIBLE\n", - "INFO:pybalance.lp.matcher:Number of solutions found: 8\n" + "INFO:pybalance.lp.matcher:Number of solutions found: 9\n" ] } ], "source": [ + "# Note that by default, gamma uses the standardized mean difference \n", + "# to calculate distance. The ConstraintSatisfactionMatcher, however,\n", + "# can only optimize linear objectives. It is not an error to pass \n", + "# gamma with standardized_difference=True, at this is only affects\n", + "# reporting, but to make the reporting consistent with what we're \n", + "# optimizing, we explicitly pass standardized_difference=False here.\n", + "\n", + "gamma = GammaBalance(m, standardize_difference=False)\n", "matcher = ConstraintSatisfactionMatcher(\n", " matching_data=m, \n", - " objective='gamma', \n", - " max_mismatch=0.05, \n", + " objective=gamma,\n", + " max_mismatch=0.05,\n", " time_limit=600\n", ")\n", "match_card = matcher.match()" ] }, + { + "cell_type": "markdown", + "id": "47da2013-6ffe-4d68-a9b6-d87f89e0ccf4", + "metadata": {}, + "source": [ + "Note that as the optimization progresses, the size of the matched population increases and the balance also increases. This will generally be the case, since it is harder to find a larger set of patients (they have more degrees of freedom) that match a given target. Increased mismatch is the tradeoff of having a larger matched population.\n", + "\n", + "Let's check that the found solution satisfies the balance constraint:" + ] + }, { "cell_type": "code", "execution_count": 5, "id": "a76e9375-d27f-4f9d-aea4-27d1f7e7a483", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pybalance.utils.preprocess:Discretized age with bins [18.02, 27.51, 37.01, 46.51, 56.0, 65.5, 75.0].\n", - "INFO:pybalance.utils.preprocess:Discretized height with bins [125.0, 136.67, 148.33, 159.99, 171.66, 183.32, 194.99].\n", - "INFO:pybalance.utils.preprocess:Discretized weight with bins [50.01, 61.67, 73.34, 85.0, 96.67, 108.33, 120.0].\n" - ] - }, { "data": { "text/plain": [ @@ -393,7 +429,6 @@ } ], "source": [ - "gamma = GammaBalance(m, standardize_difference=False)\n", "gamma.per_feature_loss(match_card.get_population('pool')).max()" ] }, @@ -405,7 +440,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] @@ -435,7 +470,15 @@ "id": "ce715a25-d006-419d-ab1b-c6dfe3e77c29", "metadata": {}, "source": [ - "## Optimize balance with balance constraint" + "## Optimize balance with size and balance constraints" + ] + }, + { + "cell_type": "markdown", + "id": "5dde7ed9-75af-486c-82c6-2e69ae040ab0", + "metadata": {}, + "source": [ + "Now that we have determined the optimal size of the matched population, let's optimize the balance for all subsets of that size. For this, we create a second matcher object, setting size constraints and keeping the balance constraint (max_mismatch)." ] }, { @@ -448,9 +491,6 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO:pybalance.utils.preprocess:Discretized age with bins [18.02, 27.51, 37.01, 46.51, 56.0, 65.5, 75.0].\n", - "INFO:pybalance.utils.preprocess:Discretized height with bins [125.0, 136.67, 148.33, 159.99, 171.66, 183.32, 194.99].\n", - "INFO:pybalance.utils.preprocess:Discretized weight with bins [50.01, 61.67, 73.34, 85.0, 96.67, 108.33, 120.0].\n", "INFO:pybalance.lp.matcher:Scaling features by factor 200.00 in order to use integer solver with <= 0.0000% loss.\n", "INFO:pybalance.lp.matcher:Solving for match population with pool size = 4182 and target size = 1000 subject to 0.05 balance constraint.\n", "INFO:pybalance.lp.matcher:Matching on 27 dimensions ...\n", @@ -458,46 +498,46 @@ "INFO:pybalance.lp.matcher:Calculating bounds on feature variables ...\n", "INFO:pybalance.lp.matcher:Applying size constraints on pool and target ...\n", "INFO:pybalance.lp.matcher:Solving with 4 workers ...\n", - "INFO:pybalance.lp.matcher:Initial balance score: 0.2095\n", + "INFO:pybalance.lp.matcher:Initial balance score: 0.1236\n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 1, time = 0.25 m\n", + "INFO:pybalance.lp.matcher:Solution 1, time = 0.29 m\n", "INFO:pybalance.lp.matcher:Objective:\t825443200.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0644\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0366\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 2, time = 0.31 m\n", + "INFO:pybalance.lp.matcher:Solution 2, time = 0.37 m\n", "INFO:pybalance.lp.matcher:Objective:\t825304800.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0644\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0365\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 3, time = 0.47 m\n", + "INFO:pybalance.lp.matcher:Solution 3, time = 0.55 m\n", "INFO:pybalance.lp.matcher:Objective:\t733533600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0557\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0325\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 4, time = 3.09 m\n", + "INFO:pybalance.lp.matcher:Solution 4, time = 3.59 m\n", "INFO:pybalance.lp.matcher:Objective:\t733527200.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0557\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0325\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 5, time = 3.59 m\n", + "INFO:pybalance.lp.matcher:Solution 5, time = 4.10 m\n", "INFO:pybalance.lp.matcher:Objective:\t733465600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0557\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0325\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 6, time = 3.73 m\n", + "INFO:pybalance.lp.matcher:Solution 6, time = 4.24 m\n", "INFO:pybalance.lp.matcher:Objective:\t733395200.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0557\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0325\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", @@ -509,7 +549,7 @@ "source": [ "matcher = ConstraintSatisfactionMatcher(\n", " matching_data=m, \n", - " objective='gamma', \n", + " objective=gamma, \n", " max_mismatch=0.05, \n", " pool_size=len(match_card.get_population('pool')),\n", " target_size=len(match_card.get_population('target')),\n", @@ -559,6 +599,14 @@ "## Optimize balance without balance constraint" ] }, + { + "cell_type": "markdown", + "id": "dea30112-beb0-49b8-95bc-c7f95444fcaf", + "metadata": {}, + "source": [ + "You can also remove the balance constraint, if you don't care about individual mismatched features. Here we run a matcher fixed to the size of the optimal subset size but relax the mismatch constraint." + ] + }, { "cell_type": "code", "execution_count": 9, @@ -569,9 +617,6 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO:pybalance.utils.preprocess:Discretized age with bins [18.02, 27.51, 37.01, 46.51, 56.0, 65.5, 75.0].\n", - "INFO:pybalance.utils.preprocess:Discretized height with bins [125.0, 136.67, 148.33, 159.99, 171.66, 183.32, 194.99].\n", - "INFO:pybalance.utils.preprocess:Discretized weight with bins [50.01, 61.67, 73.34, 85.0, 96.67, 108.33, 120.0].\n", "INFO:pybalance.lp.matcher:Scaling features by factor 200.00 in order to use integer solver with <= 0.0000% loss.\n", "INFO:pybalance.lp.matcher:Solving for match population with pool size = 4182 and target size = 1000 subject to None balance constraint.\n", "INFO:pybalance.lp.matcher:Matching on 27 dimensions ...\n", @@ -579,81 +624,81 @@ "INFO:pybalance.lp.matcher:Calculating bounds on feature variables ...\n", "INFO:pybalance.lp.matcher:Applying size constraints on pool and target ...\n", "INFO:pybalance.lp.matcher:Solving with 4 workers ...\n", - "INFO:pybalance.lp.matcher:Initial balance score: 0.2095\n", + "INFO:pybalance.lp.matcher:Initial balance score: 0.1236\n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 1, time = 0.07 m\n", "INFO:pybalance.lp.matcher:Objective:\t2127925600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1582\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0942\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 2, time = 0.11 m\n", "INFO:pybalance.lp.matcher:Objective:\t2020125600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1489\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0895\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 3, time = 0.13 m\n", "INFO:pybalance.lp.matcher:Objective:\t2019725600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1489\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0894\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 4, time = 0.20 m\n", "INFO:pybalance.lp.matcher:Objective:\t2016325600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1487\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0893\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 5, time = 0.26 m\n", "INFO:pybalance.lp.matcher:Objective:\t2015325600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1486\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0892\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 6, time = 0.32 m\n", "INFO:pybalance.lp.matcher:Objective:\t2012125600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1483\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0891\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 7, time = 0.32 m\n", "INFO:pybalance.lp.matcher:Objective:\t2011725600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1482\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0891\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 8, time = 0.34 m\n", "INFO:pybalance.lp.matcher:Objective:\t2011525600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1482\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0891\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", "INFO:pybalance.lp.matcher:Solution 9, time = 0.36 m\n", "INFO:pybalance.lp.matcher:Objective:\t2011325600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.1482\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0891\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 10, time = 0.66 m\n", + "INFO:pybalance.lp.matcher:Solution 10, time = 0.65 m\n", "INFO:pybalance.lp.matcher:Objective:\t478921600.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0346\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0212\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", "INFO:pybalance.lp.matcher:=========================================\n", - "INFO:pybalance.lp.matcher:Solution 11, time = 1.19 m\n", + "INFO:pybalance.lp.matcher:Solution 11, time = 1.18 m\n", "INFO:pybalance.lp.matcher:Objective:\t478920000.0\n", - "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0346\n", + "INFO:pybalance.lp.matcher:Balance (gamma):\t0.0212\n", "INFO:pybalance.lp.matcher:Patients (pool):\t4182\n", "INFO:pybalance.lp.matcher:Patients (target):\t1000\n", "INFO:pybalance.lp.matcher: \n", @@ -665,7 +710,7 @@ "source": [ "matcher = ConstraintSatisfactionMatcher(\n", " matching_data=m, \n", - " objective='gamma', \n", + " objective=gamma, \n", " pool_size=len(match_card.get_population('pool')),\n", " target_size=len(match_card.get_population('target')),\n", " time_limit=600\n", @@ -706,25 +751,24 @@ "fig = plot_categoric_features(match_dist2)" ] }, + { + "cell_type": "markdown", + "id": "e82f82fb-eab8-4966-99fd-bd4d5d87e7cc", + "metadata": {}, + "source": [ + "Note that the solution no longer satisfies the max_mismatch constraint." + ] + }, { "cell_type": "code", "execution_count": 11, "id": "014a2b7e-d2a5-46be-bd25-299ff3bf52df", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:pybalance.utils.preprocess:Discretized age with bins [18.02, 27.51, 37.01, 46.51, 56.0, 65.5, 75.0].\n", - "INFO:pybalance.utils.preprocess:Discretized height with bins [125.0, 136.67, 148.33, 159.99, 171.66, 183.32, 194.99].\n", - "INFO:pybalance.utils.preprocess:Discretized weight with bins [50.01, 61.67, 73.34, 85.0, 96.67, 108.33, 120.0].\n" - ] - }, { "data": { "text/plain": [ - "tensor(0.0500)" + "tensor(0.1696)" ] }, "execution_count": 11, @@ -733,8 +777,7 @@ } ], "source": [ - "beta = GammaBalance(m, standardize_difference=False)\n", - "beta.per_feature_loss(match_dist.get_population('pool')).max()" + "gamma.per_feature_loss(match_dist2.get_population('pool')).max()" ] } ], diff --git a/demos/lp_matcher.html b/demos/lp_matcher.html index bef35ea..c20a9c9 100644 --- a/demos/lp_matcher.html +++ b/demos/lp_matcher.html @@ -104,7 +104,18 @@

    Constraint Satisfaction Matcher

    -

    The ConstraintSatisfactionMatcher can be used to optimize any linear function of the baseline covariates. In this demo notebook, we show how to call the matcher in the PyBalance library.

    +

    The ConstraintSatisfactionMatcher can be used to optimize any linear function of the baseline covariates. We support constraints on the size of the subset populations and the allowed mismatch.

    +

    Here, we demonstrate the optimization of balance subject to size constraints only. Namely, we solve:

    +

    \begin{equation} +\begin{aligned} +& \underset{\hat{P}}{\text{minimize}} +& & \sum_k |\mu_{\hat{P},k} - \mu_{T,k}| \\ +& \text{subject to} +& & |\hat{P}| = P^* \\ +& & & |\hat{T}| = T^* \\ +\end{aligned} +\end{equation}

    +

    where \(P\) and \(T\) refer to two populations we are trying to match, \(\hat{P}\) and \(\hat{T}\) are the subsets of \(P\) and \(T\) we are seeking, \(P^*\) and \(T^*\) are fixed integers, and \(k\) indexes the covariates of \(P\) and \(T\).

    [1]:
    @@ -572,21 +583,21 @@

    Optimize Beta (Mean Absolute SMD) @@ -2745,34 +3190,34 @@

    Optimize Beta With Cross Terms Added" ], "text/plain": [ - "" + "" ] }, "execution_count": 3, @@ -497,21 +511,21 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 22, time = 0.55 m\n", + "INFO [matcher.py:97] Solution 22, time = 0.56 m\n", "INFO [matcher.py:101] Objective:\t22084000.0\n", "INFO [matcher.py:120] Balance (beta):\t0.0122\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 23, time = 3.16 m\n", + "INFO [matcher.py:97] Solution 23, time = 3.14 m\n", "INFO [matcher.py:101] Objective:\t22083000.0\n", "INFO [matcher.py:120] Balance (beta):\t0.0101\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 24, time = 5.78 m\n", + "INFO [matcher.py:97] Solution 24, time = 5.71 m\n", "INFO [matcher.py:101] Objective:\t22082000.0\n", "INFO [matcher.py:120] Balance (beta):\t0.0102\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -735,7 +749,7 @@ "

    " ], "text/plain": [ - "" + "" ] }, "execution_count": 5, @@ -975,7 +989,7 @@ "
    " ], "text/plain": [ - "" + "" ] }, "execution_count": 6, @@ -1133,7 +1147,7 @@ "INFO [preprocess.py:442] Added cross term binary_2 * binary_3 to matching features.\n", "INFO [preprocess.py:442] Added cross term binary_2 * height to matching features.\n", "INFO [preprocess.py:442] Added cross term binary_0 * binary_2 to matching features.\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 1/50, 0.000 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 1/50, 0.001 min) ...\n", "INFO [matcher.py:136] Best propensity score match found:\n", "INFO [matcher.py:137] \tModel: SGDClassifier\n", "INFO [matcher.py:139] \t* alpha: 0.1045355473186929\n", @@ -1183,48 +1197,48 @@ "INFO [matcher.py:180] Training model LogisticRegression (iter 6/50, 0.024 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 7/50, 0.044 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 7/50, 0.046 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 8/50, 0.065 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 9/50, 0.066 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 8/50, 0.067 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 9/50, 0.068 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 10/50, 0.083 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 11/50, 0.102 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 12/50, 0.103 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 13/50, 0.115 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 10/50, 0.085 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 11/50, 0.104 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 12/50, 0.105 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 13/50, 0.118 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 14/50, 0.137 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 15/50, 0.138 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 16/50, 0.139 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 14/50, 0.139 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 15/50, 0.140 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 16/50, 0.141 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 17/50, 0.161 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 18/50, 0.162 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 19/50, 0.163 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 20/50, 0.164 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 21/50, 0.165 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 17/50, 0.163 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 18/50, 0.164 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 19/50, 0.165 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 20/50, 0.166 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 21/50, 0.167 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 22/50, 0.186 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 23/50, 0.187 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 24/50, 0.188 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 25/50, 0.189 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 26/50, 0.190 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 27/50, 0.195 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 28/50, 0.196 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 22/50, 0.188 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 23/50, 0.189 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 24/50, 0.190 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 25/50, 0.191 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 26/50, 0.192 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 27/50, 0.196 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 28/50, 0.198 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 29/50, 0.216 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 30/50, 0.217 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 31/50, 0.232 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 29/50, 0.214 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 30/50, 0.215 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 31/50, 0.230 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 32/50, 0.254 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 33/50, 0.255 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 34/50, 0.258 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 32/50, 0.251 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 33/50, 0.252 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 34/50, 0.254 min) ...\n", "INFO [matcher.py:136] Best propensity score match found:\n", "INFO [matcher.py:137] \tModel: SGDClassifier\n", "INFO [matcher.py:139] \t* alpha: 0.02606111348517078\n", @@ -1235,24 +1249,24 @@ "INFO [matcher.py:139] \t* max_iter: 1500\n", "INFO [matcher.py:139] \t* penalty: l2\n", "INFO [matcher.py:140] \tScore (beta_x): 0.0603\n", - "INFO [matcher.py:141] \tSolution time: 0.259 min\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 35/50, 0.259 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 36/50, 0.260 min) ...\n", + "INFO [matcher.py:141] \tSolution time: 0.255 min\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 35/50, 0.255 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 36/50, 0.256 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 37/50, 0.282 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 38/50, 0.284 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 39/50, 0.285 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 37/50, 0.278 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 38/50, 0.280 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 39/50, 0.281 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 40/50, 0.306 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 41/50, 0.322 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 42/50, 0.331 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 43/50, 0.333 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 44/50, 0.334 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 45/50, 0.346 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 46/50, 0.352 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 47/50, 0.353 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 40/50, 0.302 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 41/50, 0.319 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 42/50, 0.328 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 43/50, 0.330 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 44/50, 0.331 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 45/50, 0.344 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 46/50, 0.351 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 47/50, 0.352 min) ...\n", "INFO [matcher.py:180] Training model SGDClassifier (iter 48/50, 0.354 min) ...\n", "INFO [matcher.py:180] Training model SGDClassifier (iter 49/50, 0.355 min) ...\n", "INFO [matcher.py:180] Training model SGDClassifier (iter 50/50, 0.356 min) ...\n", @@ -1266,7 +1280,7 @@ "INFO [matcher.py:139] \t* max_iter: 1500\n", "INFO [matcher.py:139] \t* penalty: l2\n", "INFO [matcher.py:140] \tScore (beta_x): 0.0603\n", - "INFO [matcher.py:141] \tSolution time: 0.259 min\n", + "INFO [matcher.py:141] \tSolution time: 0.255 min\n", "INFO [matcher.py:577] Hint achieves objective value = 147332.\n", "INFO [matcher.py:579] Applying hints ...\n", "INFO [matcher.py:611] Solving with 4 workers ...\n", @@ -1321,7 +1335,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 8, time = 0.12 m\n", + "INFO [matcher.py:97] Solution 8, time = 0.13 m\n", "INFO [matcher.py:101] Objective:\t145229000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0596\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1405,7 +1419,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 20, time = 0.27 m\n", + "INFO [matcher.py:97] Solution 20, time = 0.26 m\n", "INFO [matcher.py:101] Objective:\t143574000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0591\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1426,7 +1440,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 23, time = 0.30 m\n", + "INFO [matcher.py:97] Solution 23, time = 0.29 m\n", "INFO [matcher.py:101] Objective:\t142588000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0589\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1461,7 +1475,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 28, time = 0.36 m\n", + "INFO [matcher.py:97] Solution 28, time = 0.35 m\n", "INFO [matcher.py:101] Objective:\t141681000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0587\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1489,7 +1503,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 32, time = 0.40 m\n", + "INFO [matcher.py:97] Solution 32, time = 0.39 m\n", "INFO [matcher.py:101] Objective:\t141229000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0586\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1503,7 +1517,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 34, time = 0.44 m\n", + "INFO [matcher.py:97] Solution 34, time = 0.43 m\n", "INFO [matcher.py:101] Objective:\t140938000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0584\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1573,7 +1587,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 44, time = 0.68 m\n", + "INFO [matcher.py:97] Solution 44, time = 0.67 m\n", "INFO [matcher.py:101] Objective:\t139980000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0583\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1636,7 +1650,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 53, time = 0.77 m\n", + "INFO [matcher.py:97] Solution 53, time = 0.78 m\n", "INFO [matcher.py:101] Objective:\t138879000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0580\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1769,7 +1783,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 72, time = 1.11 m\n", + "INFO [matcher.py:97] Solution 72, time = 1.10 m\n", "INFO [matcher.py:101] Objective:\t136838000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0574\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1783,28 +1797,28 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 74, time = 1.25 m\n", + "INFO [matcher.py:97] Solution 74, time = 1.24 m\n", "INFO [matcher.py:101] Objective:\t136654000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0574\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 75, time = 1.25 m\n", + "INFO [matcher.py:97] Solution 75, time = 1.24 m\n", "INFO [matcher.py:101] Objective:\t136559000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0574\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 76, time = 1.26 m\n", + "INFO [matcher.py:97] Solution 76, time = 1.25 m\n", "INFO [matcher.py:101] Objective:\t136503000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0573\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 77, time = 1.26 m\n", + "INFO [matcher.py:97] Solution 77, time = 1.25 m\n", "INFO [matcher.py:101] Objective:\t136457000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0573\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1818,14 +1832,14 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 79, time = 1.37 m\n", + "INFO [matcher.py:97] Solution 79, time = 1.36 m\n", "INFO [matcher.py:101] Objective:\t136386000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0574\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 80, time = 1.38 m\n", + "INFO [matcher.py:97] Solution 80, time = 1.37 m\n", "INFO [matcher.py:101] Objective:\t136349000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0573\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -1839,735 +1853,1169 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 82, time = 1.39 m\n", + "INFO [matcher.py:97] Solution 82, time = 1.38 m\n", "INFO [matcher.py:101] Objective:\t136286000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0573\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 83, time = 1.39 m\n", + "INFO [matcher.py:97] Solution 83, time = 1.38 m\n", "INFO [matcher.py:101] Objective:\t136020000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0573\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 84, time = 1.43 m\n", + "INFO [matcher.py:97] Solution 84, time = 1.41 m\n", "INFO [matcher.py:101] Objective:\t135535000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0570\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 85, time = 1.48 m\n", + "INFO [matcher.py:97] Solution 85, time = 1.47 m\n", "INFO [matcher.py:101] Objective:\t135513000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0570\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 86, time = 1.49 m\n", + "INFO [matcher.py:97] Solution 86, time = 1.48 m\n", "INFO [matcher.py:101] Objective:\t135473000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0570\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 87, time = 1.49 m\n", + "INFO [matcher.py:97] Solution 87, time = 1.48 m\n", "INFO [matcher.py:101] Objective:\t135452000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0570\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 88, time = 1.53 m\n", + "INFO [matcher.py:97] Solution 88, time = 1.51 m\n", "INFO [matcher.py:101] Objective:\t135375000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0570\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 89, time = 1.54 m\n", + "INFO [matcher.py:97] Solution 89, time = 1.53 m\n", "INFO [matcher.py:101] Objective:\t135312000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0569\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 90, time = 1.55 m\n", + "INFO [matcher.py:97] Solution 90, time = 1.54 m\n", "INFO [matcher.py:101] Objective:\t134988000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0568\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 91, time = 1.59 m\n", + "INFO [matcher.py:97] Solution 91, time = 1.58 m\n", "INFO [matcher.py:101] Objective:\t134977000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0568\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 92, time = 1.60 m\n", + "INFO [matcher.py:97] Solution 92, time = 1.59 m\n", "INFO [matcher.py:101] Objective:\t134937000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0568\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 93, time = 1.60 m\n", + "INFO [matcher.py:97] Solution 93, time = 1.59 m\n", "INFO [matcher.py:101] Objective:\t134931000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0568\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 94, time = 1.62 m\n", + "INFO [matcher.py:97] Solution 94, time = 1.61 m\n", "INFO [matcher.py:101] Objective:\t134909000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0567\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 95, time = 1.68 m\n", + "INFO [matcher.py:97] Solution 95, time = 1.66 m\n", "INFO [matcher.py:101] Objective:\t134887000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0566\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 96, time = 1.69 m\n", + "INFO [matcher.py:97] Solution 96, time = 1.67 m\n", "INFO [matcher.py:101] Objective:\t134614000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0566\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 97, time = 1.69 m\n", + "INFO [matcher.py:97] Solution 97, time = 1.68 m\n", "INFO [matcher.py:101] Objective:\t134579000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0566\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 98, time = 1.69 m\n", + "INFO [matcher.py:97] Solution 98, time = 1.68 m\n", "INFO [matcher.py:101] Objective:\t134522000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0566\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 99, time = 1.70 m\n", + "INFO [matcher.py:97] Solution 99, time = 1.68 m\n", "INFO [matcher.py:101] Objective:\t134400000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0565\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 100, time = 1.70 m\n", + "INFO [matcher.py:97] Solution 100, time = 1.69 m\n", "INFO [matcher.py:101] Objective:\t134234000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0565\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 101, time = 1.71 m\n", + "INFO [matcher.py:97] Solution 101, time = 1.69 m\n", "INFO [matcher.py:101] Objective:\t134107000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0564\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 102, time = 1.75 m\n", + "INFO [matcher.py:97] Solution 102, time = 1.73 m\n", "INFO [matcher.py:101] Objective:\t133877000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0564\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 103, time = 1.75 m\n", + "INFO [matcher.py:97] Solution 103, time = 1.74 m\n", "INFO [matcher.py:101] Objective:\t133872000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0564\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 104, time = 1.79 m\n", + "INFO [matcher.py:97] Solution 104, time = 1.77 m\n", "INFO [matcher.py:101] Objective:\t133834000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0562\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 105, time = 1.81 m\n", + "INFO [matcher.py:97] Solution 105, time = 1.79 m\n", "INFO [matcher.py:101] Objective:\t133706000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0561\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 106, time = 1.86 m\n", + "INFO [matcher.py:97] Solution 106, time = 1.84 m\n", "INFO [matcher.py:101] Objective:\t133469000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0560\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 107, time = 1.89 m\n", + "INFO [matcher.py:97] Solution 107, time = 1.87 m\n", "INFO [matcher.py:101] Objective:\t133214000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 108, time = 1.89 m\n", + "INFO [matcher.py:97] Solution 108, time = 1.87 m\n", "INFO [matcher.py:101] Objective:\t133090000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 109, time = 1.89 m\n", + "INFO [matcher.py:97] Solution 109, time = 1.87 m\n", "INFO [matcher.py:101] Objective:\t133063000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 110, time = 1.90 m\n", + "INFO [matcher.py:97] Solution 110, time = 1.88 m\n", "INFO [matcher.py:101] Objective:\t133033000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 111, time = 1.92 m\n", + "INFO [matcher.py:97] Solution 111, time = 1.89 m\n", "INFO [matcher.py:101] Objective:\t133028000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 112, time = 1.92 m\n", + "INFO [matcher.py:97] Solution 112, time = 1.90 m\n", "INFO [matcher.py:101] Objective:\t133008000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0558\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 113, time = 1.93 m\n", + "INFO [matcher.py:97] Solution 113, time = 1.91 m\n", "INFO [matcher.py:101] Objective:\t132983000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 114, time = 1.93 m\n", + "INFO [matcher.py:97] Solution 114, time = 1.91 m\n", "INFO [matcher.py:101] Objective:\t132978000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0559\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 115, time = 1.98 m\n", + "INFO [matcher.py:97] Solution 115, time = 1.95 m\n", "INFO [matcher.py:101] Objective:\t132841000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0558\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 116, time = 1.98 m\n", + "INFO [matcher.py:97] Solution 116, time = 1.96 m\n", "INFO [matcher.py:101] Objective:\t132785000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0558\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 117, time = 1.98 m\n", + "INFO [matcher.py:97] Solution 117, time = 1.96 m\n", "INFO [matcher.py:101] Objective:\t132779000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0558\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 118, time = 2.04 m\n", + "INFO [matcher.py:97] Solution 118, time = 2.02 m\n", "INFO [matcher.py:101] Objective:\t132600000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 119, time = 2.05 m\n", + "INFO [matcher.py:97] Solution 119, time = 2.02 m\n", "INFO [matcher.py:101] Objective:\t132480000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 120, time = 2.05 m\n", + "INFO [matcher.py:97] Solution 120, time = 2.03 m\n", "INFO [matcher.py:101] Objective:\t132453000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 121, time = 2.06 m\n", + "INFO [matcher.py:97] Solution 121, time = 2.04 m\n", "INFO [matcher.py:101] Objective:\t132264000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 122, time = 2.17 m\n", + "INFO [matcher.py:97] Solution 122, time = 2.16 m\n", "INFO [matcher.py:101] Objective:\t132136000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 123, time = 2.21 m\n", + "INFO [matcher.py:97] Solution 123, time = 2.19 m\n", "INFO [matcher.py:101] Objective:\t132122000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 124, time = 2.22 m\n", + "INFO [matcher.py:97] Solution 124, time = 2.21 m\n", "INFO [matcher.py:101] Objective:\t132117000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 125, time = 2.23 m\n", + "INFO [matcher.py:97] Solution 125, time = 2.21 m\n", "INFO [matcher.py:101] Objective:\t132079000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0557\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 126, time = 2.33 m\n", + "INFO [matcher.py:97] Solution 126, time = 2.31 m\n", "INFO [matcher.py:101] Objective:\t132025000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 127, time = 2.35 m\n", + "INFO [matcher.py:97] Solution 127, time = 2.33 m\n", "INFO [matcher.py:101] Objective:\t132007000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 128, time = 2.35 m\n", + "INFO [matcher.py:97] Solution 128, time = 2.33 m\n", "INFO [matcher.py:101] Objective:\t131985000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 129, time = 2.35 m\n", + "INFO [matcher.py:97] Solution 129, time = 2.33 m\n", "INFO [matcher.py:101] Objective:\t131979000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 130, time = 2.37 m\n", + "INFO [matcher.py:97] Solution 130, time = 2.35 m\n", "INFO [matcher.py:101] Objective:\t131957000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 131, time = 2.42 m\n", + "INFO [matcher.py:97] Solution 131, time = 2.39 m\n", "INFO [matcher.py:101] Objective:\t131715000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 132, time = 2.49 m\n", + "INFO [matcher.py:97] Solution 132, time = 2.47 m\n", "INFO [matcher.py:101] Objective:\t131695000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 133, time = 2.51 m\n", + "INFO [matcher.py:97] Solution 133, time = 2.49 m\n", "INFO [matcher.py:101] Objective:\t131689000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 134, time = 2.53 m\n", + "INFO [matcher.py:97] Solution 134, time = 2.51 m\n", "INFO [matcher.py:101] Objective:\t131687000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 135, time = 2.53 m\n", + "INFO [matcher.py:97] Solution 135, time = 2.51 m\n", "INFO [matcher.py:101] Objective:\t131585000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 136, time = 2.54 m\n", + "INFO [matcher.py:97] Solution 136, time = 2.52 m\n", "INFO [matcher.py:101] Objective:\t131572000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 137, time = 2.54 m\n", + "INFO [matcher.py:97] Solution 137, time = 2.52 m\n", "INFO [matcher.py:101] Objective:\t131526000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 138, time = 2.54 m\n", + "INFO [matcher.py:97] Solution 138, time = 2.52 m\n", "INFO [matcher.py:101] Objective:\t131488000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0556\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 139, time = 2.60 m\n", + "INFO [matcher.py:97] Solution 139, time = 2.58 m\n", "INFO [matcher.py:101] Objective:\t131421000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 140, time = 2.61 m\n", + "INFO [matcher.py:97] Solution 140, time = 2.58 m\n", "INFO [matcher.py:101] Objective:\t131418000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 141, time = 2.63 m\n", + "INFO [matcher.py:97] Solution 141, time = 2.60 m\n", "INFO [matcher.py:101] Objective:\t131344000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 142, time = 2.63 m\n", + "INFO [matcher.py:97] Solution 142, time = 2.61 m\n", "INFO [matcher.py:101] Objective:\t131338000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 143, time = 2.64 m\n", + "INFO [matcher.py:97] Solution 143, time = 2.61 m\n", "INFO [matcher.py:101] Objective:\t131174000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0555\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 144, time = 2.64 m\n", + "INFO [matcher.py:97] Solution 144, time = 2.62 m\n", "INFO [matcher.py:101] Objective:\t131116000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 145, time = 2.76 m\n", + "INFO [matcher.py:97] Solution 145, time = 2.73 m\n", "INFO [matcher.py:101] Objective:\t131101000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 146, time = 2.76 m\n", + "INFO [matcher.py:97] Solution 146, time = 2.73 m\n", "INFO [matcher.py:101] Objective:\t131083000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 147, time = 2.76 m\n", + "INFO [matcher.py:97] Solution 147, time = 2.74 m\n", "INFO [matcher.py:101] Objective:\t131069000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 148, time = 2.77 m\n", + "INFO [matcher.py:97] Solution 148, time = 2.74 m\n", "INFO [matcher.py:101] Objective:\t131061000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 149, time = 2.77 m\n", + "INFO [matcher.py:97] Solution 149, time = 2.74 m\n", "INFO [matcher.py:101] Objective:\t131055000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 150, time = 2.77 m\n", + "INFO [matcher.py:97] Solution 150, time = 2.74 m\n", "INFO [matcher.py:101] Objective:\t131053000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 151, time = 2.78 m\n", + "INFO [matcher.py:97] Solution 151, time = 2.75 m\n", "INFO [matcher.py:101] Objective:\t131017000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0554\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 152, time = 2.80 m\n", + "INFO [matcher.py:97] Solution 152, time = 2.77 m\n", "INFO [matcher.py:101] Objective:\t130827000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0553\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 153, time = 2.81 m\n", + "INFO [matcher.py:97] Solution 153, time = 2.77 m\n", "INFO [matcher.py:101] Objective:\t130822000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0553\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 154, time = 2.83 m\n", + "INFO [matcher.py:97] Solution 154, time = 2.79 m\n", "INFO [matcher.py:101] Objective:\t130586000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0553\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 155, time = 2.84 m\n", + "INFO [matcher.py:97] Solution 155, time = 2.81 m\n", "INFO [matcher.py:101] Objective:\t130560000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0552\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 156, time = 2.86 m\n", + "INFO [matcher.py:97] Solution 156, time = 2.82 m\n", "INFO [matcher.py:101] Objective:\t130554000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0553\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 157, time = 2.86 m\n", + "INFO [matcher.py:97] Solution 157, time = 2.83 m\n", "INFO [matcher.py:101] Objective:\t130462000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0553\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 158, time = 2.87 m\n", + "INFO [matcher.py:97] Solution 158, time = 2.84 m\n", "INFO [matcher.py:101] Objective:\t130390000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0552\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 159, time = 2.91 m\n", + "INFO [matcher.py:97] Solution 159, time = 2.87 m\n", "INFO [matcher.py:101] Objective:\t130376000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0552\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 160, time = 2.96 m\n", + "INFO [matcher.py:97] Solution 160, time = 2.93 m\n", "INFO [matcher.py:101] Objective:\t130053000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0552\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 161, time = 2.96 m\n", + "INFO [matcher.py:97] Solution 161, time = 2.93 m\n", "INFO [matcher.py:101] Objective:\t130016000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0551\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 162, time = 2.96 m\n", + "INFO [matcher.py:97] Solution 162, time = 2.93 m\n", "INFO [matcher.py:101] Objective:\t129852000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0551\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 163, time = 2.97 m\n", + "INFO [matcher.py:97] Solution 163, time = 2.94 m\n", "INFO [matcher.py:101] Objective:\t129796000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0551\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 164, time = 2.97 m\n", + "INFO [matcher.py:97] Solution 164, time = 2.94 m\n", "INFO [matcher.py:101] Objective:\t129752000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0551\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 165, time = 2.98 m\n", + "INFO [matcher.py:97] Solution 165, time = 2.94 m\n", "INFO [matcher.py:101] Objective:\t129638000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0550\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 166, time = 3.02 m\n", + "INFO [matcher.py:97] Solution 166, time = 2.98 m\n", "INFO [matcher.py:101] Objective:\t129415000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0550\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 167, time = 3.08 m\n", + "INFO [matcher.py:97] Solution 167, time = 3.04 m\n", "INFO [matcher.py:101] Objective:\t129413000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0549\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 168, time = 3.08 m\n", + "INFO [matcher.py:97] Solution 168, time = 3.05 m\n", "INFO [matcher.py:101] Objective:\t129338000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0549\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 169, time = 3.11 m\n", + "INFO [matcher.py:97] Solution 169, time = 3.07 m\n", "INFO [matcher.py:101] Objective:\t129216000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0548\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 170, time = 3.20 m\n", + "INFO [matcher.py:97] Solution 170, time = 3.11 m\n", "INFO [matcher.py:101] Objective:\t129055000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0539\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 171, time = 3.26 m\n", - "INFO [matcher.py:101] Objective:\t129023000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0548\n", + "INFO [matcher.py:97] Solution 171, time = 3.17 m\n", + "INFO [matcher.py:101] Objective:\t128661000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0546\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", "INFO [matcher.py:97] Solution 172, time = 3.27 m\n", - "INFO [matcher.py:101] Objective:\t128812000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0548\n", + "INFO [matcher.py:101] Objective:\t128657000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0545\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 173, time = 3.27 m\n", - "INFO [matcher.py:101] Objective:\t128809000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0547\n", + "INFO [matcher.py:97] Solution 173, time = 3.28 m\n", + "INFO [matcher.py:101] Objective:\t128319000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0544\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 174, time = 3.28 m\n", - "INFO [matcher.py:101] Objective:\t128793000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0547\n", + "INFO [matcher.py:97] Solution 174, time = 3.46 m\n", + "INFO [matcher.py:101] Objective:\t128266000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0543\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 175, time = 3.38 m\n", - "INFO [matcher.py:101] Objective:\t128688000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0547\n", + "INFO [matcher.py:97] Solution 175, time = 3.67 m\n", + "INFO [matcher.py:101] Objective:\t127794000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0539\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 176, time = 3.39 m\n", - "INFO [matcher.py:101] Objective:\t128255000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0546\n", + "INFO [matcher.py:97] Solution 176, time = 3.72 m\n", + "INFO [matcher.py:101] Objective:\t127703000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0542\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 177, time = 3.55 m\n", - "INFO [matcher.py:101] Objective:\t128243000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0553\n", + "INFO [matcher.py:97] Solution 177, time = 3.73 m\n", + "INFO [matcher.py:101] Objective:\t127624000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0542\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 178, time = 3.56 m\n", - "INFO [matcher.py:101] Objective:\t127543000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0550\n", + "INFO [matcher.py:97] Solution 178, time = 3.77 m\n", + "INFO [matcher.py:101] Objective:\t127604000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0542\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 179, time = 4.02 m\n", - "INFO [matcher.py:101] Objective:\t127017000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0547\n", + "INFO [matcher.py:97] Solution 179, time = 3.78 m\n", + "INFO [matcher.py:101] Objective:\t127576000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0542\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 180, time = 4.49 m\n", - "INFO [matcher.py:101] Objective:\t127008000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0546\n", + "INFO [matcher.py:97] Solution 180, time = 3.78 m\n", + "INFO [matcher.py:101] Objective:\t127565000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 181, time = 4.72 m\n", - "INFO [matcher.py:101] Objective:\t126858000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0545\n", + "INFO [matcher.py:97] Solution 181, time = 3.78 m\n", + "INFO [matcher.py:101] Objective:\t127533000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 182, time = 4.93 m\n", - "INFO [matcher.py:101] Objective:\t125797000.0\n", + "INFO [matcher.py:97] Solution 182, time = 3.78 m\n", + "INFO [matcher.py:101] Objective:\t127526000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 183, time = 3.79 m\n", + "INFO [matcher.py:101] Objective:\t127520000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 184, time = 3.79 m\n", + "INFO [matcher.py:101] Objective:\t127464000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 185, time = 3.79 m\n", + "INFO [matcher.py:101] Objective:\t127463000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 186, time = 3.82 m\n", + "INFO [matcher.py:101] Objective:\t127450000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 187, time = 3.82 m\n", + "INFO [matcher.py:101] Objective:\t127394000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 188, time = 3.83 m\n", + "INFO [matcher.py:101] Objective:\t127388000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0541\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 189, time = 3.83 m\n", + "INFO [matcher.py:101] Objective:\t127253000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0540\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 190, time = 3.84 m\n", + "INFO [matcher.py:101] Objective:\t127241000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0540\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 191, time = 3.84 m\n", + "INFO [matcher.py:101] Objective:\t127209000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0539\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 192, time = 3.84 m\n", + "INFO [matcher.py:101] Objective:\t127189000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0539\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 183, time = 5.12 m\n", - "INFO [matcher.py:101] Objective:\t125342000.0\n", + "INFO [matcher.py:97] Solution 193, time = 3.84 m\n", + "INFO [matcher.py:101] Objective:\t126998000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0540\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 194, time = 3.86 m\n", + "INFO [matcher.py:101] Objective:\t126837000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0539\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 195, time = 3.86 m\n", + "INFO [matcher.py:101] Objective:\t126768000.0\n", "INFO [matcher.py:120] Balance (beta_x):\t0.0539\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 184, time = 5.18 m\n", - "INFO [matcher.py:101] Objective:\t54272000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0309\n", + "INFO [matcher.py:97] Solution 196, time = 3.88 m\n", + "INFO [matcher.py:101] Objective:\t126686000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0538\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 197, time = 3.88 m\n", + "INFO [matcher.py:101] Objective:\t126679000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0538\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 198, time = 3.89 m\n", + "INFO [matcher.py:101] Objective:\t126673000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0538\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 199, time = 3.93 m\n", + "INFO [matcher.py:101] Objective:\t126450000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0536\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 200, time = 4.02 m\n", + "INFO [matcher.py:101] Objective:\t126359000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0536\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 201, time = 4.02 m\n", + "INFO [matcher.py:101] Objective:\t126346000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0537\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 202, time = 4.02 m\n", + "INFO [matcher.py:101] Objective:\t126318000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0536\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 203, time = 4.04 m\n", + "INFO [matcher.py:101] Objective:\t125810000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0535\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 204, time = 4.04 m\n", + "INFO [matcher.py:101] Objective:\t125799000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0535\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 205, time = 4.05 m\n", + "INFO [matcher.py:101] Objective:\t125767000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0535\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 206, time = 4.05 m\n", + "INFO [matcher.py:101] Objective:\t125760000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0534\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 207, time = 4.08 m\n", + "INFO [matcher.py:101] Objective:\t125507000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0534\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 208, time = 4.10 m\n", + "INFO [matcher.py:101] Objective:\t125496000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0533\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 209, time = 4.10 m\n", + "INFO [matcher.py:101] Objective:\t125464000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0533\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 210, time = 4.15 m\n", + "INFO [matcher.py:101] Objective:\t125016000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0532\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 211, time = 4.15 m\n", + "INFO [matcher.py:101] Objective:\t124988000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0532\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 212, time = 4.16 m\n", + "INFO [matcher.py:101] Objective:\t124956000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0532\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 213, time = 4.39 m\n", + "INFO [matcher.py:101] Objective:\t124605000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0529\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 214, time = 4.57 m\n", + "INFO [matcher.py:101] Objective:\t124569000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0530\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 215, time = 4.60 m\n", + "INFO [matcher.py:101] Objective:\t124537000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0532\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 216, time = 4.63 m\n", + "INFO [matcher.py:101] Objective:\t124416000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0532\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 217, time = 4.64 m\n", + "INFO [matcher.py:101] Objective:\t124370000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0531\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 218, time = 4.66 m\n", + "INFO [matcher.py:101] Objective:\t123956000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0530\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 219, time = 4.67 m\n", + "INFO [matcher.py:101] Objective:\t123910000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0530\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 220, time = 4.71 m\n", + "INFO [matcher.py:101] Objective:\t123851000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0530\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 221, time = 4.77 m\n", + "INFO [matcher.py:101] Objective:\t123830000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0530\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 222, time = 4.77 m\n", + "INFO [matcher.py:101] Objective:\t123810000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0530\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 223, time = 4.80 m\n", + "INFO [matcher.py:101] Objective:\t123045000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0527\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 224, time = 4.98 m\n", + "INFO [matcher.py:101] Objective:\t122999000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0527\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 225, time = 5.20 m\n", + "INFO [matcher.py:101] Objective:\t122997000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0528\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 226, time = 5.20 m\n", + "INFO [matcher.py:101] Objective:\t122958000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0528\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 227, time = 5.25 m\n", + "INFO [matcher.py:101] Objective:\t122833000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0528\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 228, time = 5.25 m\n", + "INFO [matcher.py:101] Objective:\t122802000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0528\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 229, time = 5.26 m\n", + "INFO [matcher.py:101] Objective:\t122708000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0527\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 230, time = 5.30 m\n", + "INFO [matcher.py:101] Objective:\t122646000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0527\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 231, time = 5.30 m\n", + "INFO [matcher.py:101] Objective:\t122600000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 232, time = 5.31 m\n", + "INFO [matcher.py:101] Objective:\t122464000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 233, time = 5.33 m\n", + "INFO [matcher.py:101] Objective:\t122463000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 234, time = 5.34 m\n", + "INFO [matcher.py:101] Objective:\t122453000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 235, time = 5.34 m\n", + "INFO [matcher.py:101] Objective:\t122421000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0525\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 236, time = 5.35 m\n", + "INFO [matcher.py:101] Objective:\t122333000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 237, time = 5.35 m\n", + "INFO [matcher.py:101] Objective:\t122319000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 238, time = 5.35 m\n", + "INFO [matcher.py:101] Objective:\t122280000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 239, time = 5.35 m\n", + "INFO [matcher.py:101] Objective:\t122118000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 240, time = 5.44 m\n", + "INFO [matcher.py:101] Objective:\t122093000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 241, time = 5.44 m\n", + "INFO [matcher.py:101] Objective:\t121931000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 242, time = 5.44 m\n", + "INFO [matcher.py:101] Objective:\t121912000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 243, time = 5.54 m\n", + "INFO [matcher.py:101] Objective:\t121870000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0526\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 244, time = 5.55 m\n", + "INFO [matcher.py:101] Objective:\t121820000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0525\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 185, time = 5.36 m\n", - "INFO [matcher.py:101] Objective:\t54271000.0\n", - "INFO [matcher.py:120] Balance (beta_x):\t0.0309\n", + "INFO [matcher.py:97] Solution 245, time = 5.56 m\n", + "INFO [matcher.py:101] Objective:\t121793000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0525\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 246, time = 5.58 m\n", + "INFO [matcher.py:101] Objective:\t120770000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0521\n", + "INFO [matcher.py:125] Patients (pool):\t1000\n", + "INFO [matcher.py:126] Patients (target):\t1000\n", + "INFO [matcher.py:140] \n", + "INFO [matcher.py:96] =========================================\n", + "INFO [matcher.py:97] Solution 247, time = 5.79 m\n", + "INFO [matcher.py:101] Objective:\t120522000.0\n", + "INFO [matcher.py:120] Balance (beta_x):\t0.0521\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:618] Status = FEASIBLE\n", - "INFO [matcher.py:619] Number of solutions found: 185\n" + "INFO [matcher.py:619] Number of solutions found: 247\n" ] }, { @@ -2719,34 +3167,34 @@ " 9933\n", " \n", " \n", - " 9965\n", - " 41.035792\n", - " 130.021437\n", - " 80.495109\n", - " 0.0\n", - " 0\n", - " 1\n", + " 9947\n", + " 64.290077\n", + " 168.091011\n", + " 63.511962\n", + " 1.0\n", + " 2\n", + " 2\n", " pool\n", " 0\n", + " 0\n", + " 0\n", " 1\n", - " 1\n", - " 1\n", - " 9965\n", + " 9947\n", " \n", " \n", - " 9981\n", - " 39.006118\n", - " 133.419182\n", - " 71.135407\n", + " 9958\n", + " 51.722321\n", + " 170.350117\n", + " 80.695438\n", " 0.0\n", - " 1\n", + " 2\n", " 4\n", " pool\n", " 0\n", + " 1\n", " 0\n", - " 0\n", - " 0\n", - " 9981\n", + " 1\n", + " 9958\n", " \n", " \n", " 9982\n", @@ -2784,7 +3232,7 @@ "" ], "text/plain": [ - "" + "" ] }, "execution_count": 9, @@ -2804,7 +3252,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] @@ -2931,8 +3379,8 @@ "INFO [matcher.py:139] \t* penalty: l2\n", "INFO [matcher.py:139] \t* solver: saga\n", "INFO [matcher.py:140] \tScore (gamma): 0.0472\n", - "INFO [matcher.py:141] \tSolution time: 0.003 min\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 3/50, 0.003 min) ...\n", + "INFO [matcher.py:141] \tSolution time: 0.004 min\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 3/50, 0.004 min) ...\n", "INFO [matcher.py:136] Best propensity score match found:\n", "INFO [matcher.py:137] \tModel: LogisticRegression\n", "INFO [matcher.py:139] \t* C: 0.0909955270741388\n", @@ -2943,8 +3391,8 @@ "INFO [matcher.py:140] \tScore (gamma): 0.0448\n", "INFO [matcher.py:141] \tSolution time: 0.005 min\n", "INFO [matcher.py:180] Training model SGDClassifier (iter 4/50, 0.005 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 5/50, 0.006 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 6/50, 0.007 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 5/50, 0.007 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 6/50, 0.008 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", "INFO [matcher.py:136] Best propensity score match found:\n", @@ -2955,11 +3403,11 @@ "INFO [matcher.py:139] \t* penalty: l1\n", "INFO [matcher.py:139] \t* solver: saga\n", "INFO [matcher.py:140] \tScore (gamma): 0.0347\n", - "INFO [matcher.py:141] \tSolution time: 0.030 min\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 7/50, 0.030 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 8/50, 0.031 min) ...\n", + "INFO [matcher.py:141] \tSolution time: 0.031 min\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 7/50, 0.031 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 8/50, 0.032 min) ...\n", "INFO [matcher.py:180] Training model LogisticRegression (iter 9/50, 0.033 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 10/50, 0.036 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 10/50, 0.037 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", "INFO [matcher.py:136] Best propensity score match found:\n", @@ -2970,18 +3418,18 @@ "INFO [matcher.py:139] \t* penalty: l1\n", "INFO [matcher.py:139] \t* solver: saga\n", "INFO [matcher.py:140] \tScore (gamma): 0.0331\n", - "INFO [matcher.py:141] \tSolution time: 0.057 min\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 11/50, 0.057 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 12/50, 0.066 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 13/50, 0.067 min) ...\n", + "INFO [matcher.py:141] \tSolution time: 0.061 min\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 11/50, 0.061 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 12/50, 0.071 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 13/50, 0.072 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 14/50, 0.086 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 15/50, 0.089 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 16/50, 0.090 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 17/50, 0.091 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 18/50, 0.094 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 19/50, 0.095 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 14/50, 0.094 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 15/50, 0.097 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 16/50, 0.099 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 17/50, 0.100 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 18/50, 0.103 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 19/50, 0.104 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", "INFO [matcher.py:136] Best propensity score match found:\n", @@ -2992,46 +3440,46 @@ "INFO [matcher.py:139] \t* penalty: l1\n", "INFO [matcher.py:139] \t* solver: saga\n", "INFO [matcher.py:140] \tScore (gamma): 0.0308\n", - "INFO [matcher.py:141] \tSolution time: 0.115 min\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 20/50, 0.116 min) ...\n", + "INFO [matcher.py:141] \tSolution time: 0.130 min\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 20/50, 0.130 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 21/50, 0.135 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 22/50, 0.136 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 23/50, 0.137 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 21/50, 0.151 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 22/50, 0.153 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 23/50, 0.154 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 24/50, 0.158 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 25/50, 0.159 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 26/50, 0.160 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 27/50, 0.172 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 28/50, 0.173 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 29/50, 0.174 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 30/50, 0.179 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 31/50, 0.180 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 32/50, 0.181 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 33/50, 0.184 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 24/50, 0.177 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 25/50, 0.178 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 26/50, 0.179 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 27/50, 0.194 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 28/50, 0.195 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 29/50, 0.196 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 30/50, 0.202 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 31/50, 0.203 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 32/50, 0.204 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 33/50, 0.208 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 34/50, 0.205 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 35/50, 0.214 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 36/50, 0.215 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 37/50, 0.216 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 38/50, 0.217 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 39/50, 0.227 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 40/50, 0.228 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 41/50, 0.229 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 42/50, 0.235 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 43/50, 0.236 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 44/50, 0.237 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 45/50, 0.238 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 46/50, 0.239 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 47/50, 0.240 min) ...\n", - "INFO [matcher.py:180] Training model LogisticRegression (iter 48/50, 0.242 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 34/50, 0.231 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 35/50, 0.241 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 36/50, 0.242 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 37/50, 0.243 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 38/50, 0.244 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 39/50, 0.256 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 40/50, 0.257 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 41/50, 0.258 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 42/50, 0.265 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 43/50, 0.266 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 44/50, 0.267 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 45/50, 0.269 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 46/50, 0.270 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 47/50, 0.271 min) ...\n", + "INFO [matcher.py:180] Training model LogisticRegression (iter 48/50, 0.273 min) ...\n", "/opt/miniconda3/envs/pybalance/lib/python3.9/site-packages/sklearn/linear_model/_sag.py:350: ConvergenceWarning: The max_iter was reached which means the coef_ did not converge\n", " warnings.warn(\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 49/50, 0.264 min) ...\n", - "INFO [matcher.py:180] Training model SGDClassifier (iter 50/50, 0.265 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 49/50, 0.295 min) ...\n", + "INFO [matcher.py:180] Training model SGDClassifier (iter 50/50, 0.297 min) ...\n", "INFO [matcher.py:136] Best propensity score match found:\n", "INFO [matcher.py:137] \tModel: LogisticRegression\n", "INFO [matcher.py:139] \t* C: 0.7964686611607528\n", @@ -3040,7 +3488,7 @@ "INFO [matcher.py:139] \t* penalty: l1\n", "INFO [matcher.py:139] \t* solver: saga\n", "INFO [matcher.py:140] \tScore (gamma): 0.0308\n", - "INFO [matcher.py:141] \tSolution time: 0.115 min\n", + "INFO [matcher.py:141] \tSolution time: 0.130 min\n", "INFO [matcher.py:577] Hint achieves objective value = 100400.\n", "INFO [matcher.py:579] Applying hints ...\n", "INFO [matcher.py:611] Solving with 4 workers ...\n", @@ -3053,7 +3501,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 2, time = 0.14 m\n", + "INFO [matcher.py:97] Solution 2, time = 0.13 m\n", "INFO [matcher.py:101] Objective:\t115400000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0349\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -3067,7 +3515,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 4, time = 0.15 m\n", + "INFO [matcher.py:97] Solution 4, time = 0.14 m\n", "INFO [matcher.py:101] Objective:\t114400000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0346\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -3088,21 +3536,21 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 7, time = 0.18 m\n", + "INFO [matcher.py:97] Solution 7, time = 0.17 m\n", "INFO [matcher.py:101] Objective:\t101400000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0308\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 8, time = 0.20 m\n", + "INFO [matcher.py:97] Solution 8, time = 0.19 m\n", "INFO [matcher.py:101] Objective:\t100800000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0306\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 9, time = 0.21 m\n", + "INFO [matcher.py:97] Solution 9, time = 0.20 m\n", "INFO [matcher.py:101] Objective:\t100400000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0305\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -3116,14 +3564,14 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 11, time = 0.27 m\n", + "INFO [matcher.py:97] Solution 11, time = 0.26 m\n", "INFO [matcher.py:101] Objective:\t97200000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0298\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 12, time = 0.32 m\n", + "INFO [matcher.py:97] Solution 12, time = 0.31 m\n", "INFO [matcher.py:101] Objective:\t97000000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0298\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -3144,7 +3592,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 15, time = 0.38 m\n", + "INFO [matcher.py:97] Solution 15, time = 0.37 m\n", "INFO [matcher.py:101] Objective:\t90800000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0282\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -3158,7 +3606,7 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 17, time = 0.43 m\n", + "INFO [matcher.py:97] Solution 17, time = 0.42 m\n", "INFO [matcher.py:101] Objective:\t80800000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0249\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -3172,28 +3620,28 @@ "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 19, time = 0.45 m\n", + "INFO [matcher.py:97] Solution 19, time = 0.44 m\n", "INFO [matcher.py:101] Objective:\t80400000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0247\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 20, time = 0.49 m\n", + "INFO [matcher.py:97] Solution 20, time = 0.48 m\n", "INFO [matcher.py:101] Objective:\t19000000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0070\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 21, time = 0.65 m\n", + "INFO [matcher.py:97] Solution 21, time = 0.64 m\n", "INFO [matcher.py:101] Objective:\t18800000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0069\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", "INFO [matcher.py:126] Patients (target):\t1000\n", "INFO [matcher.py:140] \n", "INFO [matcher.py:96] =========================================\n", - "INFO [matcher.py:97] Solution 22, time = 0.67 m\n", + "INFO [matcher.py:97] Solution 22, time = 0.66 m\n", "INFO [matcher.py:101] Objective:\t18400000.0\n", "INFO [matcher.py:120] Balance (gamma):\t0.0068\n", "INFO [matcher.py:125] Patients (pool):\t1000\n", @@ -3417,7 +3865,7 @@ "" ], "text/plain": [ - "" + "" ] }, "execution_count": 12, diff --git a/index.html b/index.html index 94f5f8a..728e800 100644 --- a/index.html +++ b/index.html @@ -134,8 +134,8 @@

    Usage
  • Cardinality matching
    • diff --git a/objects.inv b/objects.inv index f5ccdc3..0a8c627 100644 Binary files a/objects.inv and b/objects.inv differ diff --git a/searchindex.js b/searchindex.js index b86fafc..9719ada 100644 --- a/searchindex.js +++ b/searchindex.js @@ -1 +1 @@ -Search.setIndex({"docnames": ["00_introduction", "01_installation", "02_demos", "03_api", "04_license", "05_help", "demos/balance_calculators", "demos/card_matcher", "demos/ea_matcher", "demos/lp_matcher", "demos/matching_data", "demos/ps_matcher", "index"], "filenames": ["00_introduction.rst", "01_installation.rst", "02_demos.rst", "03_api.rst", "04_license.rst", "05_help.rst", "demos/balance_calculators.ipynb", "demos/card_matcher.ipynb", "demos/ea_matcher.ipynb", "demos/lp_matcher.ipynb", "demos/matching_data.ipynb", "demos/ps_matcher.ipynb", "index.rst"], "titles": ["Introduction", "Installation instructions", "Demos", "API documentation", "License", "Help", "Balance Calculators", "Cardinality matching", "Genetic Matcher", "Constraint Satisfaction Matcher", "Matching Data", "Propensity Score Matcher", "PyBalance Utilities"], "terms": {"The": [0, 3, 8, 9, 10, 11], "pybal": [0, 1, 3, 5, 6, 7, 8, 9, 10, 11], "librari": [0, 8, 9], "implement": [0, 3, 6], "sever": [0, 2, 12], "routin": [0, 3, 10], "optim": [0, 2, 3, 12], "balanc": [0, 1, 2, 8, 9, 11, 12], "between": [0, 2, 3, 12], "non": [0, 3, 8, 9], "random": [0, 6], "popul": [0, 3, 6, 7, 8, 9, 10, 11], "In": [0, 3, 8, 9, 10, 11], "observ": 0, "studi": 0, "thi": [0, 1, 3, 4, 6, 8, 9, 10, 11], "match": [0, 2, 6, 8, 9, 11, 12], "process": 0, "i": [0, 1, 3, 4, 6, 9, 10, 11], "kei": [0, 3], "step": [0, 3], "toward": 0, "minim": 0, "potenti": [0, 11], "effect": [0, 3], "confound": 0, "covari": [0, 3, 8, 9, 10], "two": [0, 3, 10], "separ": [0, 3, 10], "approach": 0, "both": [0, 3, 8], "which": [0, 1, 3, 8, 9, 10, 11], "work": [0, 6], "distribut": [0, 3, 4, 8, 10], "directli": [0, 11], "without": [0, 2, 4, 12], "specifi": [0, 3, 6, 10], "whom": 0, "given": [0, 3, 10, 11], "individu": 0, "consid": [0, 3, 6], "group": [0, 1, 3, 5, 10], "subject": [0, 2, 3, 9, 12], "togeth": 0, "set": [0, 3, 9], "f": [0, 1, 6], "e": [0, 1, 3, 6, 10], "g": [0, 1, 3, 6, 10], "ag": [0, 3, 4, 6, 7, 8, 9, 10, 11], "height": [0, 3, 6, 7, 8, 9, 10, 11], "smoker": 0, "describ": [0, 3, 10], "characterist": 0, "By": [0, 3], "convent": 0, "we": [0, 1, 3, 8, 9, 10, 11], "refer": [0, 3, 10], "smaller": [0, 3, 10, 11], "target": [0, 2, 3, 7, 8, 9, 10, 11, 12], "larger": [0, 3], "pool": [0, 2, 3, 8, 9, 10, 11, 12], "our": [0, 10], "goal": 0, "draw": 0, "from": [0, 3, 4, 6, 7, 8, 9, 10, 11, 12], "chosen": 0, "subset": [0, 2, 3, 10, 12], "defin": [0, 3], "close": 0, "possibl": [0, 3, 4, 9], "more": [0, 3], "formal": 0, "size": [0, 2, 3, 6, 9, 10, 12], "m": [0, 1, 6, 7, 8, 9, 10, 11], "n": [0, 1, 3, 6, 10], "choos": [0, 3, 9], "patient": [0, 3, 7, 8, 9], "best": [0, 3, 6, 8, 9, 11], "resembl": 0, "sinc": [0, 3], "ar": [0, 3, 4, 6, 10], "explor": [0, 2, 12], "whole": [0, 6], "space": [0, 3, 9], "solut": [0, 3, 7, 8, 9, 11], "gener": [0, 3, 6, 8, 10], "infeas": 0, "even": [0, 4], "modestli": 0, "depend": [0, 1, 3], "natur": [0, 9], "measur": [0, 11], "differ": [0, 3, 10], "solver": [0, 3, 7, 8, 9, 11], "avail": 0, "For": [0, 3], "instanc": [0, 3], "case": [0, 3, 10], "mean": [0, 2, 3, 6, 10, 12], "standard": [0, 3, 10], "error": [0, 3, 6, 9], "one": [0, 3, 5, 10], "can": [0, 1, 3, 6, 8, 9, 10, 11], "formul": [0, 3], "follow": [0, 3, 4, 12], "begin": 0, "equat": 0, "x_": 0, "1": [0, 3, 6, 7, 8, 9, 10, 11], "mbox": 0, "select": [0, 1, 3], "0": [0, 3, 6, 7, 8, 9, 10, 11], "otherwis": [0, 3, 4], "end": 0, "take": [0, 6, 9], "c_": 0, "mf": 0, "valu": [0, 3, 6, 9, 10], "featur": [0, 3, 7, 9, 10], "correspond": [0, 3], "": [0, 3, 6, 8, 9, 10, 11], "align": 0, "a_f": 0, "bigg": 0, "sum_": 0, "object": [0, 3, 7, 8, 9, 10, 11], "function": [0, 3, 8, 9, 10], "constraint": [0, 2, 12], "linear": [0, 3, 8, 9], "fast": 0, "integ": [0, 7, 9], "program": 0, "us": [0, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], "backend": 0, "solv": [0, 3, 7, 9], "cost": 0, "2": [0, 2, 3, 6, 7, 9, 10, 11, 12], "sat": [0, 3], "googl": [0, 3], "Or": 0, "tool": [0, 3, 10], "note": [0, 1, 3, 9, 10, 11], "do": [0, 1, 11], "explicitli": [0, 3, 10], "assign": [0, 10], "control": [0, 3], "treatment": [0, 3], "therefor": 0, "decis": [0, 3], "variabl": [0, 3, 7, 9, 10], "x": [0, 3], "simpli": [0, 1, 10, 12], "vector": 0, "length": 0, "equal": [0, 3], "number": [0, 3, 6, 7, 9, 10, 11], "detail": [0, 3], "allow": [0, 1, 3], "scale": [0, 7, 9], "rel": 0, "larg": [0, 3, 11], "howev": [0, 3, 4], "alwai": [0, 1, 3], "desir": [0, 1], "improv": [0, 3], "poorli": 0, "dimens": [0, 7, 9], "slightli": [0, 9], "often": [0, 3, 10], "better": 0, "than": [0, 3, 11], "well": [0, 3], "same": [0, 3, 6], "amount": 0, "enforc": 0, "prior": [0, 4], "requir": [0, 1, 3], "method": [0, 3, 8, 10, 11], "appli": [0, 3, 7, 9], "an": [0, 3, 6, 8], "evolutionari": [0, 3], "stochast": 0, "search": [0, 3, 12], "also": [0, 1, 3, 6], "heurist": 0, "effici": 0, "complet": 0, "eas": 0, "comparison": 0, "base": [0, 3], "propens": [0, 2, 8, 9, 12], "score": [0, 2, 7, 8, 9, 12], "greater": 0, "technic": [0, 3], "applic": 0, "see": [0, 1, 3, 9], "public": 0, "here": [0, 1, 3, 6, 9, 10], "reccomend": 1, "conda": 1, "creat": [1, 3, 6], "python": 1, "3": [1, 3, 4, 6, 7, 8, 9, 10, 11], "9": [1, 6, 7, 8, 9, 10, 11], "activ": 1, "If": [1, 3, 5, 11], "you": [1, 3, 5, 10], "wish": 1, "within": [1, 3], "jupyt": 1, "notebook": [1, 8, 9, 10, 11], "need": [1, 3], "regist": [1, 3], "your": 1, "enviro": 1, "ipykernel": 1, "user": [1, 3, 6, 8, 10, 11], "name": [1, 3, 4, 10], "make": 1, "sure": 1, "kernel": 1, "when": [1, 6, 9], "run": [1, 10], "suggest": [1, 5], "latest": 1, "releas": [1, 3], "found": [1, 3, 5, 6, 7, 8, 9, 11], "http": [1, 3, 5, 9, 10], "github": [1, 3, 5, 10], "com": [1, 3, 5, 10], "bayer": [1, 4, 5, 10], "To": [1, 3], "clone": 1, "repositori": 1, "checkout": 1, "git": 1, "cd": 1, "vx": 1, "y": [1, 3], "z": 1, "where": [1, 10], "tag": 1, "virtual": 1, "environ": 1, "favorit": 1, "manag": 1, "yourenv": 1, "r": 1, "txt": 1, "gpu": [1, 3], "acceler": [1, 3], "onli": [1, 3, 9, 10], "geneticmatch": [1, 3, 8, 11], "addit": [1, 3], "requirements_gpu": 1, "Then": 1, "code": [1, 4], "setup": 1, "py": [1, 3, 6, 8, 9, 10, 11], "maintain": [1, 5], "those": [1, 3], "who": 1, "prefer": 1, "develop": [1, 5], "build": [1, 7, 9], "imag": 1, "t": [1, 3, 6], "dev": 1, "dockerfil": 1, "enter": 1, "v": 1, "path": [1, 3, 10], "local": [1, 3], "top": [1, 3], "level": [1, 3, 7, 8, 9, 10, 11], "directori": 1, "attach": 1, "wai": [1, 3, 4], "immedi": 1, "chang": [1, 5], "access": [1, 3, 10], "compos": 1, "up": [1, 3, 9], "navig": 1, "link": 1, "print": [1, 3, 6], "screen": 1, "connect": 1, "server": 1, "should": [1, 3, 9, 10], "save": 1, "want": 1, "persist": 1, "provid": [1, 3, 4], "have": [1, 3, 5, 6, 12], "acceess": 1, "calcul": [1, 2, 7, 9, 12], "pyblal": 1, "data": [2, 4, 6, 12], "initi": [2, 3, 7, 8, 9, 12], "matchingdata": [2, 3, 6, 7, 8, 12], "visual": [2, 7, 8, 9, 11, 12], "fit": [2, 3, 4, 12], "simultan": [2, 12], "basic": [2, 3, 11, 12], "genet": [2, 12], "matcher": [2, 7, 12], "beta": [2, 3, 6, 7, 12], "absolut": [2, 3, 12], "smd": [2, 12], "gamma": [2, 3, 7, 12], "area": [2, 3, 12], "cdf": [2, 12], "satisfact": [2, 12], "With": [2, 12], "cross": [2, 12], "term": [2, 12], "ad": [2, 12], "cardin": [2, 3, 12], "class": [3, 10], "matchinghead": [3, 10], "categor": [3, 6, 7, 8, 9, 10, 11], "numer": [3, 6, 7, 8, 9, 10, 11], "sourc": [3, 4, 12], "simpl": 3, "structur": 3, "store": 3, "inform": 3, "about": [3, 10], "countri": [3, 6, 7, 8, 9, 10, 11], "gender": [3, 6, 7, 8, 9, 10, 11], "weight": [3, 6, 7, 8, 9, 10, 11], "type": 3, "paramet": 3, "list": [3, 4, 6, 9], "str": 3, "treat": [3, 10], "header": [3, 6, 7, 8, 9, 10, 11], "none": [3, 6, 7, 8, 9, 11], "population_col": 3, "It": [3, 6, 10], "common": 3, "problem": [3, 9, 12], "metadata": [3, 10], "order": [3, 7, 9], "perform": 3, "mai": [3, 4], "contain": 3, "column": [3, 6, 7, 8, 9, 10, 11], "patient_id": [3, 6, 7, 8, 9, 10, 11], "index_d": 3, "intend": 3, "must": [3, 4, 6], "go": [3, 9], "along": [3, 10], "ride": 3, "main": [3, 10], "everywher": 3, "wrapper": [3, 10], "around": [3, 10], "panda": [3, 9, 10], "datafram": [3, 9, 10], "includ": [3, 4, 8], "logic": [3, 10], "field": [3, 10], "while": 3, "other": [3, 4], "exist": 3, "alongsid": 3, "pd": [3, 10], "frame": 3, "all": [3, 6], "least": 3, "each": [3, 10], "row": [3, 6, 7, 8, 9, 10, 11], "belong": 3, "string": [3, 10], "pass": [3, 9, 10], "assum": 3, "option": [3, 6], "A": [3, 4, 9], "whose": 3, "infer": [3, 10], "how": [3, 8, 9, 10], "mani": [3, 10], "uniqu": 3, "ha": 3, "As": 3, "guess": 3, "lead": 3, "recommend": 3, "suppli": 3, "them": 3, "split": [3, 10], "subpopul": 3, "append": [3, 8, 9, 11], "df": 3, "oper": 3, "inplac": 3, "copi": [3, 8, 9, 11], "new": 3, "exact": 3, "return": [3, 6, 9, 10, 11], "properti": 3, "pointer": 3, "underli": [3, 10], "normal": [3, 10], "true": [3, 8, 9, 10, 11], "aggreg": 3, "std": [3, 10], "quantil": 3, "25": [3, 6, 7, 8, 9, 10, 11], "5": [3, 6, 7, 8, 9, 10, 11], "75": [3, 7, 8, 9, 10, 11], "call": [3, 6, 8, 9, 10], "describe_categor": 3, "describe_numer": 3, "result": [3, 11], "singl": [3, 6], "summari": [3, 10], "statist": 3, "long_format": 3, "get_popul": [3, 7, 8, 9, 11], "get": [3, 5, 10], "its": [3, 4], "head": [3, 10], "first": 3, "present": [3, 10], "sampl": [3, 6, 8], "tail": 3, "last": 3, "to_csv": 3, "arg": 3, "kwarg": 3, "write": 3, "csv": 3, "signatur": 3, "ident": 3, "to_parquet": 3, "parquet": 3, "infer_matching_head": 3, "max_categori": 3, "10": [3, 6, 7, 8, 9, 10, 11], "ignore_col": 3, "patientid": 3, "input": 3, "either": [3, 10], "combin": 3, "keyword": [3, 10], "argument": [3, 10], "dictionari": 3, "default": 3, "ignor": 3, "split_target_pool": [3, 6, 10], "matching_data": [3, 7, 8, 10, 11], "pool_nam": 3, "target_nam": [3, 10], "attempt": 3, "basematchingpreprocessor": 3, "abstract": 3, "preprocessor": [3, 6], "organ": [3, 10], "transform": 3, "keep": [3, 10], "track": [3, 10], "so": [3, 6], "inherit": 3, "_fit": 3, "_transform": 3, "_get_output_head": 3, "_get_feature_names_out": 3, "extend": 3, "sklearn": [3, 8, 9, 11], "handl": 3, "conform": 3, "chainabl": 3, "easili": 3, "task": 3, "chainpreprocessor": 3, "comput": [3, 8, 9], "deviat": 3, "accept": 3, "overridden": 3, "subclass": 3, "feature_name_in": 3, "get_feature_names_out": 3, "output": 3, "particular": [3, 4, 11], "refit": 3, "fals": [3, 6, 7, 8, 9, 10, 11], "workhors": 3, "mark": 3, "after": [3, 10], "prevent": 3, "twice": 3, "categoriconehotencod": 3, "drop": 3, "convert": [3, 6], "hot": 3, "encod": 3, "unaffect": 3, "ani": [3, 4, 8, 9, 10], "choic": [3, 6, 9], "if_binari": 3, "onehotencod": 3, "numericbinsencod": 3, "n_bin": 3, "strategi": 3, "uniform": [3, 8], "onehot": 3, "dens": 3, "cumul": [3, 10], "discret": [3, 7, 8, 9], "accord": [3, 8, 11], "bin": [3, 6, 7, 8, 9, 10], "int": 3, "would": [3, 10], "avoid": 3, "intern": [3, 6], "kmean": 3, "kbinsdiscret": 3, "ordin": 3, "bool": 3, "whether": [3, 4], "3rd": 3, "4": [3, 6, 7, 8, 9, 10, 11], "map": 3, "decisiontreeencod": 3, "keep_original_featur": 3, "decision_tree_param": 3, "binari": [3, 4], "coviat": 3, "termin": 3, "leaf": 3, "posit": 3, "tree": 3, "sequenc": 3, "basebalancecalcul": 3, "feature_weight": [3, 8], "standardize_differ": [3, 7, 10], "devic": 3, "low": 3, "interfac": 3, "matrix": 3, "pytorch": [3, 6], "per": 3, "loss": [3, 4, 7, 8, 9], "furthermor": 3, "time": [3, 7, 8, 9, 11], "distanc": [3, 6], "exactli": [3, 10], "some": [3, 10], "expon": 3, "total": 3, "sum": 3, "feature_loss": 3, "system": 3, "per_feature_loss": [3, 7], "pool_subset": [3, 6], "target_subset": [3, 6], "mismatch": 3, "aka": 3, "basi": 3, "candid": [3, 8], "tensor": [3, 6, 7], "betabal": [3, 6, 8, 9, 10, 11], "conveni": [3, 10], "standardmatchingpreprocessor": 3, "betasquaredbal": [3, 8], "except": [3, 6], "averag": 3, "squar": 3, "fashion": 3, "betamaxbal": [3, 8], "worst": [3, 8], "determin": 3, "metric": [3, 11], "criterion": 3, "suffici": 3, "good": [3, 4, 6], "awar": 3, "variou": 3, "unwant": 3, "behavior": [3, 9], "signal": 3, "gammabal": [3, 7, 8, 9], "dimension": 3, "margin": 3, "gammapreprocessor": 3, "descript": 3, "gammasquaredbal": [3, 8], "gammaxtreebal": [3, 8, 9], "balancecalcul": 3, "appropri": 3, "against": 3, "balance_calcul": [3, 6, 7], "therein": 3, "configur": 3, "specif": [3, 4], "batchedbalancecaclul": 3, "max_batch_size_gb": [3, 8], "8": [3, 7, 8, 9, 10, 11], "batch": 3, "peak": 3, "memori": 3, "usag": [3, 11], "propensityscorematch": [3, 11], "calip": [3, 11], "max_it": [3, 8, 9, 11], "50": [3, 6, 7, 8, 9, 10, 11], "time_limit": [3, 7, 8, 9, 11], "300": [3, 8], "greedi": [3, 11], "verbos": [3, 8, 9], "model": [3, 7, 8, 9, 11], "randomli": 3, "over": 3, "hyperparamet": 3, "known": [3, 9], "float": 3, "restrict": 3, "maximum": 3, "try": [3, 6, 9], "befor": [3, 6], "No": 3, "train": [3, 8, 9, 11], "second": 3, "began": 3, "linear_sum_assign": 3, "former": 3, "global": 3, "sub": 3, "optimi": 3, "latter": 3, "far": 3, "intens": 3, "flag": 3, "indic": 3, "diagnosit": 3, "dure": 3, "__init__": 3, "plot_propensity_score_match_distribut": [3, 11], "plot": [3, 10], "histogram": 3, "estim": 3, "pre": 3, "post": 3, "plot_propensity_score_match_pair": 3, "scatterplot": 3, "pair": 3, "form": [3, 4], "param": 3, "algorithm": [3, 8], "get_global_default": [3, 8], "seed": [3, 8, 11], "n_candidate_popul": [3, 8], "5000": [3, 8, 10], "reason": 3, "break": 3, "govern": 3, "mix": [3, 6], "evolv": 3, "lp": [3, 7, 9], "constraintsatisfactionmatch": [3, 7, 9, 11], "match_siz": 3, "pool_siz": [3, 6, 7, 9], "target_s": [3, 6, 7, 9], "max_mismatch": [3, 7, 9], "180": [3, 8, 9, 11], "num_work": [3, 9], "ps_hint": [3, 9], "satisf": 3, "below": 3, "via": 3, "n_target": [3, 7, 11], "kosukeimai": 3, "io": 3, "matchit": 3, "method_cardin": 3, "html": [3, 9], "cannot": 3, "itself": 3, "report": [3, 9], "actual": [3, 9], "find": 3, "c": [3, 4, 8, 9, 11], "full": [3, 9], "deprec": 3, "remov": 3, "later": 3, "less": 3, "limit": [3, 4, 8], "stop": [3, 8], "def": [3, 6], "sec": 3, "worker": [3, 7, 9], "blob": [3, 10], "stabl": [3, 9], "ortool": 3, "sat_paramet": 3, "proto": 3, "l556": 3, "hint": [3, 9], "entir": 3, "being": [3, 9, 11], "omit": 3, "altogheth": 3, "fly": 3, "admit": 3, "bit": 3, "confus": 3, "clean": 3, "plot_numeric_featur": [3, 7, 8, 9, 10, 11], "col_wrap": 3, "6": [3, 7, 8, 9, 10, 11], "plot_param": 3, "extra": [3, 10], "seaborn": [3, 10, 11], "histplot": 3, "overrid": 3, "figur": 3, "plot_categoric_featur": [3, 7, 8, 9, 10, 11], "include_binari": [3, 10], "plot_binary_featur": [3, 8, 9, 10, 11], "max_featur": 3, "include_onli": 3, "orient_horizont": [3, 10], "reference_popul": 3, "sn": 3, "barplot": 3, "max": [3, 7, 10], "show": [3, 8, 9, 11], "lot": 3, "sort": 3, "descend": 3, "shown": 3, "orient": 3, "axi": 3, "compar": [3, 6], "plot_joint_numeric_distribut": [3, 10, 11], "joint_kind": 3, "kde": 3, "2d": 3, "scatter": 3, "usual": 3, "bad": 3, "dataset": [3, 9], "jointgrid": 3, "plot_joint_numeric_categoric_distribut": [3, 10], "include_only_numer": 3, "include_only_categor": 3, "plot_per_feature_loss": [3, 8, 9, 10, 11], "debin": [3, 8, 9, 11], "back": 3, "real": 3, "like": 3, "country_u": 3, "country_germani": 3, "divid": 3, "contribut": 3, "obtain": 3, "sim": [3, 6, 7, 8, 9, 10, 11], "generate_toy_dataset": [3, 7, 8, 9, 11], "n_pool": [3, 7, 11], "10000": [3, 8, 9, 11], "1000": [3, 6, 7, 8, 9, 11], "45": [3, 7, 8, 9, 10, 11], "toi": 3, "finer": 3, "generate_random_feature_data_rwd": 3, "generate_random_feature_data_rct": 3, "load_paper_dataset": [3, 6, 7], "load": 3, "paper": 3, "onlinelibrari": 3, "wilei": 3, "doi": 3, "1002": 3, "pst": 3, "2352": 3, "bsd": 4, "claus": 4, "copyright": 4, "2024": 4, "redistribut": 4, "modif": 4, "permit": 4, "condit": 4, "met": 4, "retain": 4, "abov": 4, "notic": 4, "disclaim": 4, "reproduc": 4, "document": [4, 9, 12], "materi": 4, "neither": 4, "holder": 4, "nor": 4, "contributor": 4, "endors": 4, "promot": 4, "product": 4, "deriv": 4, "softwar": 4, "written": 4, "permiss": 4, "BY": 4, "THE": 4, "AND": 4, "AS": 4, "express": 4, "OR": 4, "impli": 4, "warranti": 4, "BUT": 4, "NOT": 4, "TO": 4, "OF": 4, "merchant": 4, "FOR": 4, "purpos": 4, "IN": 4, "NO": 4, "event": 4, "shall": 4, "BE": 4, "liabl": 4, "direct": 4, "indirect": 4, "incident": 4, "special": 4, "exemplari": 4, "consequenti": 4, "damag": 4, "procur": 4, "substitut": 4, "servic": 4, "profit": 4, "busi": 4, "interrupt": 4, "caus": 4, "ON": 4, "theori": 4, "liabil": 4, "contract": 4, "strict": 4, "tort": 4, "neglig": 4, "aris": 4, "out": 4, "IF": 4, "advis": 4, "SUCH": 4, "re": 5, "troubl": 5, "toolkit": 5, "pleas": [5, 6], "touch": 5, "stephen": 5, "privitera": 5, "hooman": 5, "sedghamiz": 5, "alexand": 5, "hartenstein": 5, "abhishek": 5, "choudhari": 5, "ve": 5, "bug": 5, "open": 5, "ticket": 5, "issu": 5, "util": [6, 7, 8, 9, 10, 11], "import": [6, 7, 8, 9, 10, 11], "haircolor": [6, 7, 8, 9, 10, 11], "binary_0": [6, 7, 8, 9, 10, 11], "binary_1": [6, 7, 8, 9, 10, 11], "binary_2": [6, 7, 8, 9, 10, 11], "binary_3": [6, 7, 8, 9, 10, 11], "64": [6, 9, 10, 11], "854093": [6, 10], "189": [6, 8, 9, 10, 11], "466850": [6, 10], "88": [6, 8, 9, 10, 11], "835049": [6, 10], "135740": [6, 10], "52": [6, 9, 10, 11], "571993": [6, 10], "158": [6, 8, 9, 10, 11], "134940": [6, 10], "94": [6, 7, 8, 9, 10, 11], "215107": [6, 10], "49288": [6, 10], "828361": [6, 10], "154": [6, 8, 9, 10, 11], "692482": [6, 10], "226222": [6, 10], "256676": [6, 10], "70": [6, 7, 8, 9, 10, 11], "177571": [6, 10], "160": [6, 8, 9, 10, 11], "536632": [6, 10], "244356": [6, 10], "338287": [6, 10], "73": [6, 7, 8, 9, 10, 11], "779164": [6, 10], "153": [6, 9, 10, 11], "551419": [6, 10], "86": [6, 8, 9, 10, 11], "161814": [6, 10], "72849": [6, 10], "274995": [6, 10], "62": [6, 7, 8, 9, 10, 11], "547794": [6, 10], "186": [6, 8, 9, 10, 11], "005015": [6, 10], "975051": [6, 10], "579081": [6, 10], "274996": [6, 10], "69": [6, 9, 10, 11], "879934": [6, 10], "142": [6, 8, 9, 10, 11], "371386": [6, 10], "100": [6, 8, 9, 10, 11], "138389": [6, 10], "569939": [6, 10], "274997": [6, 10], "56": [6, 7, 8, 9, 10, 11], "921402": [6, 10], "130": [6, 7, 8, 9, 10, 11], "639589": [6, 10], "108": [6, 7, 8, 9, 10, 11], "745182": [6, 10], "532419": [6, 10], "274998": [6, 10], "34": [6, 7, 8, 9, 10, 11], "082754": [6, 10], "174": [6, 9, 10, 11], "764051": [6, 10], "67": [6, 7, 8, 9, 10, 11], "998396": [6, 10], "566266": [6, 10], "274999": [6, 10], "60": [6, 9, 10, 11], "981259": [6, 10], "137": [6, 8, 9, 10, 11], "419436": [6, 10], "89": [6, 9, 10, 11], "897817": [6, 10], "544231": [6, 10], "275000": [6, 10], "12": [6, 7, 8, 9, 10, 11], "13": [6, 7, 8, 9, 10, 11], "count": 6, "250000": [6, 10], "25000": [6, 10], "14": [6, 8, 9, 10, 11], "what": 6, "involv": 6, "onc": 6, "meaningfulli": 6, "15": [6, 8, 9, 10, 11], "2353": 6, "dtype": 6, "torch": 6, "float64": 6, "16": [6, 8, 9, 10, 11], "17": [6, 8, 9, 11], "2366": 6, "18": [6, 7, 8, 9, 10, 11], "2669": 6, "19": [6, 7, 8, 9, 10, 11], "np": 6, "arrai": 6, "reset_index": 6, "index": [6, 9, 12], "replac": 6, "2404": 6, "2418": 6, "gmema": 6, "src": [6, 8, 10, 11], "224": [6, 8, 11], "userwarn": [6, 10], "numpi": 6, "ndarrai": 6, "extrem": 6, "slow": 6, "trigger": 6, "runner": 6, "csrc": 6, "tensor_new": 6, "cpp": 6, "278": 6, "subset_popul": 6, "2602": 6, "2757": 6, "28": [6, 8, 9, 11], "throw": 6, "valueerror": 6, "veri": 6, "un": 6, "smart": 6, "becaus": 6, "doesn": 6, "just": [6, 10], "illustr": 6, "27": [6, 7, 8, 9, 10, 11], "get_subset": 6, "n_subset": 6, "_": 6, "rang": [6, 9], "best_match": 6, "best_dist": 6, "100000": 6, "j": 6, "this_best_dist": 6, "min": [6, 8, 9, 10, 11], "best_match_idx": 6, "argmin": 6, "3f": 6, "215": [6, 9, 11], "20": [6, 7, 8, 9, 11], "211": [6, 8, 11], "30": [6, 8, 9, 10, 11], "40": [6, 7, 8, 9, 11], "208": [6, 11], "80": [6, 7, 9, 11], "90": [6, 7, 9, 11], "log": [7, 8, 9, 10, 11], "basicconfig": [7, 8, 9, 10, 11], "info": [7, 8, 9, 10, 11], "15000": 7, "731988": 7, "816972": 7, "76": [7, 9, 10, 11], "100401": 7, "26": [7, 8, 9, 11], "403338": 7, "784188": 7, "134423": 7, "58": [7, 8, 9, 10, 11], "155044": 7, "175": [7, 9, 10, 11], "704961": 7, "806745": 7, "68": [7, 8, 9, 10, 11], "334248": 7, "167": [7, 8, 9, 10, 11], "485984": 7, "081777": 7, "54": [7, 8, 9, 11], "114518": 7, "782073": 7, "53": [7, 8, 9, 10, 11], "612174": 7, "995": [7, 8, 9, 11], "21": [7, 8, 9, 11], "474205": [7, 8, 9], "168": [7, 8, 9, 11], "602546": [7, 8, 9], "342128": [7, 8, 9], "15995": 7, "996": [7, 8, 9, 11], "643320": [7, 8, 9], "188": [7, 8, 9, 11], "188724": [7, 8, 9], "61": [7, 8, 9, 10, 11], "611744": [7, 8, 9], "15996": 7, "997": [7, 8, 9, 11], "29": [7, 8, 9, 10, 11], "472765": [7, 8, 9], "161": [7, 8, 9, 11], "408162": [7, 8, 9], "57": [7, 8, 9, 10, 11], "214095": [7, 8, 9], "15997": 7, "998": [7, 8, 9, 11], "41": [7, 8, 9, 10, 11], "291949": [7, 8, 9], "150": [7, 8, 9, 11], "968833": [7, 8, 9], "91": [7, 8, 9, 11], "270798": [7, 8, 9], "15998": 7, "999": [7, 8, 9, 11], "530294": [7, 8, 9], "155": [7, 8, 9, 11], "124741": [7, 8, 9], "196505": [7, 8, 9], "15999": 7, "16000": 7, "05": [7, 8, 9], "600": 7, "match_card": 7, "preprocess": [7, 8, 9], "02": [7, 8, 9], "51": [7, 8, 9, 11], "37": [7, 8, 9, 10, 11], "01": [7, 8, 9, 10], "46": [7, 8, 9, 10, 11], "65": [7, 8, 9, 11], "125": [7, 8, 9, 10, 11], "136": [7, 8, 9, 11], "148": [7, 8, 9, 11], "33": [7, 8, 9, 10, 11], "159": [7, 9, 10, 11], "99": [7, 9, 11], "171": [7, 8, 9, 11], "66": [7, 8, 9, 10, 11], "183": [7, 8, 9, 11], "32": [7, 8, 9, 10, 11], "194": [7, 11], "85": [7, 8, 9, 10, 11], "96": [7, 8, 9, 10, 11], "120": [7, 8, 9, 10, 11], "factor": [7, 9], "200": [7, 9, 11], "00": [7, 9, 10], "lt": [7, 9, 11], "0000": [7, 9], "bound": [7, 9], "2095": 7, "13153": 7, "0117": 7, "1847": 7, "12981": 7, "0280": 7, "2019": 7, "47": [7, 8, 9, 11], "12979": 7, "0382": 7, "2021": 7, "49": [7, 8, 9, 11], "12909": 7, "0380": 7, "2091": 7, "12879": 7, "0383": 7, "2121": 7, "12827": 7, "0387": 7, "2173": 7, "7": [7, 8, 9, 10, 11], "11000": [7, 8, 9, 11], "0648": 7, "4000": 7, "10818": 7, "0704": 7, "4182": 7, "statu": [7, 9], "feasibl": [7, 9], "0500": 7, "matplotlib": [7, 8, 9, 10, 11], "inlin": [7, 8, 9, 10, 11], "fig": [7, 8, 9, 10, 11], "len": [7, 9, 10], "match_dist": 7, "825443200": 7, "0644": 7, "31": [7, 8, 9, 11], "825304800": 7, "733533600": 7, "0557": [7, 9], "09": [7, 9, 10], "733527200": 7, "59": [7, 9, 10, 11], "733465600": 7, "733395200": 7, "match_dist2": 7, "07": 7, "2127925600": 7, "1582": 7, "11": [7, 8, 9, 10, 11], "2020125600": 7, "1489": 7, "2019725600": 7, "2016325600": 7, "1487": 7, "2015325600": 7, "1486": 7, "2012125600": 7, "1483": 7, "2011725600": 7, "1482": 7, "2011525600": 7, "36": [7, 8, 9, 11], "2011325600": 7, "478921600": 7, "0346": [7, 9], "478920000": 7, "baselin": [8, 9], "demo": [8, 9, 10, 12], "exampl": 8, "format": [8, 9, 10, 11], "levelnam": [8, 9, 10, 11], "filenam": [8, 9, 10, 11], "lineno": [8, 9, 10, 11], "d": [8, 9, 10, 11], "messag": [8, 9, 10, 11], "betaxbal": [8, 9], "gammaxbal": [8, 9], "511573": [8, 9], "190": [8, 9, 11], "229250": [8, 9], "105": [8, 9, 11], "165097": [8, 9], "505065": [8, 9], "121236": [8, 9], "95": [8, 9, 10, 11], "001474": [8, 9], "071384": [8, 9], "162": [8, 9, 11], "325356": [8, 9], "84": [8, 9, 10, 11], "290576": [8, 9], "44": [8, 9, 11], "423692": [8, 9], "948096": [8, 9], "82": [8, 9, 10, 11], "031381": [8, 9], "695052": [8, 9], "132": [8, 9, 10, 11], "952651": [8, 9], "857540": [8, 9], "10995": [8, 9, 11], "10996": [8, 9, 11], "10997": [8, 9, 11], "10998": [8, 9, 11], "10999": [8, 9, 11], "matcher_beta": [8, 9], "log_everi": 8, "n_gener": 8, "get_param": [8, 9, 11], "cpu": 8, "39": [8, 9, 10, 11], "candidate_population_s": 8, "1024": 8, "n_keep_best": 8, "256": 8, "n_voting_popul": 8, "n_mutat": 8, "n_iter_no_chang": 8, "1234": 8, "benchmark": 8, "233": [8, 11], "38": [8, 9, 10, 11], "sgdclassifi": [8, 9, 11], "iter": [8, 9, 11], "001": [8, 9, 11], "139": [8, 9, 11], "alpha": [8, 9], "5074398973827774": 8, "class_weight": [8, 9], "early_stop": [8, 9], "fit_intercept": [8, 9, 11], "log_loss": [8, 9], "1500": [8, 9], "penalti": [8, 9, 11], "l2": [8, 9, 11], "140": [8, 9, 10, 11], "0525": 8, "141": [8, 9, 11], "002": [8, 9], "logisticregress": [8, 9, 11], "05835496346821344": 8, "500": [8, 9, 11], "saga": [8, 9, 11], "0291": 8, "004": [8, 11], "sprivit": [8, 10, 11], "venv": [8, 10, 11], "lib": [8, 9, 10, 11], "python3": [8, 9, 10, 11], "site": [8, 9, 10, 11], "packag": [8, 9, 10, 11], "linear_model": [8, 9, 11], "_sag": [8, 9, 11], "350": [8, 9, 11], "convergencewarn": [8, 9, 11], "wa": [8, 9, 11], "reach": [8, 9, 11], "coef_": [8, 9, 11], "did": [8, 9, 11], "converg": [8, 9, 11], "warn": [8, 9, 11], "028": [8, 11], "029": 8, "050": 8, "052": 8, "055": [8, 11], "056": 8, "073": 8, "075": 8, "078": [8, 11], "079": [8, 11], "080": 8, "082": 8, "083": [8, 9], "085": 8, "087": 8, "3905570899706423": 8, "0289": 8, "090": [8, 9], "101": [8, 9, 11], "102": [8, 9, 11], "22": [8, 9, 11], "104": [8, 9, 11], "23": [8, 9, 11], "24": [8, 9, 11], "107": [8, 9, 11], "109": [8, 9, 11], "111": [8, 9, 11], "2699411413616818": 8, "l1": [8, 9, 11], "0288": 8, "113": [8, 9, 11], "115": [8, 9, 11], "133": [8, 9, 10, 11], "135": [8, 9, 11], "35": [8, 9, 11], "144": [8, 9, 10, 11], "172": [8, 9, 11], "5868985298319505": 8, "0249": [8, 9], "195": [8, 9, 10, 11], "197": [8, 11], "199": [8, 11], "201": [8, 11], "42": [8, 9, 11], "203": [8, 11], "43": [8, 9, 11], "213": [8, 11], "234": [8, 11], "235": [8, 9, 11], "257": 8, "48": [8, 9, 10, 11], "279": 8, "281": 8, "282": [8, 9], "025": 8, "71": [8, 9, 11], "512": [8, 11], "511": 8, "logger": 8, "remain": 8, "elaps": 8, "02494": 8, "25118": 8, "7451": 8, "01141": 8, "24623": 8, "exceed": 8, "55": [8, 9, 10, 11], "261578": [8, 9], "396134": [8, 9], "438359": [8, 9], "63": [8, 9, 11], "113091": [8, 9], "165": [8, 9, 10, 11], "563337": [8, 9], "433016": [8, 9], "10001": [8, 9], "232216": [8, 9], "859857": [8, 9], "915385": [8, 9], "10002": [8, 9], "996941": [8, 9], "357415": [8, 9], "606615": [8, 9], "10003": [8, 9], "850195": [8, 9], "983706": [8, 9], "000581": [8, 9], "10004": [8, 9], "382714": 8, "203257": 8, "126127": 8, "4050": 8, "186246": 8, "221816": 8, "97": [8, 9, 10, 11], "047691": 8, "8313": 8, "510049": 8, "960298": 8, "501597": 8, "7166": 8, "061793": 8, "157": [8, 9, 11], "544063": 8, "784043": 8, "569": 8, "174501": 8, "973210": 8, "83": [8, 9, 11], "131287": 8, "2000": [8, 9, 11], "get_best_match": [8, 9, 11], "m_data": [8, 9, 11], "loc": [8, 9, 11], "prematch": [8, 9, 11], "hue_ord": [8, 9, 11], "beta2": 8, "matcher_beta2": 8, "beta_squar": 8, "263": [8, 11], "0603": [8, 9], "0374": 8, "007": [8, 9, 11], "16555309446666": 8, "0357": 8, "044": [8, 9, 11], "048": 8, "02072493419677": 8, "0347": [8, 9], "081": 8, "089": [8, 9], "092": 8, "117": [8, 9, 11], "124": [8, 9, 11], "126": [8, 9, 11], "129": [8, 9, 11], "131": [8, 9, 11], "134": [8, 9, 11], "143": [8, 9, 11], "170": [8, 9, 11], "177": [8, 9, 11], "181": [8, 9, 11], "192": [8, 11], "196": [8, 9, 11], "226": [8, 11], "232": [8, 9, 11], "238": [8, 9, 11], "241": [8, 11], "245": [8, 11], "280": 8, "288": 8, "0311": 8, "322": [8, 9], "323": 8, "325": 8, "328": 8, "331": [8, 9, 10, 11], "333": [8, 9], "381": 8, "385": 8, "387": 8, "423": 8, "458": 8, "460": [8, 11], "462": 8, "031": [8, 9], "03106": 8, "28163": 8, "matcher_gamma": [8, 9], "335": [8, 9], "04": [8, 9], "217": [8, 9, 11], "1083": 8, "0391": 8, "008": [8, 11], "0376": 8, "058": 8, "0337": 8, "091": [8, 9], "095": [8, 9], "098": 8, "179630432958701": 8, "0269": 8, "138": [8, 9, 11], "146": [8, 9, 10, 11], "149": [8, 9, 11], "151": [8, 9, 11], "206": [8, 11], "219": [8, 11], "222": [8, 11], "265": [8, 9, 11], "271": [8, 11], "273": 8, "277": 8, "320": 8, "370": [8, 11], "372": 8, "374": [8, 11], "378": 8, "380": 8, "409": 8, "446": 8, "448": 8, "450": [8, 11], "486": 8, "524": 8, "526": 8, "528": 8, "027": [8, 11], "02688": 8, "23595": 8, "7375": 8, "93": [8, 9, 11], "01151": 8, "24080": 8, "360": 9, "240": [9, 11], "2841": 9, "418": 9, "421": [9, 11], "428": 9, "437": 9, "527": 9, "611": 9, "2328": 9, "452948000": 9, "2298": 9, "03": 9, "452876000": 9, "2297": 9, "452777000": 9, "452736000": 9, "2296": 9, "452730000": 9, "452596000": 9, "2295": 9, "452537000": 9, "2294": 9, "06": 9, "452040000": 9, "2291": 9, "08": 9, "451825000": 9, "2289": 9, "451808000": 9, "451755000": 9, "22699000": 9, "0104": 9, "22422000": 9, "0124": 9, "22306000": 9, "22291000": 9, "22121000": 9, "0122": 9, "22119000": 9, "0102": 9, "22103000": 9, "0121": 9, "22101000": 9, "22099000": 9, "22088000": 9, "22084000": 9, "22083000": 9, "0101": 9, "78": [9, 11], "22082000": 9, "618": 9, "619": 9, "9933": 9, "194783": 9, "127": [9, 11], "495418": 9, "177329": 9, "9946": 9, "630370": 9, "185": [9, 11], "351623": 9, "381552": 9, "9955": 9, "736759": 9, "612045": 9, "72": [9, 11], "288182": 9, "9981": 9, "006118": 9, "419182": 9, "135407": 9, "9982": 9, "575808": 9, "401060": 9, "848616": 9, "hopefulli": 9, "progress": 9, "due": 9, "round": 9, "incur": 9, "cast": 9, "continu": 9, "understood": [9, 10], "accuraci": 9, "origin": 9, "quantiti": 9, "never": 9, "increas": 9, "sometim": [9, 10], "help": [9, 10], "add": 9, "p": 9, "beta_x": 9, "matcher_betax": 9, "442": 9, "3751": 9, "533": [9, 11], "540": 9, "guid": 9, "opt": 9, "miniconda3": 9, "env": 9, "542": 9, "settingwithcopywarn": 9, "slice": 9, "row_index": 9, "col_index": 9, "instead": [9, 11], "caveat": 9, "pydata": 9, "org": 9, "doc": 9, "user_guid": 9, "view": 9, "versu": 9, "ix": 9, "543": 9, "000": 9, "1045355473186929": 9, "modified_hub": 9, "1650": 9, "0354658577371722": 9, "0887": 9, "003": 9, "7627616953429366": 9, "0670": 9, "006": [9, 11], "015804928600429955": 9, "0615": 9, "024": 9, "065": 9, "066": [9, 11], "103": [9, 11], "163": [9, 11], "164": [9, 11], "187": [9, 11], "216": [9, 11], "254": 9, "255": 9, "258": 9, "02606111348517078": 9, "259": 9, "260": 9, "284": 9, "285": 9, "306": [9, 11], "334": [9, 11], "346": 9, "352": 9, "353": 9, "354": 9, "355": 9, "356": 9, "577": 9, "achiev": 9, "147332": 9, "579": 9, "2324": 9, "147332000": 9, "147176000": 9, "0601": 9, "147050000": 9, "147002000": 9, "146721000": 9, "145561000": 9, "0596": 9, "145369000": 9, "145229000": 9, "145192000": 9, "0595": 9, "145144000": 9, "145129000": 9, "144996000": 9, "144843000": 9, "0594": 9, "144588000": 9, "144406000": 9, "144195000": 9, "0593": 9, "143827000": 9, "143679000": 9, "0592": 9, "143649000": 9, "0591": 9, "143574000": 9, "143526000": 9, "143245000": 9, "142588000": 9, "0589": 9, "142455000": 9, "141967000": 9, "0588": 9, "141924000": 9, "141829000": 9, "0587": 9, "141681000": 9, "141606000": 9, "141322000": 9, "0585": 9, "141285000": 9, "141229000": 9, "0586": 9, "141161000": 9, "140938000": 9, "0584": 9, "140793000": 9, "140697000": 9, "140642000": 9, "140592000": 9, "140562000": 9, "0583": 9, "140520000": 9, "140167000": 9, "0582": 9, "140140000": 9, "140132000": 9, "139980000": 9, "139917000": 9, "139651000": 9, "139638000": 9, "139610000": 9, "74": [9, 10, 11], "139189000": 9, "0581": 9, "139131000": 9, "0580": 9, "138919000": 9, "138885000": 9, "77": [9, 11], "138879000": 9, "138853000": 9, "0579": 9, "138782000": 9, "138716000": 9, "138683000": 9, "138483000": 9, "137815000": 9, "0576": 9, "137752000": 9, "137486000": 9, "0575": 9, "137401000": 9, "137333000": 9, "137132000": 9, "0574": 9, "137105000": 9, "137099000": 9, "98": [9, 11], "137080000": 9, "137005000": 9, "136985000": 9, "136974000": 9, "136947000": 9, "136838000": 9, "136729000": 9, "0573": 9, "136654000": 9, "136559000": 9, "136503000": 9, "136457000": 9, "136435000": 9, "79": [9, 11], "136386000": 9, "136349000": 9, "81": [9, 10, 11], "136313000": 9, "136286000": 9, "136020000": 9, "135535000": 9, "0570": 9, "135513000": 9, "135473000": 9, "87": [9, 10, 11], "135452000": 9, "135375000": 9, "135312000": 9, "0569": 9, "134988000": 9, "0568": 9, "134977000": 9, "92": [9, 10, 11], "134937000": 9, "134931000": 9, "134909000": 9, "0567": 9, "134887000": 9, "0566": 9, "134614000": 9, "134579000": 9, "134522000": 9, "134400000": 9, "0565": 9, "134234000": 9, "134107000": 9, "0564": 9, "133877000": 9, "133872000": 9, "133834000": 9, "0562": 9, "133706000": 9, "0561": 9, "106": [9, 11], "133469000": 9, "0560": 9, "133214000": 9, "0559": 9, "133090000": 9, "133063000": 9, "110": [9, 11], "133033000": 9, "133028000": 9, "112": [9, 11], "133008000": 9, "0558": 9, "132983000": 9, "114": [9, 11], "132978000": 9, "132841000": 9, "116": [9, 11], "132785000": 9, "132779000": 9, "118": [9, 11], "132600000": 9, "119": [9, 11], "132480000": 9, "132453000": 9, "121": [9, 11], "132264000": 9, "0556": 9, "122": [9, 11], "132136000": 9, "123": [9, 11], "132122000": 9, "132117000": 9, "132079000": 9, "132025000": 9, "132007000": 9, "128": [9, 11], "131985000": 9, "131979000": 9, "131957000": 9, "0555": 9, "131715000": 9, "131695000": 9, "131689000": 9, "0554": 9, "131687000": 9, "131585000": 9, "131572000": 9, "131526000": 9, "131488000": 9, "131421000": 9, "131418000": 9, "131344000": 9, "131338000": 9, "131174000": 9, "131116000": 9, "145": [9, 10, 11], "131101000": 9, "131083000": 9, "147": [9, 11], "131069000": 9, "131061000": 9, "131055000": 9, "131053000": 9, "131017000": 9, "152": [9, 10, 11], "130827000": 9, "0553": 9, "130822000": 9, "130586000": 9, "130560000": 9, "0552": 9, "156": [9, 10, 11], "130554000": 9, "130462000": 9, "130390000": 9, "130376000": 9, "130053000": 9, "130016000": 9, "0551": 9, "129852000": 9, "129796000": 9, "129752000": 9, "129638000": 9, "0550": 9, "166": [9, 10, 11], "129415000": 9, "129413000": 9, "0549": 9, "129338000": 9, "169": [9, 11], "129216000": 9, "0548": 9, "129055000": 9, "0539": 9, "129023000": 9, "128812000": 9, "173": [9, 11], "128809000": 9, "0547": 9, "128793000": 9, "128688000": 9, "176": [9, 11], "128255000": 9, "0546": 9, "128243000": 9, "178": [9, 11], "127543000": 9, "179": [9, 11], "127017000": 9, "127008000": 9, "126858000": 9, "0545": 9, "182": [9, 11], "125797000": 9, "125342000": 9, "184": [9, 11], "54272000": 9, "0309": 9, "54271000": 9, "9965": 9, "035792": 9, "021437": 9, "495109": 9, "9983": 9, "616093": 9, "546870": 9, "683367": 9, "774501445415405": 9, "elasticnet": 9, "2142": 9, "058541995189524146": 9, "0472": 9, "0909955270741388": 9, "0448": 9, "005": [9, 11], "15085738749804528": 9, "030": 9, "033": [9, 11], "036": 9, "70303412073022": 9, "0331": 9, "057": [9, 11], "067": 9, "086": [9, 11], "094": 9, "7964686611607528": 9, "0308": 9, "205": [9, 11], "214": [9, 11], "227": [9, 11], "228": [9, 11], "229": [9, 11], "236": [9, 11], "237": [9, 11], "239": [9, 11], "242": [9, 11], "264": 9, "100400": 9, "2110": 9, "115600000": 9, "0349": 9, "115400000": 9, "114600000": 9, "114400000": 9, "113800000": 9, "0344": 9, "102000000": 9, "0310": 9, "101400000": 9, "100800000": 9, "0306": 9, "100400000": 9, "0305": 9, "97800000": 9, "0300": 9, "97200000": 9, "0298": 9, "97000000": 9, "96600000": 9, "0297": 9, "91000000": 9, "0282": 9, "90800000": 9, "90600000": 9, "0281": 9, "80800000": 9, "80600000": 9, "0248": 9, "80400000": 9, "0247": 9, "19000000": 9, "0070": 9, "18800000": 9, "0069": 9, "18400000": 9, "0068": 9, "9932": 9, "514956": 9, "248205": 9, "505187": 9, "9966": 9, "121009": 9, "339212": 9, "428001": 9, "9984": 9, "366166": 9, "483411": 9, "271539": 9, "demonstr": 10, "download": 10, "yourself": 10, "sphinx": 10, "ipynb": 10, "o": 10, "get_paper_dataset_path": 10, "thin": 10, "addition": 10, "certain": 10, "relev": 10, "data_path": 10, "read_parquet": 10, "unless": 10, "unus": 10, "still": 10, "m_restricted_featur": 10, "tabl": 10, "120054": 10, "12956": 10, "129946": 10, "12044": 10, "100096": 10, "4924": 10, "75185": 10, "10055": 10, "74719": 10, "10021": 10, "2490": 10, "25033": 10, "5045": 10, "49534": 10, "4981": 10, "75337": 10, "2474": 10, "74934": 10, "5010": 10, "25162": 10, "225028": 10, "17535": 10, "24972": 10, "7465": 10, "175673": 10, "12527": 10, "74327": 10, "12473": 10, "125113": 10, "17472": 10, "124887": 10, "7528": 10, "49933": 10, "12562": 10, "200067": 10, "12438": 10, "q25": 10, "median": 10, "q75": 10, "similarli": 10, "404918": 10, "383184": 10, "107753": 10, "171211": 10, "489148": 10, "780034": 10, "662572": 10, "20695": 10, "718093": 10, "743721": 10, "879321": 10, "58718": 10, "707782": 10, "629048": 10, "681391": 10, "352801": 10, "274990": 10, "063519": 10, "704149": 10, "876565": 10, "536365": 10, "274992": 10, "745450": 10, "747313": 10, "291448": 10, "535279": 10, "274993": 10, "736083": 10, "434020": 10, "264209": 10, "595582": 10, "133010": 10, "consist": 10, "doe": [10, 11], "266010": 10, "759575": 10, "325267": 10, "512966": 10, "250001": 10, "152645": 10, "515410": 10, "988094": 10, "540606": 10, "250002": 10, "079212": 10, "272208": 10, "090671": 10, "578266": 10, "250003": 10, "494927": 10, "336677": 10, "678251": 10, "559858": 10, "250004": 10, "036012": 10, "843524": 10, "586475": 10, "588368": 10, "built": 10, "quick": 10, "snapshot": 10, "situat": 10, "most": 10, "bc": 10, "palett": 10, "colorblind": 10, "set_ticklabel": 10, "fix": 10, "tick": 10, "set_tick": 10, "fixedloc": 10, "plt": 10, "gca": 10, "set_yticklabel": 10, "label": 10, "minor": 10, "unlik": 11, "correct": 11, "tri": 11, "possibli": 11, "807949": 11, "610298": 11, "912924": 11, "810836": 11, "541198": 11, "416988": 11, "876976": 11, "138610": 11, "789013": 11, "398077": 11, "939196": 11, "345017": 11, "890587": 11, "386701": 11, "140295": 11, "662026": 11, "692755": 11, "607476": 11, "130301": 11, "583192": 11, "798145": 11, "035281": 11, "744482": 11, "499644": 11, "044564": 11, "796983": 11, "983973": 11, "243734": 11, "013556": 11, "513956": 11, "undesir": 11, "900": 11, "250": 11, "30826677643062983": 11, "0466": 11, "4178302034480912": 11, "0370": 11, "009": 11, "010": 11, "011": 11, "013": 11, "019": 11, "096856154490844": 11, "0338": 11, "041": 11, "046": 11, "062": 11, "063": 11, "064": 11, "068": 11, "074": 11, "104136295096468": 11, "0333": 11, "084": 11, "692577101426174": 11, "0325": 11, "202": 11, "204": 11, "231": 11, "244": 11, "246": 11, "269": 11, "272": 11, "294": 11, "295": 11, "297": 11, "299": 11, "317": 11, "319": 11, "321": 11, "342": 11, "343": 11, "1176816672180467": 11, "0295": 11, "364": 11, "367": 11, "368": 11, "373": 11, "375": 11, "396": 11, "397": 11, "399": 11, "401": 11, "424": 11, "426": 11, "427": 11, "429": 11, "430": 11, "432": 11, "434": 11, "435": 11, "456": 11, "459": 11, "469": 11, "474": 11, "475": 11, "498": 11, "510": 11, "514": 11, "516": 11, "555": 11, "575": 11, "582": 11, "583": 11, "585": 11, "586": 11, "588": 11, "606": 11, "608": 11, "610": 11, "612": 11, "614": 11, "636": 11, "637": 11, "659": 11, "661": 11, "683": 11, "685": 11, "686": 11, "707": 11, "708": 11, "710": 11, "717": 11, "719": 11, "721": 11, "725": 11, "727": 11, "728": 11, "730": 11, "731": 11, "733": 11, "754": 11, "775": 11, "777": 11, "779": 11, "781": 11, "782": 11, "806": 11, "807": 11, "814": 11, "816": 11, "817": 11, "819": 11, "820": 11, "826": 11, "827": 11, "828": 11, "830": 11, "831": 11, "832": 11, "834": 11, "847": 11, "869": 11, "871": 11, "873": 11, "874": 11, "875": 11, "877": 11, "898": 11, "901": 11, "923": 11, "925": 11, "927": 11, "950": 11, "952": 11, "966": 11, "968": 11, "969": 11, "970": 11, "972": 11, "973": 11, "974": 11, "977": 11, "978": 11, "035": 11, "037": 11, "038": 11, "191": 11, "193": 11, "070": 11, "198": 11, "071": 11, "076": 11, "207": 11, "209": 11, "210": 11, "212": 11, "218": 11, "220": 11, "221": 11, "223": 11, "225": 11, "230": 11, "261": 11, "267": 11, "268": 11, "292": 11, "296": 11, "298": 11, "243": 11, "301": 11, "308": 11, "247": 11, "248": 11, "332": 11, "249": 11, "341": 11, "3446": 11, "549356": 11, "579121": 11, "890246": 11, "4926": 11, "557032": 11, "371970": 11, "182597": 11, "3456": 11, "742592": 11, "351062": 11, "254390": 11, "6891": 11, "909882": 11, "862281": 11, "818220": 11, "962": 11, "829914": 11, "725077": 11, "206007": 11, "axisgrid": 11, "facetgrid": 11, "0x7f8e68524a90": 11, "gt": 11, "instal": 12, "instruct": 12, "look": 12, "introduct": 12, "statement": 12, "pip": 12, "docker": 12, "core": 12, "simul": 12, "modul": 12, "page": 12}, "objects": {"pybalance.genetic": [[3, 0, 1, "", "GeneticMatcher"], [3, 2, 1, "", "get_global_defaults"]], "pybalance.genetic.GeneticMatcher": [[3, 1, 1, "", "match"]], "pybalance.lp": [[3, 0, 1, "", "ConstraintSatisfactionMatcher"]], "pybalance.lp.ConstraintSatisfactionMatcher": [[3, 1, 1, "", "match"]], "pybalance.propensity": [[3, 0, 1, "", "PropensityScoreMatcher"], [3, 2, 1, "", "plot_propensity_score_match_distributions"], [3, 2, 1, "", "plot_propensity_score_match_pairs"]], "pybalance.propensity.PropensityScoreMatcher": [[3, 1, 1, "", "match"]], "pybalance.sim": [[3, 2, 1, "", "generate_toy_dataset"], [3, 2, 1, "", "load_paper_dataset"]], "pybalance.utils": [[3, 2, 1, "", "BalanceCalculator"], [3, 0, 1, "", "BaseBalanceCalculator"], [3, 0, 1, "", "BaseMatchingPreprocessor"], [3, 0, 1, "", "BatchedBalanceCaclulator"], [3, 0, 1, "", "BetaBalance"], [3, 0, 1, "", "BetaMaxBalance"], [3, 0, 1, "", "BetaSquaredBalance"], [3, 0, 1, "", "CategoricOneHotEncoder"], [3, 0, 1, "", "ChainPreprocessor"], [3, 0, 1, "", "DecisionTreeEncoder"], [3, 0, 1, "", "GammaBalance"], [3, 0, 1, "", "GammaSquaredBalance"], [3, 0, 1, "", "GammaXTreeBalance"], [3, 0, 1, "", "MatchingData"], [3, 0, 1, "", "MatchingHeaders"], [3, 0, 1, "", "NumericBinsEncoder"], [3, 2, 1, "", "infer_matching_headers"], [3, 2, 1, "", "split_target_pool"]], "pybalance.utils.BaseBalanceCalculator": [[3, 1, 1, "", "per_feature_loss"]], "pybalance.utils.BaseMatchingPreprocessor": [[3, 1, 1, "", "_fit"], [3, 1, 1, "", "_get_feature_names_out"], [3, 1, 1, "", "_get_output_headers"], [3, 1, 1, "", "_transform"], [3, 1, 1, "", "fit"]], "pybalance.utils.MatchingData": [[3, 1, 1, "", "append"], [3, 1, 1, "", "copy"], [3, 3, 1, "", "data"], [3, 1, 1, "", "describe"], [3, 1, 1, "", "describe_categoric"], [3, 1, 1, "", "describe_numeric"], [3, 1, 1, "", "get_population"], [3, 1, 1, "", "head"], [3, 3, 1, "", "populations"], [3, 1, 1, "", "sample"], [3, 1, 1, "", "tail"], [3, 1, 1, "", "to_csv"], [3, 1, 1, "", "to_parquet"]], "pybalance.visualization": [[3, 2, 1, "", "plot_binary_features"], [3, 2, 1, "", "plot_categoric_features"], [3, 2, 1, "", "plot_joint_numeric_categoric_distributions"], [3, 2, 1, "", "plot_joint_numeric_distributions"], [3, 2, 1, "", "plot_numeric_features"], [3, 2, 1, "", "plot_per_feature_loss"]]}, "objtypes": {"0": "py:class", "1": "py:method", "2": "py:function", "3": "py:property"}, "objnames": {"0": ["py", "class", "Python class"], "1": ["py", "method", "Python method"], "2": ["py", "function", "Python function"], "3": ["py", "property", "Python property"]}, "titleterms": {"introduct": 0, "problem": 0, "statement": 0, "instal": 1, "instruct": 1, "from": 1, "pip": 1, "sourc": 1, "us": 1, "docker": 1, "demo": 2, "api": [3, 12], "document": 3, "tabl": [3, 12], "content": 3, "core": 3, "util": [3, 12], "match": [3, 7, 10], "data": [3, 10], "preprocess": 3, "balanc": [3, 6, 7], "calcul": [3, 6], "matcher": [3, 8, 9, 11], "propens": [3, 11], "score": [3, 11], "genet": [3, 6, 8], "constraint": [3, 7, 9], "satisfact": [3, 9], "visual": [3, 10], "simul": 3, "licens": [4, 12], "help": [5, 12], "fit": 6, "between": [6, 8, 9], "pool": [6, 7], "target": 6, "subset": 6, "sever": 6, "simultan": 6, "basic": 6, "optim": [6, 7, 8, 9, 11], "cardin": 7, "size": 7, "subject": 7, "without": 7, "beta": [8, 9, 11], "mean": [8, 9, 11], "absolut": [8, 9, 11], "smd": [8, 9, 11], "2": 8, "gamma": [8, 9], "area": [8, 9], "cdf": [8, 9], "With": 9, "cross": 9, "term": 9, "ad": 9, "initi": 10, "matchingdata": 10, "explor": 10, "pybal": 12, "usag": 12, "get": 12, "start": 12, "indic": 12}, "envversion": {"sphinx.domains.c": 3, "sphinx.domains.changeset": 1, "sphinx.domains.citation": 1, "sphinx.domains.cpp": 9, "sphinx.domains.index": 1, "sphinx.domains.javascript": 3, "sphinx.domains.math": 2, "sphinx.domains.python": 4, "sphinx.domains.rst": 2, "sphinx.domains.std": 2, "nbsphinx": 4, "sphinx.ext.intersphinx": 1, "sphinx.ext.viewcode": 1, "sphinx": 58}, "alltitles": {"Introduction": [[0, "introduction"]], "Problem Statement": [[0, "problem-statement"]], "Installation instructions": [[1, "installation-instructions"]], "Install from PIP": [[1, "install-from-pip"]], "Install from source": [[1, "install-from-source"]], "Use with docker": [[1, "use-with-docker"]], "Demos": [[2, "demos"], [2, null]], "API documentation": [[3, "api-documentation"]], "Table of Contents": [[3, "table-of-contents"]], "Core Utilities": [[3, "core-utilities"]], "Matching Data": [[3, "matching-data"], [10, "Matching-Data"]], "Preprocessing": [[3, "preprocessing"]], "Balance Calculators": [[3, "balance-calculators"], [6, "Balance-Calculators"]], "Matchers": [[3, "matchers"]], "Propensity Score Matcher": [[3, "propensity-score-matcher"], [11, "Propensity-Score-Matcher"]], "Genetic Matcher": [[3, "genetic-matcher"], [8, "Genetic-Matcher"]], "Constraint Satisfaction Matcher": [[3, "constraint-satisfaction-matcher"], [9, "Constraint-Satisfaction-Matcher"]], "Visualization": [[3, "visualization"]], "Simulation": [[3, "simulation"]], "License": [[4, "license"]], "Help": [[5, "help"]], "Fit Balance Calculator": [[6, "Fit-Balance-Calculator"]], "Balance between pool and target": [[6, "Balance-between-pool-and-target"]], "Balance between subset of pool and target": [[6, "Balance-between-subset-of-pool-and-target"]], "Balance between several subsets simultaneously": [[6, "Balance-between-several-subsets-simultaneously"]], "Basic Genetic Optimizer": [[6, "Basic-Genetic-Optimizer"]], "Cardinality matching": [[7, "Cardinality-matching"]], "Optimize pool size subject to balance constraint": [[7, "Optimize-pool-size-subject-to-balance-constraint"]], "Optimize balance with balance constraint": [[7, "Optimize-balance-with-balance-constraint"]], "Optimize balance without balance constraint": [[7, "Optimize-balance-without-balance-constraint"]], "Optimize Beta (Mean Absolute SMD)": [[8, "Optimize-Beta-(Mean-Absolute-SMD)"], [9, "Optimize-Beta-(Mean-Absolute-SMD)"], [11, "Optimize-Beta-(Mean-Absolute-SMD)"]], "Optimize Beta^2": [[8, "Optimize-Beta^2"]], "Optimize Gamma (Area Between CDFs)": [[8, "Optimize-Gamma-(Area-Between-CDFs)"], [9, "Optimize-Gamma-(Area-Between-CDFs)"]], "Optimize Beta With Cross Terms Added": [[9, "Optimize-Beta-With-Cross-Terms-Added"]], "Initializing MatchingData": [[10, "Initializing-MatchingData"]], "Exploring MatchingData": [[10, "Exploring-MatchingData"]], "Visualizing MatchingData": [[10, "Visualizing-MatchingData"]], "PyBalance Utilities": [[12, "pybalance-utilities"]], "Usage": [[12, "usage"]], "Getting Started": [[12, null]], "API": [[12, null]], "License & Help": [[12, null]], "Indices and tables": [[12, "indices-and-tables"]]}, "indexentries": {"balancecalculator() (in module pybalance.utils)": [[3, "pybalance.utils.BalanceCalculator"]], "basebalancecalculator (class in pybalance.utils)": [[3, "pybalance.utils.BaseBalanceCalculator"]], "basematchingpreprocessor (class in pybalance.utils)": [[3, "pybalance.utils.BaseMatchingPreprocessor"]], "batchedbalancecaclulator (class in pybalance.utils)": [[3, "pybalance.utils.BatchedBalanceCaclulator"]], "betabalance (class in pybalance.utils)": [[3, "pybalance.utils.BetaBalance"]], "betamaxbalance (class in pybalance.utils)": [[3, "pybalance.utils.BetaMaxBalance"]], "betasquaredbalance (class in pybalance.utils)": [[3, "pybalance.utils.BetaSquaredBalance"]], "categoriconehotencoder (class in pybalance.utils)": [[3, "pybalance.utils.CategoricOneHotEncoder"]], "chainpreprocessor (class in pybalance.utils)": [[3, "pybalance.utils.ChainPreprocessor"]], "constraintsatisfactionmatcher (class in pybalance.lp)": [[3, "pybalance.lp.ConstraintSatisfactionMatcher"]], "decisiontreeencoder (class in pybalance.utils)": [[3, "pybalance.utils.DecisionTreeEncoder"]], "gammabalance (class in pybalance.utils)": [[3, "pybalance.utils.GammaBalance"]], "gammasquaredbalance (class in pybalance.utils)": [[3, "pybalance.utils.GammaSquaredBalance"]], "gammaxtreebalance (class in pybalance.utils)": [[3, "pybalance.utils.GammaXTreeBalance"]], "geneticmatcher (class in pybalance.genetic)": [[3, "pybalance.genetic.GeneticMatcher"]], "matchingdata (class in pybalance.utils)": [[3, "pybalance.utils.MatchingData"]], "matchingheaders (class in pybalance.utils)": [[3, "pybalance.utils.MatchingHeaders"]], "numericbinsencoder (class in pybalance.utils)": [[3, "pybalance.utils.NumericBinsEncoder"]], "propensityscorematcher (class in pybalance.propensity)": [[3, "pybalance.propensity.PropensityScoreMatcher"]], "_fit() (pybalance.utils.basematchingpreprocessor method)": [[3, "pybalance.utils.BaseMatchingPreprocessor._fit"]], "_get_feature_names_out() (pybalance.utils.basematchingpreprocessor method)": [[3, "pybalance.utils.BaseMatchingPreprocessor._get_feature_names_out"]], "_get_output_headers() (pybalance.utils.basematchingpreprocessor method)": [[3, "pybalance.utils.BaseMatchingPreprocessor._get_output_headers"]], "_transform() (pybalance.utils.basematchingpreprocessor method)": [[3, "pybalance.utils.BaseMatchingPreprocessor._transform"]], "append() (pybalance.utils.matchingdata method)": [[3, "pybalance.utils.MatchingData.append"]], "copy() (pybalance.utils.matchingdata method)": [[3, "pybalance.utils.MatchingData.copy"]], "data (pybalance.utils.matchingdata property)": [[3, "pybalance.utils.MatchingData.data"]], "describe() (pybalance.utils.matchingdata method)": [[3, "pybalance.utils.MatchingData.describe"]], "describe_categoric() (pybalance.utils.matchingdata method)": [[3, "pybalance.utils.MatchingData.describe_categoric"]], "describe_numeric() (pybalance.utils.matchingdata method)": [[3, "pybalance.utils.MatchingData.describe_numeric"]], "fit() (pybalance.utils.basematchingpreprocessor method)": [[3, "pybalance.utils.BaseMatchingPreprocessor.fit"]], "generate_toy_dataset() (in module pybalance.sim)": [[3, "pybalance.sim.generate_toy_dataset"]], "get_global_defaults() (in module pybalance.genetic)": [[3, "pybalance.genetic.get_global_defaults"]], "get_population() (pybalance.utils.matchingdata method)": [[3, "pybalance.utils.MatchingData.get_population"]], "head() (pybalance.utils.matchingdata method)": [[3, "pybalance.utils.MatchingData.head"]], "infer_matching_headers() (in module pybalance.utils)": [[3, "pybalance.utils.infer_matching_headers"]], "load_paper_dataset() (in module pybalance.sim)": [[3, "pybalance.sim.load_paper_dataset"]], "match() (pybalance.genetic.geneticmatcher method)": [[3, "pybalance.genetic.GeneticMatcher.match"]], "match() (pybalance.lp.constraintsatisfactionmatcher method)": [[3, "pybalance.lp.ConstraintSatisfactionMatcher.match"]], "match() (pybalance.propensity.propensityscorematcher method)": [[3, "pybalance.propensity.PropensityScoreMatcher.match"]], "per_feature_loss() (pybalance.utils.basebalancecalculator method)": [[3, "pybalance.utils.BaseBalanceCalculator.per_feature_loss"]], "plot_binary_features() (in module pybalance.visualization)": [[3, "pybalance.visualization.plot_binary_features"]], "plot_categoric_features() (in module pybalance.visualization)": [[3, "pybalance.visualization.plot_categoric_features"]], "plot_joint_numeric_categoric_distributions() (in module pybalance.visualization)": [[3, "pybalance.visualization.plot_joint_numeric_categoric_distributions"]], "plot_joint_numeric_distributions() (in module pybalance.visualization)": [[3, "pybalance.visualization.plot_joint_numeric_distributions"]], "plot_numeric_features() (in module pybalance.visualization)": [[3, "pybalance.visualization.plot_numeric_features"]], "plot_per_feature_loss() (in module pybalance.visualization)": [[3, "pybalance.visualization.plot_per_feature_loss"]], "plot_propensity_score_match_distributions() (in module pybalance.propensity)": [[3, "pybalance.propensity.plot_propensity_score_match_distributions"]], "plot_propensity_score_match_pairs() (in module pybalance.propensity)": [[3, "pybalance.propensity.plot_propensity_score_match_pairs"]], "populations (pybalance.utils.matchingdata property)": [[3, "pybalance.utils.MatchingData.populations"]], "sample() (pybalance.utils.matchingdata method)": [[3, "pybalance.utils.MatchingData.sample"]], "split_target_pool() (in module pybalance.utils)": [[3, "pybalance.utils.split_target_pool"]], "tail() (pybalance.utils.matchingdata method)": [[3, "pybalance.utils.MatchingData.tail"]], "to_csv() (pybalance.utils.matchingdata method)": [[3, "pybalance.utils.MatchingData.to_csv"]], "to_parquet() (pybalance.utils.matchingdata method)": [[3, "pybalance.utils.MatchingData.to_parquet"]]}}) \ No newline at end of file +Search.setIndex({"docnames": ["00_introduction", "01_installation", "02_demos", "03_api", "04_license", "05_help", "demos/balance_calculators", "demos/card_matcher", "demos/ea_matcher", "demos/lp_matcher", "demos/matching_data", "demos/ps_matcher", "index"], "filenames": ["00_introduction.rst", "01_installation.rst", "02_demos.rst", "03_api.rst", "04_license.rst", "05_help.rst", "demos/balance_calculators.ipynb", "demos/card_matcher.ipynb", "demos/ea_matcher.ipynb", "demos/lp_matcher.ipynb", "demos/matching_data.ipynb", "demos/ps_matcher.ipynb", "index.rst"], "titles": ["Introduction", "Installation instructions", "Demos", "API documentation", "License", "Help", "Balance Calculators", "Cardinality matching", "Genetic Matcher", "Constraint Satisfaction Matcher", "Matching Data", "Propensity Score Matcher", "PyBalance Utilities"], "terms": {"The": [0, 3, 7, 8, 9, 10, 11], "pybal": [0, 1, 3, 5, 6, 7, 8, 9, 10, 11], "librari": [0, 8], "implement": [0, 3, 6, 7], "sever": [0, 2, 12], "routin": [0, 3, 10], "optim": [0, 2, 3, 12], "balanc": [0, 1, 2, 8, 9, 11, 12], "between": [0, 2, 3, 12], "non": [0, 3, 8, 9], "random": [0, 6], "popul": [0, 3, 6, 7, 8, 9, 10, 11], "In": [0, 3, 7, 8, 10, 11], "observ": 0, "studi": 0, "thi": [0, 1, 3, 4, 6, 7, 8, 9, 10, 11], "match": [0, 2, 6, 8, 9, 11, 12], "process": [0, 7], "i": [0, 1, 3, 4, 6, 7, 9, 10, 11], "kei": [0, 3], "step": [0, 3, 7], "toward": 0, "minim": [0, 9], "potenti": [0, 11], "effect": [0, 3], "confound": 0, "covari": [0, 3, 7, 8, 9, 10], "two": [0, 3, 9, 10], "separ": [0, 3, 10], "approach": 0, "both": [0, 3, 8], "which": [0, 1, 3, 8, 9, 10, 11], "work": [0, 6], "distribut": [0, 3, 4, 8, 10], "directli": [0, 11], "without": [0, 2, 4, 12], "specifi": [0, 3, 6, 10], "whom": 0, "given": [0, 3, 7, 10, 11], "individu": [0, 7], "consid": [0, 3, 6], "group": [0, 1, 3, 5, 10], "subject": [0, 3, 7, 9], "togeth": 0, "set": [0, 3, 7, 9], "f": [0, 1, 6], "e": [0, 1, 3, 6, 10], "g": [0, 1, 3, 6, 10], "ag": [0, 3, 4, 6, 7, 8, 9, 10, 11], "height": [0, 3, 6, 7, 8, 9, 10, 11], "smoker": 0, "describ": [0, 3, 10], "characterist": 0, "By": [0, 3], "convent": 0, "we": [0, 1, 3, 7, 8, 9, 10, 11], "refer": [0, 3, 9, 10], "smaller": [0, 3, 10, 11], "target": [0, 2, 3, 7, 8, 9, 10, 11, 12], "larger": [0, 3, 7], "pool": [0, 2, 3, 8, 9, 10, 11, 12], "our": [0, 10], "goal": 0, "draw": 0, "from": [0, 3, 4, 6, 7, 8, 9, 10, 11, 12], "chosen": 0, "subset": [0, 2, 3, 7, 9, 10, 12], "defin": [0, 3], "close": 0, "possibl": [0, 3, 4, 9], "more": [0, 3, 7], "formal": 0, "size": [0, 2, 3, 6, 9, 10, 12], "m": [0, 1, 6, 7, 8, 9, 10, 11], "n": [0, 1, 3, 6, 10], "choos": [0, 3, 9], "patient": [0, 3, 7, 8, 9], "best": [0, 3, 6, 8, 9, 11], "resembl": 0, "sinc": [0, 3, 7], "ar": [0, 3, 4, 6, 9, 10], "explor": [0, 2, 12], "whole": [0, 6], "space": [0, 3, 9], "solut": [0, 3, 7, 8, 9, 11], "gener": [0, 3, 6, 7, 8, 10], "infeas": 0, "even": [0, 4], "modestli": 0, "depend": [0, 1, 3], "natur": [0, 9], "measur": [0, 11], "differ": [0, 3, 7, 10], "solver": [0, 3, 7, 8, 9, 11], "avail": 0, "For": [0, 3, 7], "instanc": [0, 3], "case": [0, 3, 7, 10], "mean": [0, 2, 3, 6, 7, 10, 12], "standard": [0, 3, 7, 10], "error": [0, 3, 6, 7, 9], "one": [0, 3, 5, 10], "can": [0, 1, 3, 6, 7, 8, 9, 10, 11], "formul": [0, 3], "follow": [0, 3, 4, 12], "begin": [0, 7, 9], "equat": [0, 7, 9], "x_": 0, "1": [0, 3, 6, 7, 8, 9, 10, 11], "mbox": 0, "select": [0, 1, 3], "0": [0, 3, 6, 7, 8, 9, 10, 11], "otherwis": [0, 3, 4], "end": [0, 7, 9], "take": [0, 6, 9], "c_": 0, "mf": 0, "valu": [0, 3, 6, 9, 10], "featur": [0, 3, 7, 9, 10], "correspond": [0, 3], "": [0, 3, 6, 7, 8, 9, 10, 11], "align": [0, 7, 9], "a_f": 0, "bigg": 0, "sum_": 0, "object": [0, 3, 7, 8, 9, 10, 11], "function": [0, 3, 8, 9, 10], "constraint": [0, 2, 12], "linear": [0, 3, 7, 8, 9], "fast": 0, "integ": [0, 7, 9], "program": 0, "us": [0, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], "backend": 0, "solv": [0, 3, 7, 9], "cost": 0, "2": [0, 2, 3, 6, 7, 9, 10, 11, 12], "sat": [0, 3], "googl": [0, 3], "Or": 0, "tool": [0, 3, 10], "note": [0, 1, 3, 7, 9, 10, 11], "do": [0, 1, 11], "explicitli": [0, 3, 7, 10], "assign": [0, 10], "control": [0, 3], "treatment": [0, 3], "therefor": 0, "decis": [0, 3], "variabl": [0, 3, 7, 9, 10], "x": [0, 3], "simpli": [0, 1, 10, 12], "vector": 0, "length": 0, "equal": [0, 3], "number": [0, 3, 6, 7, 9, 10, 11], "detail": [0, 3], "allow": [0, 1, 3, 9], "scale": [0, 7, 9], "rel": 0, "larg": [0, 3, 11], "howev": [0, 3, 4, 7], "alwai": [0, 1, 3], "desir": [0, 1], "improv": [0, 3], "poorli": 0, "dimens": [0, 7, 9], "slightli": [0, 9], "often": [0, 3, 10], "better": 0, "than": [0, 3, 11], "well": [0, 3], "same": [0, 3, 6], "amount": 0, "enforc": 0, "prior": [0, 4], "requir": [0, 1, 3], "method": [0, 3, 8, 10, 11], "appli": [0, 3, 7, 9], "an": [0, 3, 6, 7, 8], "evolutionari": [0, 3], "stochast": 0, "search": [0, 3, 7, 12], "also": [0, 1, 3, 6, 7], "heurist": 0, "effici": 0, "complet": 0, "eas": 0, "comparison": 0, "base": [0, 3], "propens": [0, 2, 8, 9, 12], "score": [0, 2, 7, 8, 9, 12], "greater": 0, "technic": [0, 3], "applic": 0, "see": [0, 1, 3, 9], "public": 0, "here": [0, 1, 3, 6, 7, 9, 10], "reccomend": 1, "conda": 1, "creat": [1, 3, 6, 7], "python": 1, "3": [1, 3, 4, 6, 7, 8, 9, 10, 11], "9": [1, 6, 7, 8, 9, 10, 11], "activ": 1, "If": [1, 3, 5, 11], "you": [1, 3, 5, 7, 10], "wish": 1, "within": [1, 3, 7], "jupyt": 1, "notebook": [1, 8, 10, 11], "need": [1, 3], "regist": [1, 3], "your": 1, "enviro": 1, "ipykernel": 1, "user": [1, 3, 6, 8, 10, 11], "name": [1, 3, 4, 9, 10], "make": [1, 7], "sure": 1, "kernel": 1, "when": [1, 6, 9], "run": [1, 7, 10], "suggest": [1, 5], "latest": 1, "releas": [1, 3], "found": [1, 3, 5, 6, 7, 8, 9, 11], "http": [1, 3, 5, 9, 10], "github": [1, 3, 5, 10], "com": [1, 3, 5, 10], "bayer": [1, 4, 5, 10], "To": [1, 3], "clone": 1, "repositori": 1, "checkout": 1, "git": 1, "cd": 1, "vx": 1, "y": [1, 3], "z": 1, "where": [1, 7, 9, 10], "tag": 1, "virtual": 1, "environ": 1, "favorit": 1, "manag": 1, "yourenv": 1, "r": 1, "txt": 1, "gpu": [1, 3], "acceler": [1, 3], "onli": [1, 3, 7, 9, 10], "geneticmatch": [1, 3, 8, 11], "addit": [1, 3], "requirements_gpu": 1, "Then": [1, 7], "code": [1, 4], "setup": 1, "py": [1, 3, 6, 8, 9, 10, 11], "maintain": [1, 5], "those": [1, 3], "who": 1, "prefer": 1, "develop": [1, 5], "build": [1, 7, 9], "imag": 1, "t": [1, 3, 6, 7, 9], "dev": 1, "dockerfil": 1, "enter": 1, "v": 1, "path": [1, 3, 10], "local": [1, 3], "top": [1, 3], "level": [1, 3, 7, 8, 9, 10, 11], "directori": 1, "attach": 1, "wai": [1, 3, 4], "immedi": 1, "chang": [1, 5], "access": [1, 3, 10], "compos": 1, "up": [1, 3, 9], "navig": 1, "link": 1, "print": [1, 3, 6], "screen": 1, "connect": 1, "server": 1, "should": [1, 3, 9, 10], "save": 1, "want": 1, "persist": 1, "provid": [1, 3, 4], "have": [1, 3, 5, 6, 7, 12], "acceess": 1, "calcul": [1, 2, 7, 9, 12], "pyblal": 1, "data": [2, 4, 6, 12], "initi": [2, 3, 7, 8, 9, 12], "matchingdata": [2, 3, 6, 7, 8, 12], "visual": [2, 7, 8, 9, 11, 12], "fit": [2, 3, 4, 12], "simultan": [2, 12], "basic": [2, 3, 11, 12], "genet": [2, 12], "matcher": [2, 7, 12], "beta": [2, 3, 6, 12], "absolut": [2, 3, 12], "smd": [2, 12], "gamma": [2, 3, 7, 12], "area": [2, 3, 12], "cdf": [2, 12], "satisfact": [2, 12], "With": [2, 12], "cross": [2, 12], "term": [2, 12], "ad": [2, 12], "cardin": [2, 3, 12], "class": [3, 10], "matchinghead": [3, 10], "categor": [3, 6, 7, 8, 9, 10, 11], "numer": [3, 6, 7, 8, 9, 10, 11], "sourc": [3, 4, 12], "simpl": 3, "structur": 3, "store": 3, "inform": 3, "about": [3, 7, 10], "countri": [3, 6, 7, 8, 9, 10, 11], "gender": [3, 6, 7, 8, 9, 10, 11], "weight": [3, 6, 7, 8, 9, 10, 11], "type": 3, "paramet": 3, "list": [3, 4, 6, 9], "str": 3, "treat": [3, 10], "header": [3, 6, 7, 8, 9, 10, 11], "none": [3, 6, 7, 8, 9, 11], "population_col": 3, "It": [3, 6, 7, 10], "common": 3, "problem": [3, 9, 12], "metadata": [3, 10], "order": [3, 7, 9], "perform": 3, "mai": [3, 4], "contain": 3, "column": [3, 6, 7, 8, 9, 10, 11], "patient_id": [3, 6, 7, 8, 9, 10, 11], "index_d": 3, "intend": 3, "must": [3, 4, 6], "go": [3, 9], "along": [3, 10], "ride": 3, "main": [3, 10], "everywher": 3, "wrapper": [3, 10], "around": [3, 10], "panda": [3, 9, 10], "datafram": [3, 9, 10], "includ": [3, 4, 8], "logic": [3, 10], "field": [3, 10], "while": 3, "other": [3, 4], "exist": 3, "alongsid": 3, "pd": [3, 10], "frame": 3, "all": [3, 6, 7], "least": [3, 7], "each": [3, 10], "row": [3, 6, 7, 8, 9, 10, 11], "belong": 3, "string": [3, 10], "pass": [3, 7, 9, 10], "assum": 3, "option": [3, 6], "A": [3, 4, 9], "whose": 3, "infer": [3, 10], "how": [3, 8, 10], "mani": [3, 10], "uniqu": 3, "ha": 3, "As": 3, "guess": 3, "lead": 3, "recommend": 3, "suppli": 3, "them": 3, "split": [3, 10], "subpopul": 3, "append": [3, 8, 9, 11], "df": 3, "oper": 3, "inplac": 3, "copi": [3, 8, 9, 11], "new": 3, "exact": 3, "return": [3, 6, 9, 10, 11], "properti": 3, "pointer": 3, "underli": [3, 10], "normal": [3, 10], "true": [3, 7, 8, 9, 10, 11], "aggreg": 3, "std": [3, 10], "quantil": 3, "25": [3, 6, 8, 9, 10, 11], "5": [3, 6, 7, 8, 9, 10, 11], "75": [3, 7, 8, 9, 10, 11], "call": [3, 6, 8, 10], "describe_categor": 3, "describe_numer": 3, "result": [3, 11], "singl": [3, 6], "summari": [3, 10], "statist": 3, "long_format": 3, "get_popul": [3, 7, 8, 9, 11], "get": [3, 5, 10], "its": [3, 4], "head": [3, 10], "first": 3, "present": [3, 10], "sampl": [3, 6, 8], "tail": 3, "last": 3, "to_csv": 3, "arg": 3, "kwarg": 3, "write": 3, "csv": 3, "signatur": 3, "ident": 3, "to_parquet": 3, "parquet": 3, "infer_matching_head": 3, "max_categori": 3, "10": [3, 6, 7, 8, 9, 10, 11], "ignore_col": 3, "patientid": 3, "input": 3, "either": [3, 10], "combin": 3, "keyword": [3, 10], "argument": [3, 10], "dictionari": 3, "default": [3, 7], "ignor": 3, "split_target_pool": [3, 6, 10], "matching_data": [3, 7, 8, 10, 11], "pool_nam": 3, "target_nam": [3, 10], "attempt": 3, "basematchingpreprocessor": 3, "abstract": 3, "preprocessor": [3, 6], "organ": [3, 10], "transform": 3, "keep": [3, 7, 10], "track": [3, 10], "so": [3, 6], "inherit": 3, "_fit": 3, "_transform": 3, "_get_output_head": 3, "_get_feature_names_out": 3, "extend": 3, "sklearn": [3, 8, 9, 11], "handl": 3, "conform": 3, "chainabl": 3, "easili": 3, "task": 3, "chainpreprocessor": 3, "comput": [3, 8, 9], "deviat": 3, "accept": 3, "overridden": 3, "subclass": 3, "feature_name_in": 3, "get_feature_names_out": 3, "output": 3, "particular": [3, 4, 11], "refit": 3, "fals": [3, 6, 7, 8, 9, 10, 11], "workhors": 3, "mark": 3, "after": [3, 10], "prevent": 3, "twice": 3, "categoriconehotencod": 3, "drop": 3, "convert": [3, 6], "hot": 3, "encod": 3, "unaffect": 3, "ani": [3, 4, 8, 9, 10], "choic": [3, 6, 9], "if_binari": 3, "onehotencod": 3, "numericbinsencod": 3, "n_bin": 3, "strategi": 3, "uniform": [3, 8], "onehot": 3, "dens": 3, "cumul": [3, 10], "discret": [3, 7, 8, 9], "accord": [3, 8, 11], "bin": [3, 6, 7, 8, 9, 10], "int": 3, "would": [3, 10], "avoid": 3, "intern": [3, 6], "kmean": 3, "kbinsdiscret": 3, "ordin": 3, "bool": 3, "whether": [3, 4], "3rd": 3, "4": [3, 6, 7, 8, 9, 10, 11], "map": 3, "decisiontreeencod": 3, "keep_original_featur": 3, "decision_tree_param": 3, "binari": [3, 4], "coviat": 3, "termin": 3, "leaf": 3, "posit": 3, "tree": 3, "sequenc": 3, "basebalancecalcul": 3, "feature_weight": [3, 8], "standardize_differ": [3, 7, 10], "devic": 3, "low": 3, "interfac": 3, "matrix": 3, "pytorch": [3, 6], "per": 3, "loss": [3, 4, 7, 8, 9], "furthermor": 3, "time": [3, 7, 8, 9, 11], "distanc": [3, 6, 7], "exactli": [3, 10], "some": [3, 7, 10], "expon": 3, "total": 3, "sum": 3, "feature_loss": 3, "system": 3, "per_feature_loss": [3, 7], "pool_subset": [3, 6], "target_subset": [3, 6], "mismatch": [3, 7, 9], "aka": 3, "basi": 3, "candid": [3, 8], "tensor": [3, 6, 7], "betabal": [3, 6, 8, 9, 10, 11], "conveni": [3, 10], "standardmatchingpreprocessor": 3, "betasquaredbal": [3, 8], "except": [3, 6], "averag": 3, "squar": 3, "fashion": 3, "betamaxbal": [3, 8], "worst": [3, 8], "determin": [3, 7], "metric": [3, 11], "criterion": 3, "suffici": 3, "good": [3, 4, 6], "awar": 3, "variou": 3, "unwant": 3, "behavior": [3, 9], "signal": 3, "gammabal": [3, 7, 8, 9], "dimension": 3, "margin": 3, "gammapreprocessor": 3, "descript": 3, "gammasquaredbal": [3, 8], "gammaxtreebal": [3, 8, 9], "balancecalcul": 3, "appropri": 3, "against": 3, "balance_calcul": [3, 6, 7], "therein": 3, "configur": 3, "specif": [3, 4], "batchedbalancecaclul": 3, "max_batch_size_gb": [3, 8], "8": [3, 7, 8, 9, 10, 11], "batch": 3, "peak": 3, "memori": 3, "usag": [3, 11], "propensityscorematch": [3, 11], "calip": [3, 11], "max_it": [3, 8, 9, 11], "50": [3, 6, 7, 8, 9, 10, 11], "time_limit": [3, 7, 8, 9, 11], "300": [3, 8], "greedi": [3, 11], "verbos": [3, 8, 9], "model": [3, 7, 8, 9, 11], "randomli": 3, "over": 3, "hyperparamet": 3, "known": [3, 9], "float": 3, "restrict": 3, "maximum": 3, "try": [3, 6, 9], "befor": [3, 6], "No": 3, "train": [3, 8, 9, 11], "second": [3, 7], "began": 3, "linear_sum_assign": 3, "former": 3, "global": 3, "sub": 3, "optimi": 3, "latter": 3, "far": 3, "intens": 3, "flag": 3, "indic": 3, "diagnosit": 3, "dure": 3, "__init__": 3, "plot_propensity_score_match_distribut": [3, 11], "plot": [3, 10], "histogram": 3, "estim": 3, "pre": 3, "post": 3, "plot_propensity_score_match_pair": 3, "scatterplot": 3, "pair": 3, "form": [3, 4], "param": 3, "algorithm": [3, 8], "get_global_default": [3, 8], "seed": [3, 8, 11], "n_candidate_popul": [3, 8], "5000": [3, 8, 10], "reason": 3, "break": 3, "govern": 3, "mix": [3, 6], "evolv": 3, "lp": [3, 7, 9], "constraintsatisfactionmatch": [3, 7, 9, 11], "match_siz": 3, "pool_siz": [3, 6, 7, 9], "target_s": [3, 6, 7, 9], "max_mismatch": [3, 7, 9], "180": [3, 8, 9, 11], "num_work": [3, 9], "ps_hint": [3, 9], "satisf": 3, "below": 3, "via": 3, "n_target": [3, 7, 11], "kosukeimai": 3, "io": 3, "matchit": 3, "method_cardin": 3, "html": [3, 9], "cannot": 3, "itself": 3, "report": [3, 7, 9], "actual": [3, 9], "find": [3, 7], "c": [3, 4, 8, 9, 11], "full": [3, 9], "deprec": 3, "remov": [3, 7], "later": 3, "less": 3, "limit": [3, 4, 8], "stop": [3, 8], "def": [3, 6], "sec": 3, "worker": [3, 7, 9], "blob": [3, 10], "stabl": [3, 9], "ortool": 3, "sat_paramet": 3, "proto": 3, "l556": 3, "hint": [3, 9], "entir": 3, "being": [3, 9, 11], "omit": 3, "altogheth": 3, "fly": 3, "admit": 3, "bit": 3, "confus": 3, "clean": 3, "plot_numeric_featur": [3, 7, 8, 9, 10, 11], "col_wrap": 3, "6": [3, 7, 8, 9, 10, 11], "plot_param": 3, "extra": [3, 10], "seaborn": [3, 10, 11], "histplot": 3, "overrid": 3, "figur": 3, "plot_categoric_featur": [3, 7, 8, 9, 10, 11], "include_binari": [3, 10], "plot_binary_featur": [3, 8, 9, 10, 11], "max_featur": 3, "include_onli": 3, "orient_horizont": [3, 10], "reference_popul": 3, "sn": 3, "barplot": 3, "max": [3, 7, 10], "show": [3, 8, 11], "lot": 3, "sort": 3, "descend": 3, "shown": 3, "orient": 3, "axi": 3, "compar": [3, 6], "plot_joint_numeric_distribut": [3, 10, 11], "joint_kind": 3, "kde": 3, "2d": 3, "scatter": 3, "usual": 3, "bad": 3, "dataset": [3, 9], "jointgrid": 3, "plot_joint_numeric_categoric_distribut": [3, 10], "include_only_numer": 3, "include_only_categor": 3, "plot_per_feature_loss": [3, 8, 9, 10, 11], "debin": [3, 8, 9, 11], "back": 3, "real": 3, "like": 3, "country_u": 3, "country_germani": 3, "divid": 3, "contribut": 3, "obtain": 3, "sim": [3, 6, 7, 8, 9, 10, 11], "generate_toy_dataset": [3, 7, 8, 9, 11], "n_pool": [3, 7, 11], "10000": [3, 8, 9, 11], "1000": [3, 6, 7, 8, 9, 11], "45": [3, 8, 9, 10, 11], "toi": 3, "finer": 3, "generate_random_feature_data_rwd": 3, "generate_random_feature_data_rct": 3, "load_paper_dataset": [3, 6, 7], "load": 3, "paper": 3, "onlinelibrari": 3, "wilei": 3, "doi": 3, "1002": 3, "pst": 3, "2352": 3, "bsd": 4, "claus": 4, "copyright": 4, "2024": 4, "redistribut": 4, "modif": 4, "permit": 4, "condit": 4, "met": 4, "retain": 4, "abov": 4, "notic": 4, "disclaim": 4, "reproduc": 4, "document": [4, 9, 12], "materi": 4, "neither": 4, "holder": 4, "nor": 4, "contributor": 4, "endors": 4, "promot": 4, "product": 4, "deriv": 4, "softwar": 4, "written": 4, "permiss": 4, "BY": 4, "THE": 4, "AND": 4, "AS": 4, "express": 4, "OR": 4, "impli": 4, "warranti": 4, "BUT": 4, "NOT": 4, "TO": 4, "OF": 4, "merchant": 4, "FOR": 4, "purpos": 4, "IN": 4, "NO": 4, "event": 4, "shall": 4, "BE": 4, "liabl": 4, "direct": 4, "indirect": 4, "incident": 4, "special": 4, "exemplari": 4, "consequenti": 4, "damag": 4, "procur": 4, "substitut": 4, "servic": 4, "profit": 4, "busi": 4, "interrupt": 4, "caus": 4, "ON": 4, "theori": 4, "liabil": 4, "contract": 4, "strict": 4, "tort": 4, "neglig": 4, "aris": 4, "out": 4, "IF": 4, "advis": 4, "SUCH": 4, "re": [5, 7], "troubl": 5, "toolkit": 5, "pleas": [5, 6], "touch": 5, "stephen": 5, "privitera": 5, "hooman": 5, "sedghamiz": 5, "alexand": 5, "hartenstein": 5, "abhishek": 5, "choudhari": 5, "ve": 5, "bug": 5, "open": 5, "ticket": 5, "issu": 5, "util": [6, 7, 8, 9, 10, 11], "import": [6, 7, 8, 9, 10, 11], "haircolor": [6, 7, 8, 9, 10, 11], "binary_0": [6, 7, 8, 9, 10, 11], "binary_1": [6, 7, 8, 9, 10, 11], "binary_2": [6, 7, 8, 9, 10, 11], "binary_3": [6, 7, 8, 9, 10, 11], "64": [6, 9, 10, 11], "854093": [6, 10], "189": [6, 8, 9, 10, 11], "466850": [6, 10], "88": [6, 8, 9, 10, 11], "835049": [6, 10], "135740": [6, 10], "52": [6, 9, 10, 11], "571993": [6, 10], "158": [6, 8, 9, 10, 11], "134940": [6, 10], "94": [6, 8, 9, 10, 11], "215107": [6, 10], "49288": [6, 10], "828361": [6, 10], "154": [6, 8, 9, 10, 11], "692482": [6, 10], "226222": [6, 10], "256676": [6, 10], "70": [6, 7, 8, 9, 10, 11], "177571": [6, 10], "160": [6, 8, 9, 10, 11], "536632": [6, 10], "244356": [6, 10], "338287": [6, 10], "73": [6, 7, 8, 9, 10, 11], "779164": [6, 10], "153": [6, 9, 10, 11], "551419": [6, 10], "86": [6, 8, 9, 10, 11], "161814": [6, 10], "72849": [6, 10], "274995": [6, 10], "62": [6, 7, 8, 9, 10, 11], "547794": [6, 10], "186": [6, 8, 9, 10, 11], "005015": [6, 10], "975051": [6, 10], "579081": [6, 10], "274996": [6, 10], "69": [6, 9, 10, 11], "879934": [6, 10], "142": [6, 8, 9, 10, 11], "371386": [6, 10], "100": [6, 8, 9, 10, 11], "138389": [6, 10], "569939": [6, 10], "274997": [6, 10], "56": [6, 7, 8, 9, 10, 11], "921402": [6, 10], "130": [6, 7, 8, 9, 10, 11], "639589": [6, 10], "108": [6, 7, 8, 9, 10, 11], "745182": [6, 10], "532419": [6, 10], "274998": [6, 10], "34": [6, 7, 8, 9, 10, 11], "082754": [6, 10], "174": [6, 9, 10, 11], "764051": [6, 10], "67": [6, 7, 8, 9, 10, 11], "998396": [6, 10], "566266": [6, 10], "274999": [6, 10], "60": [6, 9, 10, 11], "981259": [6, 10], "137": [6, 8, 9, 10, 11], "419436": [6, 10], "89": [6, 9, 10, 11], "897817": [6, 10], "544231": [6, 10], "275000": [6, 10], "12": [6, 7, 8, 9, 10, 11], "13": [6, 7, 8, 9, 10, 11], "count": 6, "250000": [6, 10], "25000": [6, 10], "14": [6, 8, 9, 10, 11], "what": [6, 7], "involv": 6, "onc": 6, "meaningfulli": 6, "15": [6, 8, 9, 10, 11], "2353": 6, "dtype": 6, "torch": 6, "float64": 6, "16": [6, 8, 9, 10, 11], "17": [6, 8, 9, 11], "2366": 6, "18": [6, 7, 8, 9, 10, 11], "2669": 6, "19": [6, 8, 9, 10, 11], "np": 6, "arrai": 6, "reset_index": 6, "index": [6, 7, 9, 12], "replac": 6, "2404": 6, "2418": 6, "gmema": 6, "src": [6, 8, 10, 11], "224": [6, 8, 9, 11], "userwarn": [6, 10], "numpi": 6, "ndarrai": 6, "extrem": 6, "slow": 6, "trigger": 6, "runner": 6, "csrc": 6, "tensor_new": 6, "cpp": 6, "278": [6, 9], "subset_popul": 6, "2602": 6, "2757": 6, "28": [6, 7, 8, 9, 11], "throw": 6, "valueerror": 6, "veri": 6, "un": 6, "smart": 6, "becaus": 6, "doesn": 6, "just": [6, 10], "illustr": 6, "27": [6, 7, 8, 9, 10, 11], "get_subset": 6, "n_subset": 6, "_": 6, "rang": [6, 9], "best_match": 6, "best_dist": 6, "100000": 6, "j": 6, "this_best_dist": 6, "min": [6, 8, 9, 10, 11], "best_match_idx": 6, "argmin": 6, "3f": 6, "215": [6, 9, 11], "20": [6, 7, 8, 9, 11], "211": [6, 8, 9, 11], "30": [6, 8, 9, 10, 11], "40": [6, 7, 8, 9, 11], "208": [6, 9, 11], "80": [6, 7, 9, 11], "90": [6, 7, 9, 11], "largest": 7, "hat": [7, 9], "p": [7, 9], "underset": [7, 9], "text": [7, 9], "maxim": 7, "mu_": [7, 9], "k": [7, 9], "leq": 7, "delta": 7, "textrm": 7, "among": 7, "log": [7, 8, 9, 10, 11], "basicconfig": [7, 8, 9, 10, 11], "info": [7, 8, 9, 10, 11], "15000": 7, "731988": 7, "816972": 7, "76": [7, 9, 10, 11], "100401": 7, "26": [7, 8, 9, 11], "403338": 7, "784188": 7, "134423": 7, "58": [7, 8, 9, 10, 11], "155044": 7, "175": [7, 9, 10, 11], "704961": 7, "806745": 7, "68": [7, 8, 9, 10, 11], "334248": 7, "167": [7, 8, 9, 10, 11], "485984": 7, "081777": 7, "54": [7, 8, 9, 11], "114518": 7, "782073": 7, "53": [7, 8, 9, 10, 11], "612174": 7, "995": [7, 8, 9, 11], "21": [7, 8, 9, 11], "474205": [7, 8, 9], "168": [7, 8, 9, 11], "602546": [7, 8, 9], "342128": [7, 8, 9], "15995": 7, "996": [7, 8, 9, 11], "643320": [7, 8, 9], "188": [7, 8, 9, 11], "188724": [7, 8, 9], "61": [7, 8, 9, 10, 11], "611744": [7, 8, 9], "15996": 7, "997": [7, 8, 9, 11], "29": [7, 8, 9, 10, 11], "472765": [7, 8, 9], "161": [7, 8, 9, 11], "408162": [7, 8, 9], "57": [7, 8, 9, 10, 11], "214095": [7, 8, 9], "15997": 7, "998": [7, 8, 9, 11], "41": [7, 8, 9, 10, 11], "291949": [7, 8, 9], "150": [7, 8, 9, 11], "968833": [7, 8, 9], "91": [7, 8, 9, 11], "270798": [7, 8, 9], "15998": 7, "999": [7, 8, 9, 11], "530294": [7, 8, 9], "155": [7, 8, 9, 11], "124741": [7, 8, 9], "196505": [7, 8, 9], "15999": 7, "16000": 7, "standardized_differ": 7, "affect": 7, "consist": [7, 10], "05": [7, 8, 9], "600": 7, "match_card": 7, "preprocess": [7, 8, 9], "02": [7, 8, 9], "51": [7, 8, 9, 11], "37": [7, 8, 9, 10, 11], "01": [7, 8, 9, 10], "46": [7, 8, 9, 10, 11], "65": [7, 8, 9, 11], "125": [7, 8, 9, 10, 11], "136": [7, 8, 9, 11], "148": [7, 8, 9, 11], "33": [7, 8, 9, 10, 11], "159": [7, 9, 10, 11], "99": [7, 9, 11], "171": [7, 8, 9, 11], "66": [7, 8, 9, 10, 11], "183": [7, 8, 9, 11], "32": [7, 8, 9, 10, 11], "194": [7, 9, 11], "85": [7, 8, 9, 10, 11], "96": [7, 8, 9, 10, 11], "120": [7, 8, 9, 10, 11], "factor": [7, 9], "200": [7, 9, 11], "00": [7, 9, 10], "lt": [7, 9, 11], "0000": [7, 9], "bound": [7, 9], "1236": 7, "36": [7, 8, 9, 11], "13153": 7, "0068": [7, 9], "1847": 7, "47": [7, 8, 9, 11], "12981": 7, "0163": 7, "2019": 7, "12937": 7, "0171": 7, "2063": 7, "55": [7, 8, 9, 10, 11], "12910": 7, "0178": 7, "2090": 7, "98": [7, 9, 11], "12907": 7, "0179": 7, "2093": 7, "12906": 7, "0250": 7, "2094": 7, "7": [7, 8, 9, 10, 11], "22": [7, 8, 9, 11], "12689": 7, "0259": 7, "2311": 7, "39": [7, 8, 9, 10, 11], "12632": 7, "0260": 7, "2368": 7, "10818": 7, "0413": 7, "4182": 7, "statu": [7, 9], "feasibl": [7, 9], "progress": [7, 9], "increas": [7, 9], "harder": 7, "thei": 7, "degre": 7, "freedom": 7, "tradeoff": 7, "let": 7, "check": 7, "satisfi": 7, "0500": 7, "matplotlib": [7, 8, 9, 10, 11], "inlin": [7, 8, 9, 10, 11], "fig": [7, 8, 9, 10, 11], "now": 7, "len": [7, 9, 10], "match_dist": 7, "825443200": 7, "0366": 7, "825304800": 7, "0365": 7, "733533600": 7, "0325": [7, 11], "59": [7, 9, 10, 11], "733527200": 7, "733465600": 7, "24": [7, 8, 9, 11], "733395200": 7, "don": 7, "care": 7, "fix": [7, 9, 10], "relax": 7, "match_dist2": 7, "07": [7, 9], "2127925600": 7, "0942": 7, "11": [7, 8, 9, 10, 11], "2020125600": 7, "0895": 7, "2019725600": 7, "0894": 7, "2016325600": 7, "0893": 7, "2015325600": 7, "0892": 7, "2012125600": 7, "0891": 7, "2011725600": 7, "2011525600": 7, "2011325600": 7, "478921600": 7, "0212": 7, "478920000": 7, "longer": 7, "1696": 7, "baselin": [8, 9], "demo": [8, 10, 12], "exampl": 8, "format": [8, 9, 10, 11], "levelnam": [8, 9, 10, 11], "filenam": [8, 9, 10, 11], "lineno": [8, 9, 10, 11], "d": [8, 9, 10, 11], "messag": [8, 9, 10, 11], "betaxbal": [8, 9], "gammaxbal": [8, 9], "511573": [8, 9], "190": [8, 9, 11], "229250": [8, 9], "105": [8, 9, 11], "165097": [8, 9], "505065": [8, 9], "121236": [8, 9], "95": [8, 9, 10, 11], "001474": [8, 9], "071384": [8, 9], "162": [8, 9, 11], "325356": [8, 9], "84": [8, 9, 10, 11], "290576": [8, 9], "44": [8, 9, 11], "423692": [8, 9], "948096": [8, 9], "82": [8, 9, 10, 11], "031381": [8, 9], "695052": [8, 9], "132": [8, 9, 10, 11], "952651": [8, 9], "857540": [8, 9], "10995": [8, 9, 11], "10996": [8, 9, 11], "10997": [8, 9, 11], "10998": [8, 9, 11], "10999": [8, 9, 11], "11000": [8, 9, 11], "matcher_beta": [8, 9], "log_everi": 8, "n_gener": 8, "get_param": [8, 9, 11], "cpu": 8, "candidate_population_s": 8, "1024": 8, "n_keep_best": 8, "256": [8, 9], "n_voting_popul": 8, "n_mutat": 8, "n_iter_no_chang": 8, "1234": 8, "benchmark": 8, "31": [8, 9, 11], "233": [8, 9, 11], "38": [8, 9, 10, 11], "sgdclassifi": [8, 9, 11], "iter": [8, 9, 11], "001": [8, 9, 11], "139": [8, 9, 11], "alpha": [8, 9], "5074398973827774": 8, "class_weight": [8, 9], "early_stop": [8, 9], "fit_intercept": [8, 9, 11], "log_loss": [8, 9], "1500": [8, 9], "penalti": [8, 9, 11], "l2": [8, 9, 11], "140": [8, 9, 10, 11], "0525": [8, 9], "141": [8, 9, 11], "002": [8, 9], "logisticregress": [8, 9, 11], "05835496346821344": 8, "500": [8, 9, 11], "saga": [8, 9, 11], "0291": 8, "004": [8, 9, 11], "sprivit": [8, 10, 11], "venv": [8, 10, 11], "lib": [8, 9, 10, 11], "python3": [8, 9, 10, 11], "site": [8, 9, 10, 11], "packag": [8, 9, 10, 11], "linear_model": [8, 9, 11], "_sag": [8, 9, 11], "350": [8, 9, 11], "convergencewarn": [8, 9, 11], "wa": [8, 9, 11], "reach": [8, 9, 11], "coef_": [8, 9, 11], "did": [8, 9, 11], "converg": [8, 9, 11], "warn": [8, 9, 11], "028": [8, 11], "029": 8, "050": 8, "052": 8, "055": [8, 11], "056": 8, "073": 8, "075": 8, "078": [8, 11], "079": [8, 11], "080": 8, "082": 8, "083": 8, "085": [8, 9], "087": 8, "3905570899706423": 8, "0289": 8, "090": 8, "101": [8, 9, 11], "102": [8, 9, 11], "104": [8, 9, 11], "23": [8, 9, 11], "107": [8, 9, 11], "109": [8, 9, 11], "111": [8, 9, 11], "2699411413616818": 8, "l1": [8, 9, 11], "0288": 8, "113": [8, 9, 11], "115": [8, 9, 11], "133": [8, 9, 10, 11], "135": [8, 9, 11], "35": [8, 9, 11], "144": [8, 9, 10, 11], "172": [8, 9, 11], "5868985298319505": 8, "0249": [8, 9], "195": [8, 9, 10, 11], "197": [8, 9, 11], "199": [8, 9, 11], "201": [8, 9, 11], "42": [8, 9, 11], "203": [8, 9, 11], "43": [8, 9, 11], "213": [8, 9, 11], "234": [8, 9, 11], "235": [8, 9, 11], "257": [8, 9], "48": [8, 9, 10, 11], "279": 8, "49": [8, 9, 11], "281": [8, 9], "282": 8, "025": 8, "71": [8, 9, 11], "512": [8, 11], "511": 8, "logger": 8, "remain": 8, "elaps": 8, "02494": 8, "25118": 8, "7451": 8, "01141": 8, "24623": 8, "exceed": 8, "261578": [8, 9], "396134": [8, 9], "438359": [8, 9], "63": [8, 9, 11], "113091": [8, 9], "165": [8, 9, 10, 11], "563337": [8, 9], "433016": [8, 9], "10001": [8, 9], "232216": [8, 9], "859857": [8, 9], "915385": [8, 9], "10002": [8, 9], "996941": [8, 9], "357415": [8, 9], "606615": [8, 9], "10003": [8, 9], "850195": [8, 9], "983706": [8, 9], "000581": [8, 9], "10004": [8, 9], "382714": 8, "203257": 8, "126127": 8, "4050": 8, "186246": 8, "221816": 8, "97": [8, 9, 10, 11], "047691": 8, "8313": 8, "510049": 8, "960298": 8, "501597": 8, "7166": 8, "061793": 8, "157": [8, 9, 11], "544063": 8, "784043": 8, "569": 8, "174501": 8, "973210": 8, "83": [8, 9, 11], "131287": 8, "2000": [8, 9, 11], "get_best_match": [8, 9, 11], "m_data": [8, 9, 11], "loc": [8, 9, 11], "prematch": [8, 9, 11], "hue_ord": [8, 9, 11], "beta2": 8, "matcher_beta2": 8, "beta_squar": 8, "263": [8, 11], "0603": [8, 9], "0374": 8, "007": [8, 9, 11], "16555309446666": 8, "0357": 8, "044": [8, 11], "048": 8, "02072493419677": 8, "0347": [8, 9], "081": 8, "089": 8, "092": 8, "117": [8, 9, 11], "124": [8, 9, 11], "126": [8, 9, 11], "129": [8, 9, 11], "131": [8, 9, 11], "134": [8, 9, 11], "143": [8, 9, 11], "170": [8, 9, 11], "177": [8, 9, 11], "181": [8, 9, 11], "192": [8, 9, 11], "196": [8, 9, 11], "226": [8, 9, 11], "232": [8, 9, 11], "238": [8, 9, 11], "241": [8, 9, 11], "245": [8, 9, 11], "280": [8, 9], "288": 8, "0311": 8, "322": 8, "323": 8, "325": 8, "328": [8, 9], "331": [8, 9, 10, 11], "333": 8, "381": 8, "385": 8, "387": 8, "423": 8, "458": 8, "460": [8, 11], "462": 8, "031": [8, 9], "03106": 8, "28163": 8, "matcher_gamma": [8, 9], "335": [8, 9], "04": [8, 9], "217": [8, 9, 11], "1083": 8, "0391": 8, "008": [8, 9, 11], "0376": 8, "058": 8, "0337": 8, "091": 8, "095": 8, "098": 8, "179630432958701": 8, "0269": 8, "138": [8, 9, 11], "146": [8, 9, 10, 11], "149": [8, 9, 11], "151": [8, 9, 11], "206": [8, 9, 11], "219": [8, 9, 11], "222": [8, 9, 11], "265": [8, 9, 11], "271": [8, 9, 11], "273": [8, 9], "277": 8, "320": 8, "370": [8, 11], "372": 8, "374": [8, 11], "378": 8, "380": 8, "409": 8, "446": 8, "448": 8, "450": [8, 11], "486": 8, "524": 8, "526": 8, "528": 8, "027": [8, 11], "02688": 8, "23595": 8, "7375": 8, "93": [8, 9, 11], "01151": 8, "24080": 8, "support": 9, "demonstr": [9, 10], "sum_k": 9, "seek": 9, "360": 9, "240": [9, 11], "2841": 9, "418": 9, "421": [9, 11], "428": 9, "437": 9, "527": 9, "611": 9, "2328": 9, "452948000": 9, "2298": 9, "03": 9, "452876000": 9, "2297": 9, "452777000": 9, "452736000": 9, "2296": 9, "452730000": 9, "452596000": 9, "2295": 9, "452537000": 9, "2294": 9, "06": 9, "452040000": 9, "2291": 9, "08": 9, "451825000": 9, "2289": 9, "451808000": 9, "451755000": 9, "22699000": 9, "0104": 9, "22422000": 9, "0124": 9, "22306000": 9, "22291000": 9, "22121000": 9, "0122": 9, "22119000": 9, "0102": 9, "22103000": 9, "0121": 9, "22101000": 9, "22099000": 9, "22088000": 9, "22084000": 9, "22083000": 9, "0101": 9, "22082000": 9, "618": 9, "619": 9, "9933": 9, "194783": 9, "127": [9, 11], "495418": 9, "177329": 9, "9946": 9, "630370": 9, "185": [9, 11], "351623": 9, "381552": 9, "9955": 9, "736759": 9, "612045": 9, "72": [9, 11], "288182": 9, "9981": 9, "006118": 9, "419182": 9, "135407": 9, "9982": 9, "575808": 9, "401060": 9, "848616": 9, "hopefulli": 9, "due": 9, "round": 9, "incur": 9, "cast": 9, "continu": 9, "understood": [9, 10], "accuraci": 9, "origin": 9, "quantiti": 9, "never": 9, "sometim": [9, 10], "help": [9, 10], "add": 9, "beta_x": 9, "matcher_betax": 9, "442": 9, "3751": 9, "533": [9, 11], "540": 9, "guid": 9, "opt": 9, "miniconda3": 9, "env": 9, "542": 9, "settingwithcopywarn": 9, "slice": 9, "row_index": 9, "col_index": 9, "instead": [9, 11], "caveat": 9, "pydata": 9, "org": 9, "doc": 9, "user_guid": 9, "view": 9, "versu": 9, "ix": 9, "543": 9, "1045355473186929": 9, "modified_hub": 9, "1650": 9, "0354658577371722": 9, "0887": 9, "003": 9, "7627616953429366": 9, "0670": 9, "006": [9, 11], "015804928600429955": 9, "0615": 9, "024": 9, "046": [9, 11], "067": 9, "068": [9, 11], "118": [9, 11], "163": [9, 11], "164": [9, 11], "166": [9, 10, 11], "191": [9, 11], "198": [9, 11], "214": [9, 11], "230": [9, 11], "251": 9, "252": 9, "254": 9, "02606111348517078": 9, "255": 9, "302": 9, "319": [9, 11], "330": 9, "344": 9, "351": 9, "352": 9, "354": 9, "355": 9, "356": 9, "577": 9, "achiev": 9, "147332": 9, "579": 9, "2324": 9, "147332000": 9, "147176000": 9, "0601": 9, "09": [9, 10], "147050000": 9, "147002000": 9, "146721000": 9, "145561000": 9, "0596": 9, "145369000": 9, "145229000": 9, "145192000": 9, "0595": 9, "145144000": 9, "145129000": 9, "144996000": 9, "144843000": 9, "0594": 9, "144588000": 9, "144406000": 9, "144195000": 9, "0593": 9, "143827000": 9, "143679000": 9, "0592": 9, "143649000": 9, "0591": 9, "143574000": 9, "143526000": 9, "143245000": 9, "142588000": 9, "0589": 9, "142455000": 9, "141967000": 9, "0588": 9, "141924000": 9, "141829000": 9, "0587": 9, "141681000": 9, "141606000": 9, "141322000": 9, "0585": 9, "141285000": 9, "141229000": 9, "0586": 9, "141161000": 9, "140938000": 9, "0584": 9, "140793000": 9, "140697000": 9, "140642000": 9, "140592000": 9, "140562000": 9, "0583": 9, "140520000": 9, "140167000": 9, "0582": 9, "140140000": 9, "140132000": 9, "139980000": 9, "139917000": 9, "139651000": 9, "139638000": 9, "139610000": 9, "74": [9, 10, 11], "139189000": 9, "0581": 9, "139131000": 9, "0580": 9, "138919000": 9, "138885000": 9, "78": [9, 11], "138879000": 9, "138853000": 9, "0579": 9, "138782000": 9, "138716000": 9, "138683000": 9, "138483000": 9, "137815000": 9, "0576": 9, "137752000": 9, "137486000": 9, "0575": 9, "137401000": 9, "137333000": 9, "137132000": 9, "0574": 9, "137105000": 9, "137099000": 9, "137080000": 9, "137005000": 9, "136985000": 9, "136974000": 9, "136947000": 9, "136838000": 9, "136729000": 9, "0573": 9, "136654000": 9, "136559000": 9, "136503000": 9, "77": [9, 11], "136457000": 9, "136435000": 9, "79": [9, 11], "136386000": 9, "136349000": 9, "81": [9, 10, 11], "136313000": 9, "136286000": 9, "136020000": 9, "135535000": 9, "0570": 9, "135513000": 9, "135473000": 9, "87": [9, 10, 11], "135452000": 9, "135375000": 9, "135312000": 9, "0569": 9, "134988000": 9, "0568": 9, "134977000": 9, "92": [9, 10, 11], "134937000": 9, "134931000": 9, "134909000": 9, "0567": 9, "134887000": 9, "0566": 9, "134614000": 9, "134579000": 9, "134522000": 9, "134400000": 9, "0565": 9, "134234000": 9, "134107000": 9, "0564": 9, "133877000": 9, "103": [9, 11], "133872000": 9, "133834000": 9, "0562": 9, "133706000": 9, "0561": 9, "106": [9, 11], "133469000": 9, "0560": 9, "133214000": 9, "0559": 9, "133090000": 9, "133063000": 9, "110": [9, 11], "133033000": 9, "133028000": 9, "112": [9, 11], "133008000": 9, "0558": 9, "132983000": 9, "114": [9, 11], "132978000": 9, "132841000": 9, "116": [9, 11], "132785000": 9, "132779000": 9, "132600000": 9, "0557": 9, "119": [9, 11], "132480000": 9, "132453000": 9, "121": [9, 11], "132264000": 9, "0556": 9, "122": [9, 11], "132136000": 9, "123": [9, 11], "132122000": 9, "132117000": 9, "132079000": 9, "132025000": 9, "132007000": 9, "128": [9, 11], "131985000": 9, "131979000": 9, "131957000": 9, "0555": 9, "131715000": 9, "131695000": 9, "131689000": 9, "0554": 9, "131687000": 9, "131585000": 9, "131572000": 9, "131526000": 9, "131488000": 9, "131421000": 9, "131418000": 9, "131344000": 9, "131338000": 9, "131174000": 9, "131116000": 9, "145": [9, 10, 11], "131101000": 9, "131083000": 9, "147": [9, 11], "131069000": 9, "131061000": 9, "131055000": 9, "131053000": 9, "131017000": 9, "152": [9, 10, 11], "130827000": 9, "0553": 9, "130822000": 9, "130586000": 9, "130560000": 9, "0552": 9, "156": [9, 10, 11], "130554000": 9, "130462000": 9, "130390000": 9, "130376000": 9, "130053000": 9, "130016000": 9, "0551": 9, "129852000": 9, "129796000": 9, "129752000": 9, "129638000": 9, "0550": 9, "129415000": 9, "129413000": 9, "0549": 9, "129338000": 9, "169": [9, 11], "129216000": 9, "0548": 9, "129055000": 9, "0539": 9, "128661000": 9, "0546": 9, "128657000": 9, "0545": 9, "173": [9, 11], "128319000": 9, "0544": 9, "128266000": 9, "0543": 9, "127794000": 9, "176": [9, 11], "127703000": 9, "0542": 9, "127624000": 9, "178": [9, 11], "127604000": 9, "179": [9, 11], "127576000": 9, "127565000": 9, "0541": 9, "127533000": 9, "182": [9, 11], "127526000": 9, "127520000": 9, "184": [9, 11], "127464000": 9, "127463000": 9, "127450000": 9, "187": [9, 11], "127394000": 9, "127388000": 9, "127253000": 9, "0540": 9, "127241000": 9, "127209000": 9, "127189000": 9, "193": [9, 11], "126998000": 9, "126837000": 9, "126768000": 9, "126686000": 9, "0538": 9, "126679000": 9, "126673000": 9, "126450000": 9, "0536": 9, "126359000": 9, "126346000": 9, "0537": 9, "202": [9, 11], "126318000": 9, "125810000": 9, "0535": 9, "204": [9, 11], "125799000": 9, "205": [9, 11], "125767000": 9, "125760000": 9, "0534": 9, "207": [9, 11], "125507000": 9, "125496000": 9, "0533": 9, "209": [9, 11], "125464000": 9, "210": [9, 11], "125016000": 9, "0532": 9, "124988000": 9, "212": [9, 11], "124956000": 9, "124605000": 9, "0529": 9, "124569000": 9, "0530": 9, "124537000": 9, "216": [9, 11], "124416000": 9, "124370000": 9, "0531": 9, "218": [9, 11], "123956000": 9, "123910000": 9, "220": [9, 11], "123851000": 9, "221": [9, 11], "123830000": 9, "123810000": 9, "223": [9, 11], "123045000": 9, "0527": 9, "122999000": 9, "225": [9, 11], "122997000": 9, "0528": 9, "122958000": 9, "227": [9, 11], "122833000": 9, "228": [9, 11], "122802000": 9, "229": [9, 11], "122708000": 9, "122646000": 9, "231": [9, 11], "122600000": 9, "0526": 9, "122464000": 9, "122463000": 9, "122453000": 9, "122421000": 9, "236": [9, 11], "122333000": 9, "237": [9, 11], "122319000": 9, "122280000": 9, "239": [9, 11], "122118000": 9, "122093000": 9, "121931000": 9, "242": [9, 11], "121912000": 9, "243": [9, 11], "121870000": 9, "244": [9, 11], "121820000": 9, "121793000": 9, "246": [9, 11], "120770000": 9, "0521": 9, "247": [9, 11], "120522000": 9, "9947": 9, "290077": 9, "091011": 9, "511962": 9, "9958": 9, "722321": 9, "350117": 9, "695438": 9, "9983": 9, "616093": 9, "546870": 9, "683367": 9, "774501445415405": 9, "elasticnet": 9, "2142": 9, "058541995189524146": 9, "0472": 9, "0909955270741388": 9, "0448": 9, "005": [9, 11], "15085738749804528": 9, "032": 9, "033": [9, 11], "037": [9, 11], "70303412073022": 9, "0331": 9, "061": 9, "071": [9, 11], "072": 9, "094": 9, "097": 9, "099": 9, "7964686611607528": 9, "0308": 9, "258": 9, "266": 9, "267": [9, 11], "269": [9, 11], "270": 9, "295": [9, 11], "297": [9, 11], "100400": 9, "2110": 9, "115600000": 9, "0349": 9, "115400000": 9, "114600000": 9, "0346": 9, "114400000": 9, "113800000": 9, "0344": 9, "102000000": 9, "0310": 9, "101400000": 9, "100800000": 9, "0306": 9, "100400000": 9, "0305": 9, "97800000": 9, "0300": 9, "97200000": 9, "0298": 9, "97000000": 9, "96600000": 9, "0297": 9, "91000000": 9, "0282": 9, "90800000": 9, "90600000": 9, "0281": 9, "80800000": 9, "80600000": 9, "0248": 9, "80400000": 9, "0247": 9, "19000000": 9, "0070": 9, "18800000": 9, "0069": 9, "18400000": 9, "9932": 9, "514956": 9, "248205": 9, "505187": 9, "9965": 9, "035792": 9, "021437": 9, "495109": 9, "9966": 9, "121009": 9, "339212": 9, "428001": 9, "9984": 9, "366166": 9, "483411": 9, "271539": 9, "download": 10, "yourself": 10, "sphinx": 10, "ipynb": 10, "o": 10, "get_paper_dataset_path": 10, "thin": 10, "addition": 10, "certain": 10, "relev": 10, "data_path": 10, "read_parquet": 10, "unless": 10, "unus": 10, "still": 10, "m_restricted_featur": 10, "tabl": 10, "120054": 10, "12956": 10, "129946": 10, "12044": 10, "100096": 10, "4924": 10, "75185": 10, "10055": 10, "74719": 10, "10021": 10, "2490": 10, "25033": 10, "5045": 10, "49534": 10, "4981": 10, "75337": 10, "2474": 10, "74934": 10, "5010": 10, "25162": 10, "225028": 10, "17535": 10, "24972": 10, "7465": 10, "175673": 10, "12527": 10, "74327": 10, "12473": 10, "125113": 10, "17472": 10, "124887": 10, "7528": 10, "49933": 10, "12562": 10, "200067": 10, "12438": 10, "q25": 10, "median": 10, "q75": 10, "similarli": 10, "404918": 10, "383184": 10, "107753": 10, "171211": 10, "489148": 10, "780034": 10, "662572": 10, "20695": 10, "718093": 10, "743721": 10, "879321": 10, "58718": 10, "707782": 10, "629048": 10, "681391": 10, "352801": 10, "274990": 10, "063519": 10, "704149": 10, "876565": 10, "536365": 10, "274992": 10, "745450": 10, "747313": 10, "291448": 10, "535279": 10, "274993": 10, "736083": 10, "434020": 10, "264209": 10, "595582": 10, "133010": 10, "doe": [10, 11], "266010": 10, "759575": 10, "325267": 10, "512966": 10, "250001": 10, "152645": 10, "515410": 10, "988094": 10, "540606": 10, "250002": 10, "079212": 10, "272208": 10, "090671": 10, "578266": 10, "250003": 10, "494927": 10, "336677": 10, "678251": 10, "559858": 10, "250004": 10, "036012": 10, "843524": 10, "586475": 10, "588368": 10, "built": 10, "quick": 10, "snapshot": 10, "situat": 10, "most": 10, "bc": 10, "palett": 10, "colorblind": 10, "set_ticklabel": 10, "tick": 10, "set_tick": 10, "fixedloc": 10, "plt": 10, "gca": 10, "set_yticklabel": 10, "label": 10, "minor": 10, "unlik": 11, "correct": 11, "tri": 11, "possibli": 11, "807949": 11, "610298": 11, "912924": 11, "810836": 11, "541198": 11, "416988": 11, "876976": 11, "138610": 11, "789013": 11, "398077": 11, "939196": 11, "345017": 11, "890587": 11, "386701": 11, "140295": 11, "662026": 11, "692755": 11, "607476": 11, "130301": 11, "583192": 11, "798145": 11, "035281": 11, "744482": 11, "499644": 11, "044564": 11, "796983": 11, "983973": 11, "243734": 11, "013556": 11, "513956": 11, "undesir": 11, "900": 11, "250": 11, "30826677643062983": 11, "0466": 11, "4178302034480912": 11, "0370": 11, "009": 11, "010": 11, "011": 11, "013": 11, "019": 11, "096856154490844": 11, "0338": 11, "041": 11, "062": 11, "063": 11, "064": 11, "066": 11, "074": 11, "104136295096468": 11, "0333": 11, "084": 11, "086": 11, "692577101426174": 11, "272": 11, "294": 11, "299": 11, "317": 11, "321": 11, "342": 11, "343": 11, "1176816672180467": 11, "0295": 11, "364": 11, "367": 11, "368": 11, "373": 11, "375": 11, "396": 11, "397": 11, "399": 11, "401": 11, "424": 11, "426": 11, "427": 11, "429": 11, "430": 11, "432": 11, "434": 11, "435": 11, "456": 11, "459": 11, "469": 11, "474": 11, "475": 11, "498": 11, "510": 11, "514": 11, "516": 11, "555": 11, "575": 11, "582": 11, "583": 11, "585": 11, "586": 11, "588": 11, "606": 11, "608": 11, "610": 11, "612": 11, "614": 11, "636": 11, "637": 11, "659": 11, "661": 11, "683": 11, "685": 11, "686": 11, "707": 11, "708": 11, "710": 11, "717": 11, "719": 11, "721": 11, "725": 11, "727": 11, "728": 11, "730": 11, "731": 11, "733": 11, "754": 11, "775": 11, "777": 11, "779": 11, "781": 11, "782": 11, "806": 11, "807": 11, "814": 11, "816": 11, "817": 11, "819": 11, "820": 11, "826": 11, "827": 11, "828": 11, "830": 11, "831": 11, "832": 11, "834": 11, "847": 11, "869": 11, "871": 11, "873": 11, "874": 11, "875": 11, "877": 11, "898": 11, "901": 11, "923": 11, "925": 11, "927": 11, "950": 11, "952": 11, "966": 11, "968": 11, "969": 11, "970": 11, "972": 11, "973": 11, "974": 11, "977": 11, "978": 11, "035": 11, "038": 11, "057": 11, "070": 11, "076": 11, "261": 11, "268": 11, "292": 11, "296": 11, "298": 11, "301": 11, "306": 11, "308": 11, "248": 11, "332": 11, "249": 11, "334": 11, "341": 11, "3446": 11, "549356": 11, "579121": 11, "890246": 11, "4926": 11, "557032": 11, "371970": 11, "182597": 11, "3456": 11, "742592": 11, "351062": 11, "254390": 11, "6891": 11, "909882": 11, "862281": 11, "818220": 11, "962": 11, "829914": 11, "725077": 11, "206007": 11, "axisgrid": 11, "facetgrid": 11, "0x7f8e68524a90": 11, "gt": 11, "instal": 12, "instruct": 12, "look": 12, "introduct": 12, "statement": 12, "pip": 12, "docker": 12, "core": 12, "simul": 12, "modul": 12, "page": 12}, "objects": {"pybalance.genetic": [[3, 0, 1, "", "GeneticMatcher"], [3, 2, 1, "", "get_global_defaults"]], "pybalance.genetic.GeneticMatcher": [[3, 1, 1, "", "match"]], "pybalance.lp": [[3, 0, 1, "", "ConstraintSatisfactionMatcher"]], "pybalance.lp.ConstraintSatisfactionMatcher": [[3, 1, 1, "", "match"]], "pybalance.propensity": [[3, 0, 1, "", "PropensityScoreMatcher"], [3, 2, 1, "", "plot_propensity_score_match_distributions"], [3, 2, 1, "", "plot_propensity_score_match_pairs"]], "pybalance.propensity.PropensityScoreMatcher": [[3, 1, 1, "", "match"]], "pybalance.sim": [[3, 2, 1, "", "generate_toy_dataset"], [3, 2, 1, "", "load_paper_dataset"]], "pybalance.utils": [[3, 2, 1, "", "BalanceCalculator"], [3, 0, 1, "", "BaseBalanceCalculator"], [3, 0, 1, "", "BaseMatchingPreprocessor"], [3, 0, 1, "", "BatchedBalanceCaclulator"], [3, 0, 1, "", "BetaBalance"], [3, 0, 1, "", "BetaMaxBalance"], [3, 0, 1, "", "BetaSquaredBalance"], [3, 0, 1, "", "CategoricOneHotEncoder"], [3, 0, 1, "", "ChainPreprocessor"], [3, 0, 1, "", "DecisionTreeEncoder"], [3, 0, 1, "", "GammaBalance"], [3, 0, 1, "", "GammaSquaredBalance"], [3, 0, 1, "", "GammaXTreeBalance"], [3, 0, 1, "", "MatchingData"], [3, 0, 1, "", "MatchingHeaders"], [3, 0, 1, "", "NumericBinsEncoder"], [3, 2, 1, "", "infer_matching_headers"], [3, 2, 1, "", "split_target_pool"]], "pybalance.utils.BaseBalanceCalculator": [[3, 1, 1, "", "per_feature_loss"]], "pybalance.utils.BaseMatchingPreprocessor": [[3, 1, 1, "", "_fit"], [3, 1, 1, "", "_get_feature_names_out"], [3, 1, 1, "", "_get_output_headers"], [3, 1, 1, "", "_transform"], [3, 1, 1, "", "fit"]], "pybalance.utils.MatchingData": [[3, 1, 1, "", "append"], [3, 1, 1, "", "copy"], [3, 3, 1, "", "data"], [3, 1, 1, "", "describe"], [3, 1, 1, "", "describe_categoric"], [3, 1, 1, "", "describe_numeric"], [3, 1, 1, "", "get_population"], [3, 1, 1, "", "head"], [3, 3, 1, "", "populations"], [3, 1, 1, "", "sample"], [3, 1, 1, "", "tail"], [3, 1, 1, "", "to_csv"], [3, 1, 1, "", "to_parquet"]], "pybalance.visualization": [[3, 2, 1, "", "plot_binary_features"], [3, 2, 1, "", "plot_categoric_features"], [3, 2, 1, "", "plot_joint_numeric_categoric_distributions"], [3, 2, 1, "", "plot_joint_numeric_distributions"], [3, 2, 1, "", "plot_numeric_features"], [3, 2, 1, "", "plot_per_feature_loss"]]}, "objtypes": {"0": "py:class", "1": "py:method", "2": "py:function", "3": "py:property"}, "objnames": {"0": ["py", "class", "Python class"], "1": ["py", "method", "Python method"], "2": ["py", "function", "Python function"], "3": ["py", "property", "Python property"]}, "titleterms": {"introduct": 0, "problem": 0, "statement": 0, "instal": 1, "instruct": 1, "from": 1, "pip": 1, "sourc": 1, "us": 1, "docker": 1, "demo": 2, "api": [3, 12], "document": 3, "tabl": [3, 12], "content": 3, "core": 3, "util": [3, 12], "match": [3, 7, 10], "data": [3, 10], "preprocess": 3, "balanc": [3, 6, 7], "calcul": [3, 6], "matcher": [3, 8, 9, 11], "propens": [3, 11], "score": [3, 11], "genet": [3, 6, 8], "constraint": [3, 7, 9], "satisfact": [3, 9], "visual": [3, 10], "simul": 3, "licens": [4, 12], "help": [5, 12], "fit": 6, "between": [6, 8, 9], "pool": [6, 7], "target": 6, "subset": 6, "sever": 6, "simultan": 6, "basic": 6, "optim": [6, 7, 8, 9, 11], "cardin": 7, "size": 7, "without": 7, "beta": [8, 9, 11], "mean": [8, 9, 11], "absolut": [8, 9, 11], "smd": [8, 9, 11], "2": 8, "gamma": [8, 9], "area": [8, 9], "cdf": [8, 9], "With": 9, "cross": 9, "term": 9, "ad": 9, "initi": 10, "matchingdata": 10, "explor": 10, "pybal": 12, "usag": 12, "get": 12, "start": 12, "indic": 12}, "envversion": {"sphinx.domains.c": 3, "sphinx.domains.changeset": 1, "sphinx.domains.citation": 1, "sphinx.domains.cpp": 9, "sphinx.domains.index": 1, "sphinx.domains.javascript": 3, "sphinx.domains.math": 2, "sphinx.domains.python": 4, "sphinx.domains.rst": 2, "sphinx.domains.std": 2, "nbsphinx": 4, "sphinx.ext.intersphinx": 1, "sphinx.ext.viewcode": 1, "sphinx": 58}, "alltitles": {"Introduction": [[0, "introduction"]], "Problem Statement": [[0, "problem-statement"]], "Installation instructions": [[1, "installation-instructions"]], "Install from PIP": [[1, "install-from-pip"]], "Install from source": [[1, "install-from-source"]], "Use with docker": [[1, "use-with-docker"]], "Demos": [[2, "demos"], [2, null]], "API documentation": [[3, "api-documentation"]], "Table of Contents": [[3, "table-of-contents"]], "Core Utilities": [[3, "core-utilities"]], "Matching Data": [[3, "matching-data"], [10, "Matching-Data"]], "Preprocessing": [[3, "preprocessing"]], "Balance Calculators": [[3, "balance-calculators"], [6, "Balance-Calculators"]], "Matchers": [[3, "matchers"]], "Propensity Score Matcher": [[3, "propensity-score-matcher"], [11, "Propensity-Score-Matcher"]], "Genetic Matcher": [[3, "genetic-matcher"], [8, "Genetic-Matcher"]], "Constraint Satisfaction Matcher": [[3, "constraint-satisfaction-matcher"], [9, "Constraint-Satisfaction-Matcher"]], "Visualization": [[3, "visualization"]], "Simulation": [[3, "simulation"]], "License": [[4, "license"]], "Help": [[5, "help"]], "Fit Balance Calculator": [[6, "Fit-Balance-Calculator"]], "Balance between pool and target": [[6, "Balance-between-pool-and-target"]], "Balance between subset of pool and target": [[6, "Balance-between-subset-of-pool-and-target"]], "Balance between several subsets simultaneously": [[6, "Balance-between-several-subsets-simultaneously"]], "Basic Genetic Optimizer": [[6, "Basic-Genetic-Optimizer"]], "Cardinality matching": [[7, "Cardinality-matching"]], "Optimize pool size with balance constraint": [[7, "Optimize-pool-size-with-balance-constraint"]], "Optimize balance with size and balance constraints": [[7, "Optimize-balance-with-size-and-balance-constraints"]], "Optimize balance without balance constraint": [[7, "Optimize-balance-without-balance-constraint"]], "Optimize Beta (Mean Absolute SMD)": [[8, "Optimize-Beta-(Mean-Absolute-SMD)"], [9, "Optimize-Beta-(Mean-Absolute-SMD)"], [11, "Optimize-Beta-(Mean-Absolute-SMD)"]], "Optimize Beta^2": [[8, "Optimize-Beta^2"]], "Optimize Gamma (Area Between CDFs)": [[8, "Optimize-Gamma-(Area-Between-CDFs)"], [9, "Optimize-Gamma-(Area-Between-CDFs)"]], "Optimize Beta With Cross Terms Added": [[9, "Optimize-Beta-With-Cross-Terms-Added"]], "Initializing MatchingData": [[10, "Initializing-MatchingData"]], "Exploring MatchingData": [[10, "Exploring-MatchingData"]], "Visualizing MatchingData": [[10, "Visualizing-MatchingData"]], "PyBalance Utilities": [[12, "pybalance-utilities"]], "Usage": [[12, "usage"]], "Getting Started": [[12, null]], "API": [[12, null]], "License & Help": [[12, null]], "Indices and tables": [[12, "indices-and-tables"]]}, "indexentries": {"balancecalculator() (in module pybalance.utils)": [[3, "pybalance.utils.BalanceCalculator"]], "basebalancecalculator (class in pybalance.utils)": [[3, "pybalance.utils.BaseBalanceCalculator"]], "basematchingpreprocessor (class in pybalance.utils)": [[3, "pybalance.utils.BaseMatchingPreprocessor"]], "batchedbalancecaclulator (class in pybalance.utils)": [[3, "pybalance.utils.BatchedBalanceCaclulator"]], "betabalance (class in pybalance.utils)": [[3, "pybalance.utils.BetaBalance"]], "betamaxbalance (class in pybalance.utils)": [[3, "pybalance.utils.BetaMaxBalance"]], "betasquaredbalance (class in pybalance.utils)": [[3, "pybalance.utils.BetaSquaredBalance"]], "categoriconehotencoder (class in pybalance.utils)": [[3, "pybalance.utils.CategoricOneHotEncoder"]], "chainpreprocessor (class in pybalance.utils)": [[3, "pybalance.utils.ChainPreprocessor"]], "constraintsatisfactionmatcher (class in pybalance.lp)": [[3, "pybalance.lp.ConstraintSatisfactionMatcher"]], "decisiontreeencoder (class in pybalance.utils)": [[3, "pybalance.utils.DecisionTreeEncoder"]], "gammabalance (class in pybalance.utils)": [[3, "pybalance.utils.GammaBalance"]], "gammasquaredbalance (class in pybalance.utils)": [[3, "pybalance.utils.GammaSquaredBalance"]], "gammaxtreebalance (class in pybalance.utils)": [[3, "pybalance.utils.GammaXTreeBalance"]], "geneticmatcher (class in pybalance.genetic)": [[3, "pybalance.genetic.GeneticMatcher"]], "matchingdata (class in pybalance.utils)": [[3, "pybalance.utils.MatchingData"]], "matchingheaders (class in pybalance.utils)": [[3, "pybalance.utils.MatchingHeaders"]], "numericbinsencoder (class in pybalance.utils)": [[3, "pybalance.utils.NumericBinsEncoder"]], "propensityscorematcher (class in pybalance.propensity)": [[3, "pybalance.propensity.PropensityScoreMatcher"]], "_fit() (pybalance.utils.basematchingpreprocessor method)": [[3, "pybalance.utils.BaseMatchingPreprocessor._fit"]], "_get_feature_names_out() (pybalance.utils.basematchingpreprocessor method)": [[3, "pybalance.utils.BaseMatchingPreprocessor._get_feature_names_out"]], "_get_output_headers() (pybalance.utils.basematchingpreprocessor method)": [[3, "pybalance.utils.BaseMatchingPreprocessor._get_output_headers"]], "_transform() (pybalance.utils.basematchingpreprocessor method)": [[3, "pybalance.utils.BaseMatchingPreprocessor._transform"]], "append() (pybalance.utils.matchingdata method)": [[3, "pybalance.utils.MatchingData.append"]], "copy() (pybalance.utils.matchingdata method)": [[3, "pybalance.utils.MatchingData.copy"]], "data (pybalance.utils.matchingdata property)": [[3, "pybalance.utils.MatchingData.data"]], "describe() (pybalance.utils.matchingdata method)": [[3, "pybalance.utils.MatchingData.describe"]], "describe_categoric() (pybalance.utils.matchingdata method)": [[3, "pybalance.utils.MatchingData.describe_categoric"]], "describe_numeric() (pybalance.utils.matchingdata method)": [[3, "pybalance.utils.MatchingData.describe_numeric"]], "fit() (pybalance.utils.basematchingpreprocessor method)": [[3, "pybalance.utils.BaseMatchingPreprocessor.fit"]], "generate_toy_dataset() (in module pybalance.sim)": [[3, "pybalance.sim.generate_toy_dataset"]], "get_global_defaults() (in module pybalance.genetic)": [[3, "pybalance.genetic.get_global_defaults"]], "get_population() (pybalance.utils.matchingdata method)": [[3, "pybalance.utils.MatchingData.get_population"]], "head() (pybalance.utils.matchingdata method)": [[3, "pybalance.utils.MatchingData.head"]], "infer_matching_headers() (in module pybalance.utils)": [[3, "pybalance.utils.infer_matching_headers"]], "load_paper_dataset() (in module pybalance.sim)": [[3, "pybalance.sim.load_paper_dataset"]], "match() (pybalance.genetic.geneticmatcher method)": [[3, "pybalance.genetic.GeneticMatcher.match"]], "match() (pybalance.lp.constraintsatisfactionmatcher method)": [[3, "pybalance.lp.ConstraintSatisfactionMatcher.match"]], "match() (pybalance.propensity.propensityscorematcher method)": [[3, "pybalance.propensity.PropensityScoreMatcher.match"]], "per_feature_loss() (pybalance.utils.basebalancecalculator method)": [[3, "pybalance.utils.BaseBalanceCalculator.per_feature_loss"]], "plot_binary_features() (in module pybalance.visualization)": [[3, "pybalance.visualization.plot_binary_features"]], "plot_categoric_features() (in module pybalance.visualization)": [[3, "pybalance.visualization.plot_categoric_features"]], "plot_joint_numeric_categoric_distributions() (in module pybalance.visualization)": [[3, "pybalance.visualization.plot_joint_numeric_categoric_distributions"]], "plot_joint_numeric_distributions() (in module pybalance.visualization)": [[3, "pybalance.visualization.plot_joint_numeric_distributions"]], "plot_numeric_features() (in module pybalance.visualization)": [[3, "pybalance.visualization.plot_numeric_features"]], "plot_per_feature_loss() (in module pybalance.visualization)": [[3, "pybalance.visualization.plot_per_feature_loss"]], "plot_propensity_score_match_distributions() (in module pybalance.propensity)": [[3, "pybalance.propensity.plot_propensity_score_match_distributions"]], "plot_propensity_score_match_pairs() (in module pybalance.propensity)": [[3, "pybalance.propensity.plot_propensity_score_match_pairs"]], "populations (pybalance.utils.matchingdata property)": [[3, "pybalance.utils.MatchingData.populations"]], "sample() (pybalance.utils.matchingdata method)": [[3, "pybalance.utils.MatchingData.sample"]], "split_target_pool() (in module pybalance.utils)": [[3, "pybalance.utils.split_target_pool"]], "tail() (pybalance.utils.matchingdata method)": [[3, "pybalance.utils.MatchingData.tail"]], "to_csv() (pybalance.utils.matchingdata method)": [[3, "pybalance.utils.MatchingData.to_csv"]], "to_parquet() (pybalance.utils.matchingdata method)": [[3, "pybalance.utils.MatchingData.to_parquet"]]}}) \ No newline at end of file