diff --git a/.claude/rules/notebooks.md b/.claude/rules/notebooks.md index e4217858..67988852 100644 --- a/.claude/rules/notebooks.md +++ b/.claude/rules/notebooks.md @@ -77,7 +77,14 @@ Rules: ## General -- Cover every public parameter of the demonstrated method (grouped sensibly). +- **Cover every public parameter of the demonstrated method (grouped sensibly).** This is a + hard rule, not a nicety: pass every public param by name in a code cell, related params + grouped into a "further parameters" cell. A minimal "call it with one arg" notebook is + rejected. **Enforced in CI** by `tests/unit/api_tests/test_notebook_param_coverage.py` + (name-based, with a committed `notebook_param_coverage_baseline.txt` backlog ratchet): a + new notebook — or any prediction notebook — must have **zero** undemonstrated params, and + the baseline may only shrink, never grow. When you add a param to a public signature, add + it to the notebook in the same change. - Set `aa.options["verbose"] = False` at the top to keep outputs clean. - Commit notebooks **with executed outputs** (tables + images), and re-run before pushing — a stale/unexecuted notebook is a recurring miss. diff --git a/aaanalysis/prediction/_aa_pred_plot.py b/aaanalysis/prediction/_aa_pred_plot.py index 2c4f59ec..27aed5e5 100644 --- a/aaanalysis/prediction/_aa_pred_plot.py +++ b/aaanalysis/prediction/_aa_pred_plot.py @@ -71,10 +71,14 @@ def eval(df_eval: pd.DataFrame, ylabel: str = "Score", ) -> Tuple[Figure, Axes]: """ - Grouped bar plot of the model x metric evaluation table. + Grouped bar plot comparing methods across metrics (hue = model). - Bars are grouped by metric and colored by model; cross-validation bars carry error bars - from ``score_std`` and held-out bars (if present) are drawn hatched. + Each metric is a group on the x-axis and each model is a colored bar (the hue), so the + different **methods** are compared side by side. Cross-validation bars carry ``score_std`` + error bars and held-out bars are hatched; pass ``baseline`` for a chance line. This is the + plot for **method** comparison — to compare **CPP parameter combinations** (parameter + ranges) instead, use the feature-optimization protocol :func:`aaanalysis.pipe.find_features` + and its evaluation-grid heatmap :func:`aaanalysis.pipe.plot_eval`. .. versionadded:: 1.1.0 @@ -88,7 +92,7 @@ def eval(df_eval: pd.DataFrame, figsize : tuple, default=(7, 5) Figure size when ``ax`` is ``None``. dict_color : dict, optional - Mapping ``model -> color``. Defaults to the house categorical palette. + Mapping ``model -> color`` (the bar hue). Defaults to the house categorical palette. baseline : int or float, optional If given, a horizontal reference line is drawn at this score (e.g. ``0.5`` for chance). ylabel : str, default="Score" @@ -101,6 +105,11 @@ def eval(df_eval: pd.DataFrame, ax : matplotlib.axes.Axes The axes with the grouped bar plot. + See Also + -------- + * :func:`aaanalysis.pipe.find_features` and :func:`aaanalysis.pipe.plot_eval` for + comparing CPP parameter combinations (a heatmap over the parameter grid). + Examples -------- .. include:: examples/aapred_plot_eval.rst @@ -114,15 +123,14 @@ def eval(df_eval: pd.DataFrame, if baseline is not None: ut.check_number_val(name="baseline", val=baseline, just_int=False) ut.check_str(name="ylabel", val=ylabel, accept_none=True) - # Resolve layout + # Grouped bar plot: metrics on the x-axis, one hued bar per model metrics = list(dict.fromkeys(df_eval[ut.COL_METRIC].tolist())) models = list(dict.fromkeys(df_eval[ut.COL_MODEL].tolist())) principles = list(dict.fromkeys(df_eval[ut.COL_PRINCIPLE].tolist())) + fig, ax = _new_ax(ax=ax, figsize=figsize) clist = ut.plot_get_clist_(n_colors=max(len(models), 2)) dict_color = dict(dict_color) if dict_color is not None else {} dict_model_color = {m: dict_color.get(m, clist[i % len(clist)]) for i, m in enumerate(models)} - # Draw grouped bars - fig, ax = _new_ax(ax=ax, figsize=figsize) n_groups = len(models) * len(principles) width = 0.8 / max(n_groups, 1) x = np.arange(len(metrics)) diff --git a/examples/prediction/aapred.ipynb b/examples/prediction/aapred.ipynb index 879c5296..654fa722 100644 --- a/examples/prediction/aapred.ipynb +++ b/examples/prediction/aapred.ipynb @@ -14,10 +14,10 @@ "id": "7227725a", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:04:27.251036Z", - "iopub.status.busy": "2026-07-02T12:04:27.250980Z", - "iopub.status.idle": "2026-07-02T12:04:28.788527Z", - "shell.execute_reply": "2026-07-02T12:04:28.788257Z" + "iopub.execute_input": "2026-07-04T13:14:15.692817Z", + "iopub.status.busy": "2026-07-04T13:14:15.692689Z", + "iopub.status.idle": "2026-07-04T13:14:17.134247Z", + "shell.execute_reply": "2026-07-04T13:14:17.133957Z" } }, "outputs": [], @@ -50,10 +50,10 @@ "id": "acd45589", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:04:28.789934Z", - "iopub.status.busy": "2026-07-02T12:04:28.789851Z", - "iopub.status.idle": "2026-07-02T12:04:29.622050Z", - "shell.execute_reply": "2026-07-02T12:04:29.621796Z" + "iopub.execute_input": "2026-07-04T13:14:17.135508Z", + "iopub.status.busy": "2026-07-04T13:14:17.135443Z", + "iopub.status.idle": "2026-07-04T13:14:17.955211Z", + "shell.execute_reply": "2026-07-04T13:14:17.954934Z" } }, "outputs": [ @@ -68,68 +68,68 @@ "data": { "text/html": [ "\n", - "\n", + "
\n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", "
 modelmetricprinciplescorescore_stdmodelmetricprinciplescorescore_std
1RandomForestClassifieraccuracycv0.8092310.0646591RandomForestClassifieraccuracycv0.8092310.064659
2RandomForestClassifierbalanced_accuracycv0.8102560.0654162RandomForestClassifierbalanced_accuracycv0.8102560.065416
3RandomForestClassifierf1cv0.8102560.0592523RandomForestClassifierf1cv0.8102560.059252
4RandomForestClassifierroc_auccv0.8872780.0710594RandomForestClassifierroc_auccv0.8872780.071059
\n" @@ -147,6 +147,287 @@ "df_eval = aapred.eval(X, labels)\n", "aa.display_df(df_eval, n_rows=10, show_shape=True)" ] + }, + { + "cell_type": "markdown", + "id": "a1md0001", + "metadata": {}, + "source": [ + "**Further parameters.** Select the models to evaluate and deploy by registry name with ``models`` (a mix of ``\"svm\"``, ``\"rf\"``, ``\"extra_trees\"``, ``\"log_reg\"`` and/or configured estimators). ``list_metrics`` sets the default metrics used by :meth:`AAPred.eval`, ``df_scales`` the amino acid scales used for internal featurization, and ``df_feat`` binds a feature set for sequence-level prediction:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a1cd0001", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-04T13:14:17.956322Z", + "iopub.status.busy": "2026-07-04T13:14:17.956236Z", + "iopub.status.idle": "2026-07-04T13:14:18.557454Z", + "shell.execute_reply": "2026-07-04T13:14:18.557220Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataFrame shape: (6, 5)\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 modelmetricprinciplescorescore_std
1SVCaccuracycv0.8489230.092943
2SVCf1cv0.8540630.089412
3SVCroc_auccv0.9071990.073961
4RandomForestClassifieraccuracycv0.8092310.064659
5RandomForestClassifierf1cv0.8102560.059252
6RandomForestClassifierroc_auccv0.8872780.071059
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_scales = aa.load_scales() # bundled AAontology scales (used for internal featurization)\n", + "aapred = aa.AAPred(models=[\"svm\", \"rf\"],\n", + " list_metrics=[\"accuracy\", \"f1\", \"roc_auc\"],\n", + " df_feat=df_feat, df_scales=df_scales, random_state=42)\n", + "df_eval = aapred.eval(X, labels)\n", + "aa.display_df(df_eval, n_rows=10, show_shape=True)" + ] + }, + { + "cell_type": "markdown", + "id": "a1md0002", + "metadata": {}, + "source": [ + "Alternatively, the legacy ``list_model_classes`` / ``list_model_kwargs`` pair selects model classes together with their keyword arguments (mutually exclusive with ``models``):" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a1cd0002", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-04T13:14:18.558562Z", + "iopub.status.busy": "2026-07-04T13:14:18.558473Z", + "iopub.status.idle": "2026-07-04T13:14:18.956885Z", + "shell.execute_reply": "2026-07-04T13:14:18.956649Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataFrame shape: (4, 5)\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 modelmetricprinciplescorescore_std
1RandomForestClassifieraccuracycv0.8169230.055368
2RandomForestClassifierbalanced_accuracycv0.8179490.056082
3RandomForestClassifierf1cv0.8183450.051525
4RandomForestClassifierroc_auccv0.8917650.064760
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.ensemble import RandomForestClassifier\n", + "aapred = aa.AAPred(list_model_classes=[RandomForestClassifier],\n", + " list_model_kwargs=[{\"n_estimators\": 50}], random_state=42)\n", + "df_eval = aapred.eval(X, labels)\n", + "aa.display_df(df_eval, n_rows=10, show_shape=True)" + ] } ], "metadata": { diff --git a/examples/prediction/aapred_fit.ipynb b/examples/prediction/aapred_fit.ipynb index a2169e9f..21dc0276 100644 --- a/examples/prediction/aapred_fit.ipynb +++ b/examples/prediction/aapred_fit.ipynb @@ -14,10 +14,10 @@ "id": "9a3b2221", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:04:35.878829Z", - "iopub.status.busy": "2026-07-02T12:04:35.878741Z", - "iopub.status.idle": "2026-07-02T12:04:37.401413Z", - "shell.execute_reply": "2026-07-02T12:04:37.401110Z" + "iopub.execute_input": "2026-07-04T13:09:13.955770Z", + "iopub.status.busy": "2026-07-04T13:09:13.955617Z", + "iopub.status.idle": "2026-07-04T13:09:15.361031Z", + "shell.execute_reply": "2026-07-04T13:09:15.360738Z" } }, "outputs": [], @@ -50,10 +50,10 @@ "id": "f7672511", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:04:37.402828Z", - "iopub.status.busy": "2026-07-02T12:04:37.402743Z", - "iopub.status.idle": "2026-07-02T12:04:37.444450Z", - "shell.execute_reply": "2026-07-02T12:04:37.444216Z" + "iopub.execute_input": "2026-07-04T13:09:15.362317Z", + "iopub.status.busy": "2026-07-04T13:09:15.362254Z", + "iopub.status.idle": "2026-07-04T13:09:15.402484Z", + "shell.execute_reply": "2026-07-04T13:09:15.402274Z" } }, "outputs": [ @@ -85,10 +85,10 @@ "id": "0c93d6ef", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:04:37.445548Z", - "iopub.status.busy": "2026-07-02T12:04:37.445481Z", - "iopub.status.idle": "2026-07-02T12:04:37.448901Z", - "shell.execute_reply": "2026-07-02T12:04:37.448697Z" + "iopub.execute_input": "2026-07-04T13:09:15.403635Z", + "iopub.status.busy": "2026-07-04T13:09:15.403573Z", + "iopub.status.idle": "2026-07-04T13:09:15.406814Z", + "shell.execute_reply": "2026-07-04T13:09:15.406619Z" } }, "outputs": [ @@ -123,6 +123,80 @@ "source": [ "The positive class whose probability :meth:`AAPred.predict_proba` returns is set by ``label_pos`` (default=1)." ] + }, + { + "cell_type": "markdown", + "id": "f1md0001", + "metadata": {}, + "source": [ + "**Further parameters.** ``label_pos`` sets which class is treated as positive. Hyperparameters can be tuned per model by ``GridSearchCV``: enable ``optimize_hyperparams``, optionally passing an explicit ``param_grids`` (a single dict is applied to every model) and the number of stratified folds ``n_cv``:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f1cd0001", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-04T13:09:15.407865Z", + "iopub.status.busy": "2026-07-04T13:09:15.407807Z", + "iopub.status.idle": "2026-07-04T13:09:15.426862Z", + "shell.execute_reply": "2026-07-04T13:09:15.426665Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of fitted models: 1\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "aapred = aa.AAPred(models=[\"svm\"], random_state=42)\n", + "aapred.fit(X, labels, label_pos=1, optimize_hyperparams=True,\n", + " param_grids={\"C\": [0.1, 1.0, 10.0]}, n_cv=5)\n", + "print(\"Number of fitted models:\", len(aapred.list_models_))" + ] } ], "metadata": { diff --git a/examples/prediction/aapred_plot_clustermap.ipynb b/examples/prediction/aapred_plot_clustermap.ipynb index 8dfbe9ae..b7a859a9 100644 --- a/examples/prediction/aapred_plot_clustermap.ipynb +++ b/examples/prediction/aapred_plot_clustermap.ipynb @@ -14,10 +14,10 @@ "id": "ff10f250", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:04:42.742209Z", - "iopub.status.busy": "2026-07-02T12:04:42.742139Z", - "iopub.status.idle": "2026-07-02T12:04:44.207005Z", - "shell.execute_reply": "2026-07-02T12:04:44.206737Z" + "iopub.execute_input": "2026-07-04T13:10:49.112042Z", + "iopub.status.busy": "2026-07-04T13:10:49.111927Z", + "iopub.status.idle": "2026-07-04T13:10:50.454077Z", + "shell.execute_reply": "2026-07-04T13:10:50.453776Z" } }, "outputs": [], @@ -49,10 +49,10 @@ "id": "f8cb4fd4", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:04:44.208361Z", - "iopub.status.busy": "2026-07-02T12:04:44.208248Z", - "iopub.status.idle": "2026-07-02T12:04:44.399545Z", - "shell.execute_reply": "2026-07-02T12:04:44.399313Z" + "iopub.execute_input": "2026-07-04T13:10:50.455424Z", + "iopub.status.busy": "2026-07-04T13:10:50.455307Z", + "iopub.status.idle": "2026-07-04T13:10:50.638836Z", + "shell.execute_reply": "2026-07-04T13:10:50.638562Z" } }, "outputs": [ @@ -73,6 +73,47 @@ "aa.AAPredPlot().clustermap(data=data, names=names, labels=labels)\n", "plt.show()" ] + }, + { + "cell_type": "markdown", + "id": "pcm1md01", + "metadata": {}, + "source": [ + "**Further parameters.** ``colors`` maps each class to a sidebar color, ``cmap`` sets the heatmap colormap, ``figsize`` sizes the figure, and ``cbar_label`` / ``title`` label the colorbar and figure:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "pcm1cd01", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-04T13:10:50.640081Z", + "iopub.status.busy": "2026-07-04T13:10:50.640001Z", + "iopub.status.idle": "2026-07-04T13:10:50.763316Z", + "shell.execute_reply": "2026-07-04T13:10:50.763055Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2IAAAMRCAYAAACOGQX9AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlcelbwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAfYFJREFUeJzt3QmcjeUb//FrzGDM2Pd9C5Fk35JkKftSElKopERZUpIK/dK0EEUSipKQNqUslURCsm9Rtuz7zphh5v+67v//nP8Z5sx6zn2emfm8X6/nNTPnPOc5z5xzjPM9131fd1BsbGyswDHuvPNOWb58uVSoUEEmTJggtWrVkhw5cnjdPygoSIKDg62eIwAAAIDUCSKIOUvWrFklKipKVq9eLXXq1An06QAAAADwA4KYg0RHR0uWLFkkJCTEhDGtdgEAAABIfzIF+gTw/2XOnFkKFiwoV69elZMnT/LQAAAAAOkUQcxh2rVrZ77OmDEj0KcCAAAAwE8YmugwBw4ckBo1asjly5fl/fffl86dO5t5YwAAAADSD4KYg1y5ckWeeOIJ2blzp6xcudI9XLFo0aISGhoa723Cw8Nl7dq1ls8UAAAAQGoQxBzkwoULCbaq9xbE9HYAAAAA0o6QQJ8A/j+teiV3bphWzAAAAACkLVTEvPj8889NC/mePXvafUYAAAAApHsEsXjo/KyGDRvKHXfcIUuXLrX/rAAAAABI12hff53NmzdL27Zt5dq1axJI58+fl7ffflvuvPNOKVy4sGTPnt007WjcuLGMGTNGLl26FNDzAwAAAJByVMQ8zJ07Vx599FF384tGjRoFpCK2ceNGEwb379/vdZ9bbrlF5s2bJ+XKlbN6bgAAAABSj2YdInLw4EHp3bu3/Pjjj5IpUya577775Ouvv5ZAOHHihLRq1UoOHTokOXPmlB49eki9evXM93rdsmXLzPy1bdu2SceOHeXPP/9knTEAAAAgjSGIiciaNWtMCKtYsaJMmTJFIiMjAxbERo8ebUJYyZIlTegqVapUnOu1eUj//v2lSZMmsmnTJtNlsVevXgE5VwAAAAApwxwxESlSpIhMnjzZzA/TBh2B5AqA48ePvyGEuVStWlVGjRplvp89e7bV8wMAAACQelTERKRu3bpmC7SYmBjZtWuXGR7ZokWLBPdt3bq1+bpz505LZwcAAADAV9JNELty5YrZvMmaNavj51JpENMtJCQk0YWadfFndfnyZUtnBwAAAMB6EHsyqLQ4WeHhPWXkyJFerx8+fLiMGDFCnEwDmLao1zliq1evNk06vPn999/NV51Lhvjt3btXypQpk+KH54MPPpAnn3zSMQ9vv3795P333zffnz59WnLnzi3pWWxsrKkQX98ZVP8du/6t79mzR0qXdvbfJn8J9OOQ0P075bWalMfI2+vMqZzy2CbECY9poP99AIBP54hlyRTk6G3o0KFy9uxZr5tenxa4hiQOHjzYNA2Jj/7n++KLL5rvmzdvbvX8ABu0EY2uoTdu3DgecPA6S0P4twsAfqiIadhxsrQw9DApnn/+edOefsWKFVK7dm0ZNGiQmb+WK1cuOXXqlCxfvtws9KzVHr3smWeeCfQpAz4VFRUlNWvWlKtXr5rGNIA/8DrjMQWAQEs3FbH04uabb5ZPP/3UzBHbsmWLWWC6cuXKUrx4cbntttukb9++JoRlz57dLEBduHDhQJ9ymqCVQx0uk5zNScMSMxKdJ6khLKEhR67nKCMPNwr04xDo+0/tOSb2OkPyOekxTQuvTwBIchALDnL2lp506tRJ1q5dKw888IBZyNlT3rx5zSLP69atk7vvvjtg5wgAAADAwtDEzEHpLO04XJUqVWTOnDly7do1OXr0qJw/f96EMq2ABfFcAAAAAGkaQxMdLjg42HRS1CGLuvA0ISwwhg0bZh573Zo1a+Z1v169ern382wQ89JLL5nLXENkdL7fs88+a7o66txGHXr64IMPyp9//pnqeS8ff/yxdOzY0dxXeHi4ZMuWzRy/ffv2MnPmTDN8KD6uc6xYsaL5ecOGDWZorJ6jHkOrsdpA48MPP0x0+FFKz0OXZdD9XLQ7nOvxdHUK1SFHrst0mK43CxculM6dO5uF0fW42l2uRo0aptHN4cOHvd7Ol49DUugxpk+fbhr1FCxY0AxLzpMnjxmKrB3yNm7cGO/tEnocrv8dLl26JBEREXLLLbdIWFiY6WbXv39/OXHiRJzb6fxUnZOaI0cOMwe1cePG8t133yX7/v39WtVmRnq/t956q/n5k08+kZtuuskcQx+30aNHJ3iOib3O9IMw/V6Pd+HChQR/Dx0urvtmyZJFTp48mezHQef96igHfa70udEP3GrVqiWvvfaanDlzJlnH0teL6/dI6Laef6fiawqVktdkUv7tevrjjz+kZ8+eUrZsWXM7/fepc0P1OdO/j96k9rn39b9xffzeffdd0+VY/93o7fX/a53ffeTIEVm6dKn7PHS6AQDEEZtEY7KXd/TmSz/99FOsPjSNGjXy6XFh1549e8zzqFvz5s1TdawrV67EVq1a1X28mTNn3rDPzz//7L7+tttuM7dxGTZsmLm8VKlSsSdPnoytUqWKe1/PLSgoKHbMmDHxnkPfvn3d+50+ffqG67ds2RJbpkyZeI/ruenr+sKFCzfc3nWON998c+w777wTGxwc7PUYDRo0iPcYqT2PrFmzet1/+fLlZp/hw4e7L9Pn+Hr6+LZs2TLB+w4LC4udMWNGvOfvq8chKc6ePRt7++23J/pYjRgx4obbJvQ4eP4Op06diq1du3a8x61YsaK5PiYmJvaJJ57wev/6OCTn/v39Wn322WfN9ZUrV46dN2/eDbfT+0/oHBN7nY0dO9b987Rp07w+f9HR0bEFChQw+7Vv3z42OS5evBj78MMPJ/j7FytWLHbTpk1JfmwTe9xdHnvsMfd+ly9f9slrMin/dlVUVFRsr169Ejx23rx5Y5csWRLvuaf2ufflv/GjR4/GVqtWzettc+bMGfvyyy+7f968ebPX5wRAxkRFLB76CZ2uO6af1vmLfkKtn0p7doVzXZacja5yduin3dpERb8qrWadO3cuznP3+OOPx7tvfJ+gb968Od7rdGK5Hnvq1KnJOj9doqFp06ZmvZzE/Pbbb6Y64s3u3bvNp7k6LNYb7er5xhtv+PU8UkIXOG/Tpo0sWLAgwf30+Xr44YdlxowZfnkckkqfa60MqCZNmphj6XOvbfv19eSaI6qf7mvlJCW0+rFmzZp4r/v777/lf//7n/lEXz/99+aFF16QY8eOiS/48jVy5coVU6G5Xvfu3VN1jg899JD7329Cr5FffvlFjh8/br7X11NyaLU2oWOrgwcPSsuWLZNdGUsNf78m9blJ7O+bVsS0Guftdeur5z41/8a1oquPj1bTvNH/I/TfFwD4oFlHkKM3Xwcx/U/Gn0FMh9zogpe6xXdZcjYkbtGiRe7hIUnZ4uuYqMNeXIuC65ATHd7iosPdXG8sdR9vAVnfWM2ePVsKFSokH330kRkapqFgyZIlUr9+/ThvfJPz5kvfJOlcQqVDavT31TeI+mZBL1+2bJncf//97v112Jc30dHR5qsO99GhanocPUd9Q9KgQQP3fjp0ydfnocN8NEx5hlZX57M77rgj0cfhnXfekZUrV7qH9Q4cONCEXj2uvrn75ptvpFq1au799XnW59LXj0NS6BtJ1xtxfeOvb+qHDBkijz32mBk2OHnyZPNG1LUsh4b75NK/D19//bUZKvXtt9+a15T+vu+9954Zbqb0dahDb3Xo82effWaG1+lwPH2sChQoYPbR5y+xcBuI1+q///4r+/fvN6+TQ4cOmedMf8c6deokeA6Jvc7y588v7dq1M9fp0DK9j/jo60LpsDr9ACCp9G/A/Pnzzff69+app54yb+j1nPR1qsNqdYio62+GBmUbUvOaTMq/Xf29dXPp1q2bGY6tt9OA/uOPP5plW5S+HjTcehuemtLn3lf/xseOHStbt2413+uQ0jfffFP+++8/8xhu27bNLC3DVAIAPlxHLKl7Iil0PP2sWbPcb4Y8L0sOz9vDzjpvOmdm1apVZg6Efqqtb1zHjx9vrtcwpft4o/MNNIStXr3azF1y0bk4+um/fvqtb370mLo8gavKlpivvvrK/SHC4sWL46ypp3M8dNM3Q/rmTt9I6ZwJfcPgbe09PTc9x3z58rkvu/32280bRK3E6hvmAwcOmDdPOpfIX+eRHPqptgYxpW+A9PG799573dfrfXTo0ME8xvqm+eeffzZvuvS5GzVqlE8fh6TQEK6/u/J22woVKnhd2D0p9PWmc0w1nOocH9d9Pf3006bzqr7B1E/t9Y2kBiD9nVz0sdImQa4Kg77x9QVfv0Z0zuaECRPcPyf3efBG5wx9+eWXJghoQPWc86n0edFwq7TDbXJewxpoXLQ6pPfl+f+ALrdx1113mXlQ+rh/8cUXZpSGv/n7NalrYLpolUlDnufvrf82tcqkFVMNQzt27JDvv//ezBn013Ofkn/jGi71wwzX/8H6YYLnB0WVKlUy4Vk/9PF8bgEg3S7onNaEhIRIly5dEr0MzqJVFv0UWP+D1TfxXbt2ldOnT5s3a/pmVieO6z4J0TcgniHMRf9D1zcV+p+40jcgSQ1imzZtSnQfDSfVq1d3D/fR8/f25lE//fZ8Y+Ki69fpsgn6xlRp5cTzzY+vzyM5/vrrL/ck//vuuy9OCPOk96VvhMuXL2/Cm1Z6vAWxlD4OSaGBXBsMXLx40YR6HSal56xv6LSJgK8+TddP5l0hzFOjRo3cn/RrkPAMYS6eVYHEmlYkla9fI/76m6lhSBuH6JtwrRJdH8R++OEH9/Dk5AxL1Df0riF92pzC2xt1/X3/+ecfscmfr0kNNBr+la6N6e0DK/299QMVV0VQH2dvQcwXz31K/o3r76FVOKWNVrxV6x955BHzf4J+yAYA8SGIOYgOk9BP0XRugr55Soi++X/11VfNG0nXJ3NI+E2VfsLpC/oGXsOUPkeeQ5b00169LiEa0jQkeKNvdrRSoG+AdP5Oaj/d1uPomznt1qVVPNfcD5XQvAjPN+DX81xEPCldA1NzHsnh2ZFMqzkJ0e5oGqZ1vb6EOpn58nG4nn7wokPSXFUCDYSu4X96bK0O6PA4/ZqaoKqf7nt70+2iXfrio0PuXLQK4C+peY1omPGHTJkymTfZGtK3b99ugr7n4+QavaCvpYReJ9fT39P1etF5UE7iz9ekK4QpvX1CoU4fZ52LpkFX/43687lPyb9xz3lhrVu3TvD4GiIJYgC8YY6Yg+iQkOeee87MN0pKaNO5FjpkBfbpJHHXXAalb+r79OmT6O30ze/1i3Rfr0SJEuart7lLCb1+tOGCDtfRCojO79FPlXWuhwZHneui8y6SwjU3KD6eb8Die3Puy/NIDs/W4a5lAhLi2kf/LekQPF89Dq722t42vd7l9ddfl969e9/wplSf+2nTpplqhM7d0jfG3ubKJEaH+sXH8z69VfM0jPiDL18jOp/LX7Ra5XqcPOdDaUDQSo3Sc05Opciz6Ynr37qT+Os16blUgraYT+jfiH5g5ao2upqh+Ou5T8m/cdccR1WyZMkEj69BHQC8oSIWQDqxVzcX10Rn/c8tvnVXXPR615sAf71RQsK0WuXZ+VC/12FUiU0UT2zYonK9ufHWdTE+Oo9GP2X2rKLpp7k63Ewnouv6UXpu+mZS30z5a+6hr88jOZIbVDz39/bvyN9zMLUCoYFEh0fp8Dedf6gT/a+vfuswLn0D7znHJql0qJmT+Po1onOL/EWr0zqEU4OhNpnQIXP6nGkjE9c8KQ1iyeFqEBFInk01bL0mU7rmng6T9Odzn5J/454fEiT2d8eflWQAGSiIBYfwht/XdN6DTkq+/pNf/U+yYcOGSTqGdh2DXfqGQueEeE5Y16FTOoxp/fr1Cb450Dcu+kYsof/8XeFcP3VOCv2PXrvM6Rtbnac2ZswY83N8nxZPmjRJ/CXQ5+E5z0Pf7CfWZVGHiCl9vvR8A0nDh7Zp103nJGnjDB2ep8NpXfOEtAKurbaT+rpwokC/RlJCOwZqENPKjH7VKp6rW6JW8bR5RXJ4ztfT59qXPKtYCVUUE6oy+es1qYskez63TzzxhKRVnq9X/XvtbWiv8tZxEwCSNzQxS7Cjt7RI5wPpUET9xNq1uXhedv2WI0cO8x9f27ZtTQtd2KXrwrjmLWjXRNeEcX1zqW3AExuSldB8AZ0fs2/fPne7/KTQ7mKu89E1gLQle3xvbPVNsHYH8/XcLKech+fjpRWLxNq6uyqa+kbal22mddiVq213fJtenxBtEPHggw+auZ/aNc7VtVA/AEhozaK0INCvkZTo2LGje+imLgWg7eS142ZK1g5zBRzX6027RiZEQ45ruJ7eb2K0mhXfUEBP+jrSlvHJ4YvXpHaAdPHVUgiB4rkERmK/S1r/XQE4JohlcvSWVr322mumG5NurjlBGrZcl8W36dh57dikQ0bS8qfjaZEOP9Q5FK7hVBMnTjSb63nQT4gTGlaqtGWzVkOvp59ga1txl4SaenjyHOLlaj0d3xtbDf1aKfK8P1/y1Xl4hqLkDGeqUaOGuyqmQcxbGNNz00/jXUOKtDNaIOiQLtebbG1/HR+9zrPDZnKGqzqRU16ryXmdZcuWzXRHVfPmzTNd8PS1o1Vt/SAmubQipq9VpYHI25IlWklxdezTdeCKFSuW6LE95/p5mz+sf7+0c6M/XpMJPaY67FQ31+PoWsYgPhpQdRi3Hi+pfwdt0kqoa+6lDqH1Fmy18623xxEAkjU0MYi5SH6n/6HpuHxftPKG7+mQUf0k2PUGQ9f/cQ230TkV2k1M36DpQuAbN270OjdHu4fpemNaidH/zPXNhgZr7RLnmgSu3ep0GJRnqPP8Xltpu4ZAeq7vpNUWXTNKj61Dv3T4pB5bP7W+/hN1XZDac7iQZ5c6XZRaK6/x8dxPO3e63vz56jw851ToWmD6mHo+lq4Fm6+/f6VdK7Vphx5DKxn6ybV+Eq+Ppw4J1fvW4VWuoVlaQdCW97rws68eh6TSeTYu+trRN3c6J0nbZutrQhuIaPXB9SZPz1XXtXItBJzQ45CU38Ez6Ogb/vi603kOv9VKrufjlND9e3utuqq9Sqv5+vrX1vnaxEafB62YadVFh8F58lXrfE+ew4P1/vSDMM8uedcPT9ThdPoa1mYiSue5pbRZhH7gon8nXFU1/XehjUG0sYO+fnWB95dfftn9Oo1vgfnEqsL6IZ8+7vo3S8OfzvPSx1aDg/6bjO/DIO3wpx8U6b+fTp06mbXLdOSFhkCdR6nhUOfK6XBFV0jVZQaS+phqFVS7Mip93vUDEX1stZ29/jvX4cJz5syJ0whEF2x2Gv099ffQf1v6IYFOMRg5cqT7tazDFTWw62uFOWIAEhSbREuq1XH0Blxvz549+o4+xVuhQoXiHO+ZZ55xX/fYY4/dcH/du3d3X//UU0/FuW7YsGHu66pWrZrg/QYHB8f++uuvNxy/b9++7n1Onz7tvvzs2bOxefLkSfbv9/PPP3s9x/3793t9QXnup4+xr89D5cuXL84+RYsWjd2wYYO5bvjw4fHev4qMjIytVatWku976tSpCf5+KXkckuPhhx9O8rkOHTo0zm0TehyS8jssWLDAvc+MGTPi3UdfZ659+vfvn+T79/Za7dOnj09eI88++6z7uuPHj3t9fBM6x8ReZ9e77bbb4uw7d+7c2JSKiYmJbd68eZJ+9xo1asRGRUUl+tiqCxcuxBYsWDDB44WFhcVGRES4f758+bLPXpOJPabXrl2LbdasWZKPr+dyPV889774N66PW6VKlZL1Ot6yZYvX+wKQMTFHzKH0UzStjugnhFppcG07d+4084j0E29djFUbRMD/9BPq8ePHm+91WE58c/N0DbiiRYua7z/44AP3PJLraSXN2wR/bW2vHTHvuuuuJJ+b3ubjjz9OdNiaNhnQRVpdfD3fyJfnodUGT66KYWK0mqxDgRIbbqhVJ+0Ip5/GB5IOa9VP0xOj56kVjrROnx8nvFZT8jrzXHhZq39t2rRJ8f1qxVOrm1ptSog2gdC/B0nt7KeVY614aaUqPnq5VpziW7zbV6/JhB5Trap9++23plqdGP2/Tf9WOpVWG/VvjQ4b9Ub/zrsqn4rRLgCul/QgljnY0Vt6okNg9A29DunQMfU63Mq16R/9KlWqmEUoH3nkkQTH2cM3dE6ePtYajvUNlAbg+IZ66fC3KVOmmO91X33j5loLx5M+rzoEq2rVquZ51lCg3+tQJO1GpotPJ5cuYKwLzuqbFw2K+kZXhx/pGwE9dx1W9tNPP5lW265hYq4lEHzJV+ehbwZ16I8OidI3oTr3K6nzhHSYo84x0TmU2pFPGw3oeegwMm2LrnNk9HFObttxf9DnXh8PHe6lw8J0XSl9s6aPmf7b18dMh3jpG9L0slSFU16ryX2d6XBiFx22l9rW6frc62tUh5rq61TPQR8LDXna8VM/zNG/E96GS3qjfz90AWpd61BfQ/p60r8zOs9N57gmFiBT+5pM7DHVsKghVD/c0mGZOhxXA6Lehw7N7Natm/z666/m76zT50TqY6MfEuhQbP3bov8H6OtCh1rqcF3touu5cLo+tgDgKUjLYpIEfzRydpv023+LO6cgrdL/lBP7lNRF37zrGjdaiYGz6TyoUaNGme91noWGA51vQ9dLZCRp+TWvDURcHS91Dpx+GAYkRgOwhlqd46lzLpOyliSAjIOhiQ6jk6mVNhjQT0N13Sn9RFErMVu3bjWfJLuCmg4NIYQBgH9pYwttvqBcIxKQsWkVT/9fbty4cYJdQl3dW/X/dEIYgJQv6Jw5fQyLcTrt6KY0YN1+++3me+2m9uOPP5ouZ61atTJr2egwiMGDB5tQVrp06QCfNYDk0E6Cnh0JMwr9YMmz86KTaVdLHYJ88eJFM9/T1cFQh5ql5HfQIWuuboNI+3SqgK5FqN1ttTOlDgXVqQM6xPLw4cNmOK12UnQt05CUeXEAMp6kB7E0umhyWqLttbVl9fXzEXS8uQYxbT+sQUyHOGiLYV1IWNet0g1A2qEhLK0O0csodD6UNkvypE0u9A12SuYupZUAiqR5/PHH5ZlnnjHfa+Mf3bypVKmSad0PACkOYpkIYn7nWsBSg5Zn1yudzKw83xS4gpq3znwAgJTTZhOef3O1oqUdCZ3eQAJ26PpmOl1A15BMiI5e0cW1vXWyBJCxJXm8YabgIEdv6YF2oNJhL1oZ0yE8LtpJ6voFc10du3TBTACAb91zzz1mIWQdnqjt3HUImudIBWRs+v+1djhevny5GZqo1VINW7rph6e6SLs26dDGLtodFABSOUeMoYk2NGzYUObOnSuTJ082nfZcwxqUNuq4fPmy+UPvWlenQIECVs4LqaPr7aSHdaCAjEL//rr+BgPe6FIDugGAfytiWYIdvaWn4Q7qlVdeMZ+yqZIlS0rNmjXN5HHtlKhdmAYMGOCePwYAAAAg3S7oHOLoLb3QdcG005LS7oguL7zwgvk6a9Ysue+++8yCnUqbdgAAAABIp0EsKDiTo7f0RKtha9askT59+rgvu//++2XixInuoYgFCxaU6dOnS+3atQN4pgAAAAD82zUxHVWd0gIdiqibJw1mTz75pJw5c0Zy585tOiwCAAAASNft6zP790yQJBq+tJMXAAAAgAzRNZGKGAAgZYYOHWoWss6odEmSjLqosy63EhEREejTAADHYWhigGgbem1Vn1phYWGybNkyn5wTAPiLhrCxY8fyAGdAGTWAAoDPglh6a4gRaNeuXZO1a9em+jjh4eE+OR8AAAAAThyamIWhib4eqvHBBx+k+jiZMzN3DwAAAEhrGJoYqAc+JMR0QAQAAACQ8RDEAAAAAMCxQSw42L9ngjiuXr0qc+fOlfnz58vOnTslOjpaNmzYYJp8vPzyy9K/f38pUaIEjxoAAACQvtcRY46YLbt27ZIOHTrIli1bbmjKoU0+xowZIx9++KH88MMPcuedd1o7LwAAAAC+wdBEhzlz5ozcfffdsmfPHlPxatOmTZymHlmyZJEqVarI5s2bpVWrViaslS5dOqDnDAAAACB5ktyTPlPmEEdv6cXbb79tQlj9+vVl69at8tZbb8W5XoPYmjVrpG7dunLx4kV59913A3auAAAAAPy9jlhIlhTeBZJD54Wp0aNHS44cOeTChQs37JM1a1YZMWKEtGzZUpYsWcIDDAAAAKQxSS8lZWJBZ3/T+V86Pyw4OFjq1auX4L7Vq1c3Xw8cOOD38wIAAAAQqIpYZipiNsTGxpqvUVFRZtHnhLoqKhZ0BgAAANL10MTM/j0TmEqYNuj477//zDywhg0ben1UFi9ebL6WLVuWRw4AAABIY5I+3lDniDl5Syfat29vvg4dOtSsGRYfXVds2LBh5vvWrVtbPT8AAAAANitizBGzYsiQITJz5kxZsWKFmSfWtWtXc3lMTIx8//33snz5cpkwYYIJaYULF5annnrKzokBAAAACECzjnRUdXKyYsWKybx58+Tee++VTZs2mU1p8GrXrp17v4IFC5r98uTJE8CzBQAAAODnZh3MEbPljjvuMAs1jxs3Tr799lvZsWOHaeIRFBQk5cqVkw4dOsizzz4rhQoVsnZOAAAAAHyHdcQcZtKkSVKpUiW58847JSIiwmza1l7XEwsPD5eQkPSzeHUg6Ny7yMhIcYJjx47JwIEDxSm0S6e+3gAAAOB/dE10mJdeeklOnjwpK1eudK8lpt0Uc+XKFehTSxc0hI0dOzbQp+FITgqFAJz9QVJa/tApqfhwCoCDFnQO9uuJQCQ6OtqEMA1ederU4SEBALjxQZJdaTE8AkhbmCPmILo4s64Ltnv3bvn333+lQoUKgT4lAAAAAH7AOmIOM3XqVMmRI4d07NhRli5daqpkAAAAANIX5og5yJUrV2TOnDlSt25d+fnnn6Vx48ZmjHqRIkUkLCws3tvo5X/++af1cwUAAABgY45YUNKLZ0gZrX59+OGHN8wJ2LNnj9fbaCdFAADSo0A2KAlUkxGahAAZR5KDWGwm2qbb+OM7bdq0ZM8rAwAgPcqIDUpoEgJkHHRNdBBdI0z/03GtI6YLOAMAAADIyBWxYCpigVpHDAAAAECGrYgRxPyNdcQAAACAjIFmHR6OHj0qS5Yskf/++08KFiworVq1kkKFCll7MlhHDAAAAMgYaNbx/7z//vsyZMgQuXjxYpxg9Prrr8vgwYOtriPWvn17s47Y+PHjpUGDBjTkAAAAANIZmnWIyKxZs6Rfv37mAWndurVUqVJF1q1bJ4sXL5bnnntO8uXLJ4888ojfnwzWEQOQXtuG+7oVOC2+AQBpXYZv1qHzsp5//nnzYGgFyhXI1Lhx48wbB31D0rVrV/Mfvz+xjhgAp3B623BafAMA0roMP0fsu+++kwMHDpiW8X379o3z4AwYMECmT58uGzdulIULF0qHDh38+mSwjhgAAACQMWT4rom//fabeSDatGkT77pd7dq1M0FMhyn6O4jpOmI9e/b0630AAOxw+vBOxRBPAAicDN+sY+fOneaBqFy5crwPUMWKFc3Xv//+2+oTAwBI25w+vFMxxBMAAifDN+vQlvWqaNGi8T5ARYoUMV+PHz9u9Yk5f/68TJo0Sb7//nsTFi9cuCA5c+aUm2++2VTv+vTpI2FhYVbPCQAAAIBvpJuKmHYc1M2brFmzmu16ly5dMl+zZcsW7+1cl7v2s0GHQrZt21b2798f53JtrX/48GFZunSpfPzxxzJv3jwpV66ctfMCAAAA4BuZkrpjbFCQo7eIiAjJlSuX102vj/cByPR/H4L45oeZ3zs2Ns5+/nbixAmzkLSGMK2APf300zJz5kxTGZs2bZppo6+Bctu2bWatsYTCJwAAAABnSnKZ61rM/w0kTp4UPWjQIK/Xx1cNU9mzZzdfL1++HO/1ronW3ipmvjZ69Gg5dOiQlCxZUpYtWyalSpWKc7028+jfv780adJENm3aJDNmzJBevXpZOTekvcn9gW4EkBQ0CwCQltGUBYD/g5izc5hk9zL0MDGFChUyX48cORLv9ToU0HM/f/v666/da5pdH8JcqlatKqNGjTLzxGbPnk0QS0fSwuR+X6NZAIC0LC383ebvLOBM6aYillK6ftgPP/wg27dvj/d61+XaJMPfYmJiZNeuXWYYZIsWLRLct3Xr1nG6PgIAAABIj3PEHL6l1J133mm+ahiLj87N8tzP30FMNw1imTNnTnQ4V0JDKgEAAACkgyCmFTEnbyl1zz33SP78+U2nwnHjxsW57t133zWXa2t7fy/m7FrQWe/r6tWrsnr16gT3/f33381XnUsGAAAAIL0GsVhnbyml88pcHRV1DLUOCdSJt/p1wIAB5nK9PkuWLGKDa0ji4MGDvTZtOH36tLz44ovm++bNm1s5LwAAAAC+k+HniCntOqgd40aMGCGLFi0ym9IFk1977TXp3r272PL888/L559/LitWrJDatWubTpB169Y1LfhPnToly5cvl7ffflv27t1rLnvmmWesnRsAAAAA30g3XRNTSytMGrgWLlxo1vLSIX+NGzeWIkWKWD0PbQry6aefSrdu3WTLli3y6KOPem27P3fuXClcuLDV8wMAAABgMYjF/L+FjdOz4sWLO6IVfKdOnaRixYqmGqfB8Ny5c+7r8ubNK23btpVhw4ZJ+fLlA3qeAAAAAFKGiphDValSRebMmSPXrl2To0ePyvnz5yVnzpymAhYUFBTo0wMAAABgJ4il/4qY08TGxkpwcLDppKg0lOk6Y+XKlQv0qQEAAACw077e2Vt6cuXKFXnppZfklltuiXO5rhmmwxF1EepZs2YF7PwAAAAAWKqIURCz4+LFi6aFva4TFh4eHuc6XehZK2R///23PPjgg7JhwwZ58803LZ0ZAAAAgACsIxbr6C290Nb0GsJ0kenZs2fHuU7b6R8/ftysa6aLP7/11lvuVvsAAAAA0mFFLDq99693CF1DTE2ZMkXatGlzw/V58uSRF154wQxf1HXPxo8fz6LOAAAAQHqtiEXHxDh6Sw+0Gce///5rhiC2atUqwX27du1qvq5bt87S2QEAAADwFSpiDqMhTOnQw4RoZUxFR0dbOS8AAAAAAaiI6YLOTt7SA23EoYtKa2Xsjz/+SHDfVatWma8lS5a0dHYAAAAA7FfEYtJH2HG6Dh06yLvvvisDBgyQJUuWmEWcr3fy5EkZMmSI+T6xIYyArw0dOlQiIyN9drxjx47JwIEDxZdCQ0NNUxsAAIB0MDQxfczDcjoNYJ988omsXbtWbr31VunVq5fUrFlTsmfPLmfOnJG//vpLpk6dKkeOHJGCBQtK//79A33KyGA0hI0dO1aczNfBDgAAwNeoiDlM6dKl5YsvvjDNOPbv3y/Dhw+Pd7/ChQvLvHnzTJt7AAAAAOk0iF1jaKI1d999t2zdulUmTZok8+fPl927d8vp06fNAs8VK1aUtm3bSt++fSVfvnz2TgoAAACAz1ARc6hChQqZapi3ihgAAACADBDErjJHDAAAAAB8gooYAAAAAFhG10QAAAAAcGyzDpYRAwAAAADbQxNZRwwAAAAArAaxqKsEMQAAAADwBYIYAAAAAFjGgs4AAAAAYBkVMQc7cOCAnD17Vq5evSqxsfF3SwkODpYqVapYPzcAAAAAKUcQc6DPPvtMXnzxRdm/f3+i+4aHh8uFCxesnBcAAAAAy0HsCs06rJg/f748/PDDdu4MAAAAQEBQEXOYt956y3ytUKGCTJgwQWrVqiU5cuTwun9QUJDFswMAAABgeUFnVnS2YfXq1ebrjBkzpE6dOlbuEwAAAIBdVMQcJDo6WqKioiQkJERq164d6NMBAAAAEPggds1f54D/J3PmzFKwYEE5duyYnDx5UvLnz89jAwAAAKRDmZK6Y9TVGEdv6UW7du3cQxMBAAAAZPCK2NUY5ojZMHz4cJk3b5688sorki9fPuncubNkzZrVyn0DAAAAsIM5Yg5y5coVeemll6RcuXKycuVK6dGjh/Tq1UuKFi0qoaGhXtcRW7t2rfVzBQAAAJByBDGHNev45JNPbrhs3759Xm+jQQwAAABAeh2amI7mYTmVVr2SOzdMG3wAAAAASK/riF0jiPmbtq1/6KGH/H4/AAAAANJIEIulWQcAAAAAWK6IXaVrok3nz5+XSZMmyffffy87d+6UCxcuSM6cOeXmm2+WNm3aSJ8+fSQsLMzqOQEAAADwDYYmOtDGjRulbdu2sn///jiXX7x4UQ4fPixLly6Vjz/+2LS51w6LAAAAANJpEIuhWYcVJ06ckFatWsmhQ4dMBUxb2NerV898r9ctW7ZMPv/8c9m2bZt07NhR/vzzT9YZAwAAANJtEItlaKINo0ePNiGsZMmSJnSVKlUqzvU9e/aU/v37S5MmTWTTpk2my6KuNQYAAAAg7ciUnIqYk7f04uuvvzZfx48ff0MIc6lataqMGjXKfD979myr5wcAAAAg9Zgj5iAxMTGya9cuyZQpk7Ro0SLBfVu3bm2+aiMPAAAAAGkLXRMdFsR00/XEEluoWRd/VpcvX7Z0dgAAAAB8hWYdDqIBrGjRomaO2OrVq02TDm9+//1381XnkgEAAABIr3PEYmMdvaUXriGJgwcPlsjIyHj3OX36tLz44ovm++bNm1s9PwAAAACpR0XMYZ5//nnTnn7FihVSu3ZtGTRokNStW1dy5colp06dkuXLl8vbb78te/fuNZc988wzgT5lAAAAAMlEsw6Hufnmm+XTTz+Vbt26yZYtW+TRRx+Nd7/s2bPL3LlzpXDhwtbPEQAAAICloYnXrsY4ektPOnXqJGvXrpUHHnjALOTsKW/evGaR53Xr1sndd98dsHMEAAAAYKEiFhtzLRV3g+SqUqWKzJkzR65duyZHjx6V8+fPm1CmFbCgoCAeUAAAACBjzBGL8u+ZIF7BwcGmkyIAAACAjBjEogligbZhwwZZuHChZMmSRdq3by833XRToE8JAAAAQApQEXOgjz76SN566y3ZsWNHnMsef/xxif1/rfqHDBkiEydONJcBAAAASFsIYg7z888/S69evSQ8PDzOumEDBgwwISxfvnxmqOLmzZulT58+ZtFnnU8GAAAAID0u6BxzzdGbE+j6X9OnT0/VMSZMmGC+eq4P9u2338qFCxdMk47ff/9dNm3aJD179jSNPN5///1UnzcAAAAApwaxq1GO3gJt5cqV0r1791QHsT/++MN87d+/v/uy+fPnm681atSQihUrxglqy5YtS9X9AQAAALCPZh0+oMME27ZtaypUqaG3P378uGTOnFkKFSpkLouJiZElS5aY7++88073viVLljRftbU9AAAAgLSFOWKpNHfuXHn00UfN0EGfPCEhISaQaQDLlCmTbNy4Uc6cOWOua9y4sXs/XVdMaQdFAAAAAOl0aGJsTIyjN9sOHjworVu3lgceeEAuXbok9913n0/WDNNKl4awv//+21z2008/ma9Zs2aNE8RcQxjLli2b6vsFAAAAYBcVsRRas2aN/Pjjj2bO1pQpUyQyMlK+/vrrVD8hGrZ2794t/fr1kyeeeELGjRtnLm/ZsqVkz57dfL9lyxZ58cUX3ZcDAAAASKdB7BoLOsdRpEgRmTx5sjzyyCNmOKG2nfeFl156yXRJ/PXXX82mQkND5dVXXzXfX7x40d2uvkKFCnG6KwIAAABIG6iIpVDdunXN5mulS5eW1atXyyuvvGLa1JcpU8aEM1f40rXEtJlHu3bt5MMPP5ScOXP6/BwAAAAA+Fe6CWJXrlwxmzc6x0q362klS9fmSor7779fbr31VvGnSZMmSaVKleSzzz4z64ZdLywszHRKzJMnj1/PAwAAAIADgljU+o/FyUaMGCEjR470ev3w4cPNPvEFsTfffDNJ96HzwfwdxLT6dfLkSbMuWb169W64XjspEsIAAACADBLEnG7o0KEyaNAgr9fHVw1TzZo1M3OwksLfISw6OtqEMO2eWKdOHb/eFwAAAIDASTdBzNvQw8RoENPNCXTul7aj166J//77r2nGAQAAACADryMGO6ZOnSo5cuSQjh07ytKlS02VDAAAAED6km4qYumBNhuZM2eO6caoc9d0TTEdNqmt8rVJR3z08j///NP6uQIAAABIOYKYg2j1S1vSe9KFovfs2eP1NuHh4RbODAAAAIAvEcQcRKtf06ZNS/a8MgAAAABpC0HMQUJCQqRnz56BPg0AAAAAfkYQ8xHtdqhrlZUuXdpXhwQAAACQThHEfBjE4lswOqViY2Pl2LFjcvHiRYmJiXFfrt9HRUXJuXPnZOfOnfLrr7/KJ5984rP7BQAAAOB/BDEHmjRpkowcOVKOHDmS6L7arIMgBgAAAKQtBDGHmT9/vvTp0ydJ+1atWlUaNWrk93MCAAAA4Fss6Oww7733nvl66623yooVK8zwxHz58klQUJBs3bpV/vrrL2nbtq3Z57HHHpN33303wGcMAAAAILkIYg6zatUq81UD1u233y4FChQwCzzrnLG9e/dKzZo15euvv5bq1avL4MGDzWUAAAAA0haCmMMWdD5//rz5vn79+u7LK1eubL5u27bN3eZ+yJAhpmnHuHHjAnS2AAAAAFKKOWIOEhwcbIYgatDKli1bnI6Mavfu3e7LXEHt559/DsCZAgAAAEiNoFgd8wbHKFKkiOmWePToUSlYsKC5bNGiRdKiRQu5++67ZfHixeYynTtWqFAhM3/sxIkTAT5rAAAAAMlBRcxhGjZsKHPnzpXJkyfLSy+9ZC6rVKmS+aqNOi5fvmyqZRs2bDCX6Ryy9Gx7xf/7uzvVnC6dxek6z54jTpYWHsO0gOeZx9AJnP46TAvSwt9EX66bCmRkzBFzmL59+5qvr7zyinTv3t18X7JkSdOk4/Tp06ZT4jfffCMDBgyIM38MAAAAQNpBEHMYXRdMF3NW2h3R5YUXXjBfZ82aJffdd59s377d/KxNOwAAAACkLQQxB9Jq2Jo1a+Is7Hz//ffLxIkT3UMRdf7Y9OnTpXbt2gE8UwAAAAApwRwxh9KhiLp50mD25JNPypkzZyR37tymwyIAAACAtIcglsZo+MqTJ0+gTwMAAABAKjA00aGuXr1q5oN169bNDD+sVq2auVy7Jg4ePFj2798f6FMEAAAAkEJUxBxo165d0qFDB9myZYv7svDwcPP12rVrMmbMGPnwww/lhx9+kDvvvDOAZwoAAAAgJaiIOYzO/9KFmzWElShRIk7DDpUlSxapUqWKXLhwQVq1aiV79+4N2LkCAAAASBmCmMO8/fbbsmfPHqlfv75s3bpV3nrrrRuCmHZUrFu3rly8eFHefffdgJ0rAAAAgJQhiDnM3LlzzdfRo0dLjhw54t0na9as7lXtlyxZYvX8AAAAAKQeQcxBdP6Xzg8LDg6WevXqJbhv9erVzdcDBw5YOjsAAAAAvkIQc5jY2FizRUVFJdpVUWXOnNnSmQEAAADwFYKYg2glTBt0xMTEmHlgCVm8eLH5WrZsWUtnBwAAAMBXCGIO0759e/N16NChZs2w+OzcuVOGDRtmvm/durXV8wMAAACQegQxhxkyZIjkzZtXVqxYYeaJTZgwwVyuVbLvv/9enn/+ebO48+HDh6Vw4cLy1FNPBfqUAQAAACQTCzo7TLFixWTevHly7733yqZNm8ymtDrWrl07934FCxY0++XJkyeAZwsAAAAgJaiIOdAdd9xhFnR+4YUXpGLFihIUFGQu16/ly5eX5557zgS0OnXqBPpUAQAAAKQAFTGHKlSokERERJhN29pfuHBBwsPDJSSEpwwAAABI63hXn0a6KebKlSvQpwEAAADARwhiDhAdHS0///yzrFy5Us6ePStFixaVZs2aSc2aNQN9agAAAAD8gCAWYOvWrZMHH3xQduzYccN1rVq1kmnTppnGHAAAAADSj6DY2NjYQJ9ERqUt6G+99VY5deqU+Tk0NNR0QTxy5Ii4nhatimmlLHPmzJIWbK9YyWfHqvT3dnkyqLQ42cQdM8XpootUFicLObhZnC42V2Fxuu3CBzaptXr/GXGygtmzitNlDXZ+D7D8YVnEyQqEO/8z8pJ5swf6FIB0wfl/MdOx0aNHmxCWI0cO+eyzz0xDjkOHDsm5c+dkxIgRZm7Y2rVrZfbs2YE+VQAAAAA+RBALoIULF5qvkydPlm7dupngpbJnzy7Dhw+XZ555xvysCzkDAAAASD8IYgG0a9cu87VDhw7xXt+1a1fz1bWoMwAAAID0gSAWIFFRUXLlyhXJli2bmRsWnzJlypivrjlkAAAAANIHglgAW9abJyCT96fAFdAuX75s7bwAAAAA+B9BLECS06ySxpYAAABA+kIQAwAAAADLCGIAAAAAYJnzVw1M565duybz58+P97rIyMhE9wkJCZEWLVr49RwBAAAA+BZBLMA0bLVt2zbF+4SHh5uFoAEAAACkHQQxAAAAAH4RExMj+/btk3Pnzkn27NmlVKlSZkSXNwcPHpTDhw9L3rx5pWzZspKeEcQCRF+Ix48fT/VxgoKCfHI+AAAAgK/8+uuvMn78eFm8eLFcvHjRfbmuoXvPPffICy+8IPXq1bvhdnqbN998Uzp27Chffvllun5CCGIBlD9//kDePQAAAOBTOqVmwIAB8uGHH7ov0+pWkSJF5NChQ3L69GmZN2+efPfdd/LKK6/IiBEjMuwzQNdEAAAAAD4ZhtiyZUsTwnT4Yf/+/WXv3r1y8uRJ2bJli5w6dUrWr19vKmKxsbEycuRIGTduXIZ95AliAAAAAFLttddek6VLl0rmzJnliy++MCFL54R5qlatmixYsMDdiG7YsGGmUpYREcQAAAAApMqxY8fk9ddfN98/9dRTcu+993oPIJkyyfvvv28C26VLl+Szzz5L9v1plW379u2ydetWOXHiRJJuoxW5TZs2yd9//22ah/jrNklFEAMAAACQKnPmzJErV66YRnJDhgxJdP8SJUqYdXI14Dz//PNJug89/ujRo6VixYqm18Itt9wit956qxQoUEAqV64sM2bMiPd233//vdSsWVPy5csnVatWlUqVKknu3LnNZXrevrpNctGsAwAAAECqLFu2zHzVYKSNOZLinnvuSfLxr127Jm3atJGff/7Z/FyoUCEpWLCgqYxpu/tt27ZJ9+7dJSoqSh577DH37b755hvTgVHnpOXIkcMEQA2L//33n6xbt066dOliqnKPPPJIqm6TElTEAAAAAKTKv//+a75qlcofpk2bZkJYnjx5TGv8I0eOmCGDuu6YNgLRqpUaO3ZsnNtpV0YNVM8995wZwqhDGXV/7d741ltvmQqXHi+1t0kJKmIAAADwqwMHDsiTTz5pvtfKQtasWaVx48bmsuDg4CRXRHQuUY8ePbzus3HjRtMaXduiexMRESErVqxw//zSSy/Fu54Vkuf8+fPmqw7l84dNmzaZANS7d2+566674lyn4U87MHbo0EF27twZ57rdu3ebr61atZIsWbK4L9fXnQYt3a6XktukBEEMAAAAfnXhwgVZtWqVTJ8+3fx8+fJlefvtt00jhJdffjlJxzh+/Lj873//SzCIFStWzLRPT8inn35q5jC51nMtU6ZMsn4XxE8rVcpz8WZfeu+99xK8XheKVtHR0aaNvjYEUbfddpv88ccfpnnIQw89JE2aNJE777wzwcCYktukBEEMAAAAfhcaGmrm+LhoVUyDVevWrU3Lc61CVKhQQZ555hkT2qZMmWL203k4d9xxhwwfPtzMBerTp4988MEHpvo1ceJEMydIw5lWSXSYmrZG18qFHlPn8ejcIQ1nDz/8sPlZ99G5RK436vAN17ywo0eP+vUhPXfunCxfvlx27Nghe/bskV27dplhg/v373fv4xnExowZI82aNZMzZ87IhAkTzKbX1ahRQ9q1a2deF6VLl45zHym5TUrwCgQAAECSaec6fTPsbdPrk2Lfvn2mwqBtz7UqVr58ebPGlM7H0Te7WpWoXbu2aZqwevVqE9hy5colnTt3NosE69datWqZaoW2S1+5cqWpmv3555/mmDp8TKsjTZs2NeHur7/+MuGtcOHC5v600vHtt9/yzPuIPndKH38NQknx448/mrlfrqGACdHXlT6nxYsXN4H+2WefNQFJg7eGsLx588Z7Ox12qkGtX79+7rCo56evBx3CevPNN5tAn9rbpES6r4gNHTpUIiMjA30aGUbvQJ8AAADwK51jpfNxvNHKlTY7uJ52t3NVxHRIor7R1TfROrdIQ1f//v3dc7Y0WLl+1jClQxr1uGFhYabypeegb4x1Pphr3tns2bPdiwQrDXGu8/ztt9/M3CG97TvvvGMu04WG9Y220rlFSJ327dubCqc+t9pB8fp5XN4WgF65cqU0bNjQ3XXRm169ernXG2vQoIHUqVNHypUrJ2XLljWt67XSWb9+/Xhvq9Wr8ePHm+GNmzdvNtVSfU0sWrTIDKXUoN6iRQtzrNTcJrnSfRDTEHZ99xT4z/YFC3l4AQBI5x9yDxo0yOv1OuQwPuHh4aY5h4YmDVQ6zEsrXAsXLjStyF20qqWVLs95X/oG2JPuc/vtt8v9998fZz8Ney5a+XLRhgsa3IoWLWo2zwYg3333HUHMB7SRhq61pYss67pgOrw0oeGfixYtMiFMJdYGXjskzpw503yvVbC+ffvesI9nF0NXRU6HFmo3Rx0Wq2319bWnoV83DVLajl7PWYes6pwwDVUpuU1KMTQRAAAASaZBK2fOnF43b0HMNUdMhxhqx0QNYfHR6oZWyrR9uNJFf3UomL4hdl2m++jcIK1I6DF1mOP13fLio0MRdUFglw0bNpjKGHxDG7CoNWvWyAMPPGDCSnz0+oceesj9XOqcq4To3EDXc68B/noajjyrsK7hsWfPnjWVMx02Gd/rQxdodoVFV7ORlNwmpdJ9RQwAAABphw5B+/zzz001QitZ2oxDh4Xpwrq6plOnTp1MdWTGjBlSsWJFE+hcDRx0uGNCdO6PVmu0c6K+mc6cObO88cYb1n639E5D9rBhw2TUqFHy1Vdfye+//24WV9Zgo4svHzp0yARrHWJ49epV07nyiy++kJCQhCOJBnF9/nUYqzZaefHFF01jF33etRL24YcfxpmbqFUt3V9DdvPmzU3VtVGjRjJw4EAT5PTDAg3y48aNMx09dd6ZNudQKblNShHEAAAA4FclSpSQTz75xOuQNp0X5qLDFnWdr/Xr15s313Xr1nW/Ude1pLT6pQFtyZIl5md9c65v9PWNsu6nc8l0fo/nMXVImTYG0eGKGta06YLur4sAJxYCkDw670tDig5h1Q6Kr7/+erz71a1b1wRiDVSJ0deEztV6/PHHzbDBRx99NM71Olds1qxZJghqoxZ9jvU1pzT06Rw0HTKpyxZcT4e06vBUz0puSm6TErzyAAAA4Fc6P0y7F8anQIECZvOk7ec954m5aLXCNZRQK1quTn0uWmFxrQ/meUyd3+OiIU7nl8F/dC5g165d5euvvzZVMW0zr8MUtUqliy9rV8wmTZqY4abX0xCn4fymm26Kc3nPnj1Nkw5dukBb1+sQwpIlS5qlCbp06WKqm926dTNNP1xLFigN4OvWrTNV1l9++cUMY9RhjjpXUF+TOkRSX5+eUnKblAiKdQ24TKe0nEizDnu2V6zks2NV+nu7PBmU+jUa/Gnijv87cdTJootUFicLObhZnC421/+f8O1U26VgoE8hzVu9/4w4WcHsqfvk1Yaswc6fep4/LIs4WYFw539GXjJv9kCfApAuOP8vJgAAAACkMwQxAAAAALCMIAYAAAAAlhHEAAAAAMAyghgAAAAAWEYQAwAAAADLCGIAAAAAYBlBDAAAAAAsI4gBAAAAgGUEMQAAAACwLMT2HQIAAADIWGJjYyX28mVr9xeULZsEBQUlef+///5bvvjiC3nllVfEFoIYAAAAAL/SELajRk1rj/LN69ZKUFhYkvY9dOiQdOzYUUqUKCE2MTQRAAAAQIb03XffSZUqVeSyxWqdCxUxAAAAABnSzz//LBMnTpTjx4/L/Pnzrd43FTEAAAAAGdJ7770nnTt3Dsh9E8QAAAAAwDKCGAAAAABYxhwx+NScLr4r7Y4QkYk7ZoqTPXVzN3E6pz+GkZtXitPFtH5anK5krDjamchr4nTVi+QSJ7s1V4w43d5I57+tWLrntDhZj9sKBvoUAFhCRQwAAAAALCOIAQAAAIBlzh9DAAAAAAB+1Lp1a6lZ096C04ogBgAAAMCvgrJlk5vXrbV6f8lRpkwZs9lEEAMAAADgV0FBQRIUFsaj7IE5YgAAAABgGUEMAAAAACwjiAEAAACAZQQxAAAAALCMIAYAAAAAltE1EQAAAIBfxcbGSnR0tLVHOXPmzKZTo5MRxAAAAAD4lYaw119/3dqj/OKLL0qWLFkS3e/IkSPy8ssvy5YtW8yCzqNGjZJcuXJZOUeGJgIAAADIkFW6tm3bSkxMjAmJe/fulYceesja/VMRAwAAAJDhLFu2TP777z9ZuXKlhISEmIpYoUKF5J9//pHy5cv7/f6piAEAAADIcFavXi116tQxIUzlzJlTqlSpIqtWrbJy/wQxAAAAABnO8ePHpWDBgnEuK1CggBw9etTK/RPEAAAAAGTIBiLBwcFxLsuUKZOZM5bu5ogNHTpUIiMjbd6lHDt2zOr9AQAAAHC+XLly3ZAVzp8/b4YoprsgpiFs7NixNu9SBg4caPX+AAAAADhfpUqVZP78+XEu27lzp1SuXNnK/TM0EQAAAH7177//SuHChc1WpEgRKV26tDzyyCNy9uzZZH2gP3jw4AT3Wb58uTz88MOJHuvKlSvStGlTM0fIU69evcwxkDE0b97cvDYXLVpkfp42bZoZqlivXj0r908QAwAAgF9dvXrVzL3ZsGGDrF+/Xn799Ve5cOGCvPDCC0k+xpkzZ+Tbb79NcJ+6devK+PHjE9xH33hrCFu6dKlcu3bNXHbixAnp3LmzTJ8+3YQ0ZAx58uSRKVOmSKdOnaRUqVLm9fjZZ59J5syZrdw/QQwAAAD+f9OZKZO7KlamTBlTfdI24RrKevbsaaoQzz77rNl38uTJUrVqVbO999575rIHH3zQLLjbsGFD8/PMmTPNuk/abvydd95xtyN/+umnzTF1Yd4OHTpIhQoVpH///u4GDNqzYMCAAVKiRAn3ub3xxhvm/rVCgozlgQcekEOHDsnixYvNmmKNGjWydt8s6AwAAIAk04pRQlWjrFmzmi0hWolasGCBVKxY0Rzrq6++koULF5pw9Msvv5hgNGPGDHOc7t27S7FixeT999+XVq1ayTfffCNr1qwxla+pU6dKaGioCV9a0dDmC6dPnzbHnDt3rnz55ZdSsmRJE8jatWtnKmF6ufIc5jh69GjzVe8b/qFVphdffNHaw5s5GVWt7Nmzy8033yy2EcQc2u0xrdI/gAAAIP2KiIiQkSNHer1++PDhMmLEiBsuP3z4sKmGKZ0bpm98v/76a9McoUaNGtKgQQNznVbA+vXr5/55yJAhpqGC/qzzd/Lnz29C2NatW6Vly5Zmn8uXL0u5cuXk/vvvd9+f7t+2bVvzfePGjeXIkSM+fiSQHEFBQZIlSxYeNA8EMYd2e0yr4vvDCwAA0tcH1IMGDfJ6vbdqWKFChWTdunXmDXlYWJjkyJHDXK5BTOfqeL7v0iqXi35/6dKlOMfSfZ566qk43bGzZctmKmUuni3IdVhkbGxssn9XwJ+YIwYAAIAk06ClIcfb5i2IueaIaSBzhbD41K9fXz755BNTNdMApvPF6tSpY24fFRXl3keHKKrcuXObIW+zZ8/mWUSaQhADAACAY3Tt2lWqV68uRYsWNcMQNbjpUMW8efNKSEiIGYKoc77atGkjN910kwlip06dkh49egT61IFkYWgiAAAA/Kp8+fKmbX18mjRpEmfdJq18TZo0ycwDi46ONsMYXXbt2mXa3ivtlPjWW2+ZKplrnzvvvFNq1aplfvY8pu57/fwkHcaYL1++OJdp63LP+wP8iSAGAAAAv9ImGwUKFIj3Og1I8TVx0K5313e+0/llnsMatUKmW3zH8jym53wxl/jOR6trgC0MTQQAAAAAywhiAAAAAGAZQQwAAAAALCOIAQAAAIBlBDEAAAAAsIwgBgAAAACWEcQAAAAAwDKCGAAAAABYRhADAAAAAMsIYgAAAABgGUEMAAAAACwjiAEAAACAZQQxAAAAALCMIAYAAAAAlhHEAAAAAMAyghgAAAAAWEYQAwAAAADLCGIAAAAAYFmI7TtE+tZ59hzfHWzECIkuUlmcbOKOmeJ0T93cTZzslf+1FKf7/ebT4nQds+wSJztfsLo4XYV8WcXJYhZPEqcLbfi4OF3PyrnFyTJdOC6Ol61koM8ASBeoiAEAAACAZQQxAAAAALCMIAYAAAAAlhHEAAAAAMAyghgAAAAAWEYQAwAAAADLCGIAAAAAYBlBDAAAAAAsI4gBAAAAgGUEMQAAAACwjCAGAAAAAJaFSDoXGhoqAwcOTNUxjh075rPzAQAAAIB0H8QiIiJSfYzUBjkAAAAA8MTQRAAAAACwjCAGAAAAAJYRxAAAAADAMoIYAAAAAFhGEAMAAAAAy9J910QAAAAE1rVr1+T48ePm+6CgIMmaNavkzp072ceJjY01t/cmKipKLl26lOixdb+YmBizzBEQKFTEAAAA4Ff//POPFCtWTKpVqyZVq1aVUqVKSfXq1WXPnj1JPsaFCxekXbt2Ce6zevVqefrpp71eHx0dLV27dpU8efJIvnz55IEHHjCXAYFAEAMAAIDfFSlSRI4cOWK2s2fPSrNmzeSFF14w1anz58/LlStXTMXLRQOSXueyf/9+2bJli5w4ccJ92dWrV83tXOrWrSvjx483tzt37py57OLFi+7r58+fb76ePn3aVOiOHTsmn376qd9/dyA+BDEAAABYd88998jOnTtlyZIl0qZNGylRooQ89NBDJoz17dtXcuXKJXnz5pVHH33UBC69TMPYvffea24/ZMgQU9UqWLCgdO/e3eyzbNkycww9ZsuWLaVs2bKSP39+adSokURGRprbzpo1S7JkySJhYWFSp04dOXPmDM8+AoIgBgAAgCTTCpRWm7xtnhUqTzony1UR27Ztm0yYMEEaNGhgrtu+fbvs2LFDPvnkE5k9e7b89ddfcujQITl69Kjs27dPJk+eLJ9//rmULl1ali9fLj/++KOsXbtWNm7caI6lVa+pU6fGuT+9XAOZBi2tuC1evDjO9Xv37pUvvvhC7rvvPp59BATNOiwYOnSo+RQmI+gd6BMAAAB+FRERISNHjvR6/fDhw2XEiBE3XK6hSueIabMNrUY1bNhQXnvtNVm1apW5XOdtqT/++EN69OjhbrjxxBNPyLx58+IEJg1ja9askXr16rkv03ln5cqVizNMUYOb0vloGsZctBKn1bFJkyZJmTJlUv2YAClBELNAQ9jYsWMlI9i+YGGgTwEAAPj5A+ZBgwZ5vV47InqbI3bgwIF4r9Ng5hISEhLnA2ztgnh9p8Tg4GDp16+fjBo1yvx8+fJlM6fszz//dO/j2RFRb++af7Zy5Up5/PHH5eOPPzZhDQgUghgAAACSTIOWt7DlC61atZLevXubapfez1tvvWXCnwY07Zz433//mX3at28vd911l5kDpqFMw1Xx4sUTPLYOc+zSpYsZkqgVNB0mmT17drMBthHEAAAA4N83nCEhpqlGfDRsuYYlqrvvvts04njqqafMfLNHHnlEHn74YVPRql+/vnTs2NEMSxw9erQJaDrkUFvS9+zZ0wxZ1GNdf0xt/JEtWzYz10yPqSHORdvdDxs2jFcArCOIAQAAwK907ta6deviva5x48Zm8/Tkk0+azZMOL/zmm2/cP+s8Mt086bwz3VzHdRkzZoz5qiHONZwRCDS6JgIAAACAZQQxAAAAALCMIAYAAAAAlhHEAAAAAMAyghgAAAAAWEYQAwAAAADLCGIAAAAAYBlBDAAAAAAsI4gBAAAAgGUEMQAAAACwjCAGAAAAAJYRxAAAAADAMoIYAAAAAFhGEAMAAAAAywhiAAAAAGAZQQwAAAAALCOIAQAAAIBlBDEAAAAAsIwgBgAAAACWhdi+w7QoNDRUBg4cmOLbHzt2TDKKOV06++xYI/QFenCzOFnk5pXidK/8r6U42asvLxCn6/nwKHG881HiZHmzOf+/m8irMeJkoQ06itN9seWIOF3ZvGHiZE3L5Benyx3oEwDSCef/z+gAERERqbp9akIcAAAAgPSHoYkAAAAAYBlBDAAAAAAsI4gBAAAAgGUEMQAAAACwjCAGAAAAAJYRxAAAAADAMoIYAAAAAFhGEAMAAAAAywhiAAAAAGAZQQwAAAAALCOIAQAAAIBlBDEAAAAAsIwgBgAAAACWEcQAAAAAwDKCGAAAAABYRhADAAAAAMsIYgAAAABgWYjtOwQAAEDGcvHiRfn111/N90FBQZI1a1apXbu25MqVK1nHOXXqlOTNm9fr9SdOnJA9e/aYYyfkn3/+kcOHD5v9smXLlqxzAHyFIAYAAAC/2r9/v3Tq1EmaNm1qfr58+bKsX79e5s2bJw0bNkzSMU6fPi1NmjSRDRs2eN3n4MGDsmDBggSD2DPPPCNffPGFlC1bVk6ePCmrVq2SPHnypOC3AlKHIAYAAAC/y5cvn8yfP9/98/jx4+X111+XTz/9VI4dOyYxMTGmOlWuXDnz/dq1a81+1atXl5CQEFm+fLnZb+nSpXLXXXdJbGysCWVRUVFSo0YNyZw5sxQrVkxatmwpx48flyNHjpj7/Pfff6Vq1aqm+rZy5Ur58ccfTUUsR44cEhERYY7RuHFjXgGwjiAGAAAA6zRw6VBCDVwDBw40Qap169YyfPhwE4zOnTtnLgsODjbDGn/44Qc5e/aszJkzR+644w4TuHSoYmhoqFy6dMkENA1V48aNk379+snTTz9t7id37tymUrZp0yZZsmSJdOvWzdyv7jtgwACGJiJgCGIAAABIsitXrpjNG53/pdv1IiMj3RUxDVCjR4+WBx54wH3dli1bTOjSSlmRIkXkjz/+MPPJHnvsMXn33Xdl5MiR8ssvv8gHH3xgqmhaNdPL1EcffSQTJkyQunXrxrk/rXxpULvnnntMmDt69KgJfl9++aWEh4fLmTNnzP3kz5+fVwCsI4hZoH8A9JOejCC5k24BAEDaosP5XAEoPlrRGjFiRLwNOyZNmmTCVVhYmPTu3Vv69OkjP/30k1SqVMmEMLV161ZT7dL9lFbJZs+eHedYWt3SUKXHc9FjetLhiPoeTJUsWdIMYcyUKZOpgP3+++/m+Fo502D38ssvp/JRAZKPIGbpD1ZGEd8fXgAAkH4MHTpUBg0a5PX6+Kph8c0R85QlSxb399o4Q4cSejb6yJkzZ5z9dbjhnXfeKRMnTjQ/79q1y1TpDh065N5H55V50jll5cuXN00/XCFPG3YcOHAgkd8Y8A+CGAAAAJLM29BDX3nwwQdNMw5tU6/3M2rUKFMR0+91bpeGuc6dO0utWrWkRIkSZlihfug9efLkRI+tnRtfffVVsxUvXlzGjBljhikCgcCCzgAAAPCr7NmzS7NmzeK9rmDBgnHazVepUsU05tDhhzqEcNasWaZtvVbKnnvuOfn6669NZUvnfO3bt8806dAGHXr8AgUKSJ06dW44pg5T1OCll2vnRO2qqEMip06dKvXr1+fZR0AExWqd1hKdJzV27Fhbd4c0PjRRj3Xt7+XiZFc2rxSnO7NjjzjZqy8vEKfruXedOF3t8+vFya7c1ECcLvJqjDhZjsgT4nTjtkWJ05XNG3cekdM0LZNbnC53dmc/hkBaQUUMAAAAACwjiAEAAACAZQQxAAAAALCMIAYAAAAAlhHEAAAAAMAyghgAAAAAWEYQAwAAAADLCGIAAAAAYBlBDAAAAAAsI4gBAAAAgGUEMQAAAACwjCAGAAAAAJYRxAAAAADAMoIYAAAAAFhGEAMAAAAAywhiAAAAAGAZQQwAAAAALCOIAQAAAIBlBDEAAAAAsCzE9h0CyRGbq7CjH7CY1k+L0/1+82lxsp4PjxKnm166hjhd6IEN4mSVzx8RpwvJHCpOdiAojzhdz+rB4nS5rp0TJ5u29bg43RN1SwX6FIB0gYoYAAAAAFhGEAMAAAAAywhiAAAAAGAZQQwAAAAALCOIAQAAAIBlBDEAAAAAsIwgBgAAAACWEcQAAAAAwDKCGAAAAABYRhADAAAAAMsIYgAAAABgGUEMAAAAACwjiAEAAACAZQQxAAAAALCMIAYAAAAAlhHEAAAAAMAyghgAAAAAWEYQAwAAAADLQmzfIQAAADKWkydPygcffGC+DwoKkqxZs8pdd90ltWrVStZxNmzYINWqVfN6/d69e2X16tXSuXNnr/ucPn1a5s6dK9euXZP7779fChQokKxzAHyFihgAAAD86vjx4/LWW29JZGSkXL58WQ4fPixt27aVmTNnJvkYx44dk06dOiW4j4ar6Ohor9frfdesWVOWLl0qq1atkurVq5tgBgQCFTEAAAD4Xc6cOeW1115z/6yBaNKkSVK/fn3ZuXOnnDhxQvLnzy8tWrSQU6dOyVdffWX2a9eunRQqVMiENr1cb/Pkk0/K2bNn5euvv5aoqCizT5EiRSQ4OFgyZ84su3fvlh07dpjvt23bJk2aNJFbb71V/v77b3Men3/+uTl2o0aNZO3atdKsWTNeAbCOIAYAAIAku3Llitm80WGHuiVGQ5JWsDSEde/e3YShpk2bmuqZVqoaNmxojvPKK6+Y4YZa6YqNjTX3fe7cObn99tulXr16EhoaaqptS5YskX///VdmzJghuXLlkm7dukmdOnWkRIkSMnToUNm8ebMJYwULFpRevXpJlixZ5OrVqyYIAhkyiOk/DC1TI33QP3wAACD9ioiIkJEjR3q9fvjw4TJixIgbLj9//ry7IqaVrc8++0zGjBljftaKl6tK9frrr0v79u3l/fffNz9rEHvvvfdk8ODBMnnyZOnfv7+MHz9ecufOLWXKlDH7lCpVylTKNMi56DEXLFhg5qSdOXNG/vzzT1MN0xCnYU5DmCvUhYeH+/hRAtJAENMQNnbs2ECfBnwkvj+8AAAg/dAP0QcNGuT1em/VMK1m6fs+DUbaIEOHFd5xxx2ycOFCd6ByNdzQSpaLVseun0u2Z88eCQsLc3+Yr9Wx65t4lC9f3tyX64NiDV4ff/yxObYGO/Xyyy/LuHHj5M0330zRYwGk6SAGAACAtCOpQw8TmyPmKVOm/98/rnjx4mYYocvGjRvN/C9XqHLtc/DgQffxfvvtN4mJiTFDHeM7picNZC46PPHixYvJ/l0AXyCIAQAAwDEef/xxUwXToYwa+LTVvHY51OGD2m1Rq1c6x2v06NGmTb02+Pjyyy/lp59+Mp0VE6LzxrRyduHCBcmRI4d88cUXJsQBgUAQAwAAgF9pWNK5XfG56aab5IEHHnD/rNUvXS9Mw5XO4dKuhjoHTM2ePVv++ecfyZcvn2zatMnso4Ft+fLlUqFCBdm1a5d06dLlhmO2adPGDH8sVqyYqba51hFbs2aNlC5dmmcfAUEQAwAAgN+D2HPPPRfvdTqXSzdPhQsXln79+t2wr6495nlMbWPvSQOYbq7junTo0CHOsZ9++ulU/DaAb7CgMwAAAABYRhADAAAAAMsIYgAAAABgGUEMAAAAACwjiAEAAACAZQQxAAAAALCMIAYAAAAAlhHEAAAAAMAyghgAAAAAWEYQAwAAAADLCGIAAAAAYBlBDAAAAAAsI4gBAAAAgGUEMQAAAACwjCAGAAAAAJYRxAAAAADAMoIYAAAAAFhGEAMAAAAAy0Js3yHSt86z5/juYCNGyHYpKE5WMlYcr2OWXeJo56PE6UIPbBCnm1S8mjjZuEUvi9MFV79bnKzo5sXidPPyNxOnKxSeRZysZfnsgT4FAJZQEQMAAAAAywhiAAAAAGAZQQwAAAAALCOIAQAAAIBlBDEAAAAAsIwgBgAAAACWEcQAAAAAwDKCGAAAAABYRhADAAAAAMsIYgAAAABgGUEMAAAAACwjiAEAAACAZQQxAAAAALCMIAYAAAAAlhHEAAAAAMAyghgAAAAAWEYQAwAAAADLCGIAAAAAYBlBDAAAAAAsI4gBAADArw4ePCgdOnQw27333itdunSRDz/8UK5du5bkY8TExMjMmTMT3GfTpk0yatSoBPfZsWOHPPnkk/LYY4/Jzp07k3z/gK8RxAAAAOBX58+fl99//1169uwpPXr0kPbt28uUKVPkjTfeSPIxjh07JsOHD09wnyJFikjTpk0TPA+9vkSJElK+fHlp0qSJuQwIhJCA3CsAAAAylNDQUFMRcwkPD5fXXntNWrVqJcuWLZM9e/aYcNS3b19Zs2aNTJ061eyn4a1+/fry6quvypEjR6Rfv34yYcIE2bJli3zwwQcSFRUl3bt3l4YNG8rhw4fll19+kaxZs8ry5cvl0qVLsm3bNmnRooU8+OCD8t1330m9evVk2LBh5tj//POPzJ07Vx599NGAPS7IuKiIAQAAIMmuXLki586d87rp9Ulx4MAByZMnjxw9elRefPFFU6WqXLmybN++XVq3bi0VKlSQKlWqmOqZBrO7775bcuTIYYY2/vfff9KxY0e59dZb5fbbb5fevXvL6tWrTdVs5cqV5piDBg0y1a4GDRrIU089JWvXrjXB67bbbnOfg97f1q1befYREFTEPAwdOlQiIyMD80ykE70DfQIAAMCvIiIiZOTIkV6v1+GDI0aMuOHykydPuitip06dkvXr18sPP/xgqlYauJ599llz3csvvyx9+vRx/6zzyKZNmyavvPKKqaLp0EId0hgUFCSLFi0y+4SEhMisWbOkTZs27vurVauWe76YDovUuWH6Pi9v3rzufbRyphU1IBAIYh70H+fYsWMD8kSkF9sXLAz0KQAAAD9/cK3VJm803MRHQ5QOM9QAFRYWJjVr1jShaOHChVK4cGH3flrV0hDlopUyHWbo6fjx41KnTh2577773JcVL15czpw54/7Z85h6TtrsQytwp0+fdl+u3+tlQCAwNBEAAABJpqEmZ86cXjdvQcw1R0yHGuowQ8/KlKdbbrlFFi9e7P55wYIFZpiiBrjY2FhzWaVKlWTfvn3Stm1bc0ydO6ZzzBJTt25dU0WLjo42lTY9tl4GBAIVMQAAADhGr169ZMaMGVK1alXJnDmzXLhwQX777TfJlSuXqYR17dpVpk+fLp988okJbblz5zaXr1ixItH5Xo0aNZIyZcqYoZDBwcGmy2LLli2t/W6AJ4IYAAAA/EqHDX700UfxXlejRg0z3NFzCOOqVavkr7/+Mo0/tBmHBjK1YcMG2bt3r6m6aThbt26dacihnRCzZctm5oq99NJLUrZs2TjH1E6L+fPnN1W1L7/8Ms6xM2VigBgCgyAGAAAAv8qePbs0b9483usKFixoNk8aqDRcXU8Dlm5KA5TnXDJVoEABs7mO61KtWjX39xrGateuncrfCEg9PgIAAAAAAMsIYgAAAABgGUEMAAAAACwjiAEAAACAZQQxAAAAALCMIAYAAAAAlhHEAAAAAMAyghgAAAAAWEYQAwAAAADLCGIAAAAAYBlBDAAAAAAsI4gBAAAAgGUEMQAAAACwjCAGAAAAAJYRxAAAAADAMoIYAAAAAFhGEAMAAAAAywhiAAAAAGBZiKQBQ4cOlcjISL/fz7Fjx/x+H+ndnC6dfXasEeJ8ZyKvidOdL1hdnCxvNuf/Gap8/og43bhFL4uTDWj+P3G695aFi5MdvO1ecbriF6LE6WrmDRInC9o4XxyvYZdAnwGQLjj/HZCICWFjx471+/0MHDjQ7/cBAAAAAFaDWGho6A1hhyoUAAAAgIzGahCLiIi44TKqUAAAAAAyGpp1AAAAAIBlBDEAAAAAsIwgBgAAAACWEcQAAAAAwDKCGAAAAABYRhADAAAAAMsIYgAAAABgGUEMAAAAACwjiAEAAACAZQQxAAAAALCMIAYAAAAAlhHEAAAAAMAyghgAAAAAWEYQAwAAAADLCGIAAAAAYBlBDAAAAAAsI4gBAADAr3bt2iWlS5c2W5kyZaRixYrSp08fOX/+fJKPceXKFRk2bFiC+6xYsUIee+yxRI8VHR0trVu3luPHj7svW7hwodSrV09q1qwpixYtSvJ5ASlFEAMAAIBfafDRILV06VL59ddf5ZtvvpHDhw/Liy++mORjnD59WubMmZPgPhqiIiIiEtxn37590rx5c1mwYIFcu3bNXHbo0CHp3r27vPzyyzJq1Cjp2bOnOT/AnwhiAAAA8Lvg4GB3VaxSpUqmIqYVrN9++02efPJJueuuu2TIkCFm308//VTq1q1rtsmTJ5vLevToYUJU06ZNzc9fffWVNGjQQGrXri0TJ040l61du1aGDh1qjtmrVy/p0qWL3Hbbbea4sbGxZp8BAwaYqlnJkiXd5/bDDz9ImzZtTJWsRYsW0rlzZ/niiy94VcCvQvx7eAAAAKQnWtnSzZusWbOaLSEain755RcpV66cXL58WT777DOZN2+eGbaoIUorUx9//LE5zqOPPiqFCxeWt956S9q3b29C2rp16+SNN96Q9957T0JDQ024KlasmISHh8vRo0fNMXW/mTNnysCBA+WBBx4wAatx48by9ddfS1BQUJxhjv/99585Fxc9jz179vjoEQPiRxDzoP+Q9R8rUi5Xrlw8fAAApGM69G/kyJFerx8+fLiMGDHihsuPHDliqmGuYYZFihSR7777Tnbv3i01atRwV7o++OADefrpp90/a4Xr22+/lddff11CQkJM4JoyZYr8+++/0rVrV7PPhQsXzByvjh07uu9Pq2WdOnUy3zdp0sQMP1Qawq539epVU7Fz0fuJiYlJ8WMEJAVBzENiY4qRuPj+8AIAgPRDg9GgQYO8Xu+tGlagQAEzR0yDUFhYmPlZaRDLmzeve7+LFy+aypaLfq+Xebp06ZIZXtivX784+23cuDHeD4c1ZLmGJsanUKFCpirmovPD9DLAn5gjBgAAgCTToJUzZ06vm7cg5pojVqpUKXcIi492LtShilrl0iGQH330kWnCkSlTJtP0Q+ncMZ3XlSNHDilevLgZtqhVs5TSIYvaQES7KGq17ssvvzSXAf5EEAMAAIBjPPTQQ1K+fHkzL0wDm1a6dKiiVs10uGDlypXlvvvuM0FJG27kzp3bVNW6deuW4vusWrWq6ZRYtmxZE+xatmwpt99+u09/L+B6DE0EAACAX910002yatWqeK9r1KiRmSPmopWv6dOnm06IUVFRJmi5aAONM2fOmOGNev0777xjGnPkyZPHXH/HHXeYLolaKfM85ptvvml6AXj6/fff41TmdG7b888/b6puWtkD/I0gBgAAAL/KnDmzqTTFJ1u2bGa7ns4j082TNtHInz+/+2cNV54By/Nnz2Pmy5fvhuPHdz7ezgXwB4YmAgAAAIBlBDEAAAAAsIwgBgAAAACWEcQAAAAAwDKCGAAAAABYRhADAAAAAMsIYgAAAABgGUEMAAAAACwjiAEAAACAZQQxAAAAALCMIAYAAAAAlhHEAAAAAMAyghgAAAAAWEYQAwAAAADLCGIAAAAAYBlBDAAAAAAsI4gBAAAAgGUEMQAAAACwLMT2HSJ96zx7ju8ONmKErN5/RpysepFc4nQV8mUVJ4u8GiNOF5I5VJwuuPrd4mTvLQsXp3vmzhfEycb9cFqcrmSRMuJ0sWEVxcmuXTwX6FMAYAkVMQAAAACwjCAGAAAAAJYRxAAAAADAMoIYAAAAAFhGEAMAAAAAywhiAAAAAGAZQQwAAAAALCOIAQAAAIBlBDEAAAAAsIwgBgAAAACWEcQAAAAAwDKCGAAAAABYRhADAAAAAMsIYgAAAABgGUEMAAAAACwjiAEAAACAZQQxAAAAALCMIAYAAAAAloXYvkMAAABkLNeuXZPTp0+b74OCgiRr1qySPXv2ZB8nNjbW3N6b6OhouXz5suTMmTPRY128eFHCwsISPB7gT1TEAAAA4Ff//POPFCpUSCpWrCg333yzFC5cWGrXri379u1L8jEuXLgg9957b4L7rFy5Uvr06ZPosY4fPy5VqlSRo0ePJvn+AV8jiAEAAMDvihQpIidOnDDb+fPnpWHDhvLCCy+YKpZWp/Srp6tXr5rN5dChQ7Jp0yY5c+ZMnEqb5+3q168vH3zwgfuYKjIyMs5xf/rpJ2nQoIEcPnzYj78tkDiCGAAAAKzS4YAtW7aUv//+W3755Rdp06aNFCtWTLp162au79+/vxlemDt3bundu7cJXI8//ripoOnt1LBhwyRfvnxme/TRR80+v/32mzz44IPmmM2bN5fy5cubYzRt2tQdyDSIzZ0711TogEBijhgAAACS7MqVK2bzRud/6Xa9mJgYUw1Tp06dkokTJ5oKltqyZYts377dhK85c+bIH3/8IQcOHJDMmTNLu3btZMqUKebyO+64www/XLBggaxevdpUyLJkySJ9+/aVqVOnyk033eS+Pz3munXrTCXu9ttvNwGsbdu28tZbb/FswxEIYvEYOnToDWVsJE1vHigAANK1iIgIGTlypNfrhw8fLiNGjLjhcp2PpXPEtBqmTTJ0aOJrr70mf/75p1SrVk3y589v9luxYoU88sgjkjdvXvOzzvmaN2+edOjQwX2sZcuWyapVq6RGjRruy4oXLx4niNWtW1fKli1rvtf9zp0756NHAPANglg8NISNHTvWRw9xxrJ9wcJAnwIAAPDzB9aDBg3yen181TCllSmtcsUnPDzc/X1wcHCcipt2Qby+s6HuM2DAABPklO6v88I0nLlky5bN/b3eXjsuAk5CEAMAAECSeRt66CstWrSQp556yjTU0Pt5++235bnnnpOQkBDTOfHgwYNmn/vuu8/M/dJKmg5N7Nmzp5QsWZJnEmlGwINYaGioDBw4MMF9jh07Zu18AAAA4FsaolxDDa+nc7w81/3SJhv63lAbcGilS4cpdu/e3VynLe+1scf69evNEEndTzswdu3a1ey3fPlyyZUr1w3HzJEjh3nP6UnPJ1Mm+tYhcIJi00CdVv+R2RwqaPv+0pPtFSv57FiV/t4uU/9M+voigVC9SC5xugr5/PeppS9EX3P8nyDJftX58wqCrkaJk8X+/Yc43TN3viBONu6HIeJ0IUXKiNPFFqsoTnZt3WJxutAWzAgHfIGPAQAAAADAMoIYAAAAAFhGEAMAAAAAywhiAAAAAGAZQQwAAAAALCOIAQAAAIBlBDEAAAAAsIwgBgAAAACWEcQAAAAAwDKCGAAAAABYRhADAAAAAMsIYgAAAABgGUEMAAAAACwjiAEAAACAZQQxAAAAALCMIAYAAAAAlhHEAAAAAMAyghgAAAAAWEYQAwAAAADLQiQDGDp0qERGRiZ5/2PHjvn1fNKzOV06++xYI0SkYPas4mS35ooRp4tZPEmcLLRBR3G6A0F5xOmKbl4sTnbwtnvF6cb9cFqcbEDrN8XpJvz1vjhdplP7xclO1u8mTlc40CcApBMZIohpCBs7dmyS9x84cKBfzwcAAABAxsbQRAAAAACwjCAGAAAAAJYRxAAAAADAMoIYAAAAAFhGEAMAAAAAywhiAAAAAGAZQQwAAAAALCOIAQAAAIBlBDEAAAAAsIwgBgAAAACWEcQAAAAAwDKCGAAAAABYRhADAAAAAMsIYgAAAABgGUEMAAAAACwjiAEAAACAZQQxAAAAALAsxPYdAgAAIGO5dOmS/PHHH+b7oKAgyZo1q1SvXl3Cw8OTdZxz585Jzpw5vV5/6tQp2b9/v1StWjXe6/fu3Sv//vtvnMuKFi0qt9xyS7LOA/AFghgAAAD86r///pM2bdrIHXfcYX6+fPmy7NixQ+bPny/16tVL0jHOnDkjzZo1k7/++svrPvv27ZOvvvrKaxBbsWKFTJs2zf3z+vXr5dFHH5W333472b8TkFoEMQAAAPhd/vz55eeff3b/PHbsWHn11VdlxowZcuLECVMpy5Ytm5QoUUJiY2Nly5YtZr/KlStLpkyZZNWqVXL48GFZuXKl1K9f31y3fft2iYqKkltvvVWCg4OlVKlS0qlTJzl58qQcP37c3Ofu3bvNMbT61q1bN7OpNWvWmBA2YsQInn0EBEEMAAAA1ulwwJkzZ5pANHjwYLl69aq0atVK3njjDbnnnnvkwIEDkjlzZsmdO7f89NNPMmfOHDl9+rRMmTJF6tSpI+3bt5c9e/ZIaGioCWG//PKLrFu3TsaNGyf9+vWTgQMHypUrV0wAO3v2rGzcuFHy5Mlj7jsmJkaefPJJeffdd5M9PBLwFYIYAAAAkkzDjW7e6Pwv3eK7nasipnO53nzzTWnbtq35+fz587Jr1y4JCQmRiRMnmnlgO3fuNFWyHj16mMAUEREhy5cvl48//lg+++wziYyMNJcrvc37778vtWrVijOf7J9//pGwsDBp2rSpCWr333+/ue77778399GkSROeeQQMQSwe+smKfoqC5MuVKxcPGwAA6ZgGopEjR3q9fvjw4fEO99OwpdUuDVcajrp27Sr9+/c3AUmHDmoIU5s2bTLzyXQ4ourQoYPMnj07zrE2bNhgmnLo8Vxc+7tUq1bN3I8qU6ZMnPA4efJkUzUDAokg5uUPDFKGcdYAAKRvQ4cOlUGDBnm9Pr5qWHxzxDxlyZLF/b0ORTxy5Ij750OHDkmOHDlu+OBXhy+OHz/e3QxEK2T61UWHNXrSeWfq4sWLprL25ZdfJvKbAv5FEAMAAECSeRt66CtdunQx3RELFy5s7ue1116TTz/91HyvTTh0vpg25Khbt66ULVvWBDxt+qGhzFVVS4hW07RCpo1BgEBiQWcAAAD4lTbEaNiwYbzXaZDybDevQwq1Bf2yZctMe3udE6bVL220ocMJp0+fLhUrVpRFixaZBhzffvutvP7669KiRQvJly+fuf31x9TGIEWKFDHfR0dHu+eKAYFERQwAAAB+pS3pZ82aFe912mDDs8mGatSokdmu97///c/9va4/dv0aZLpItG6u47p4DqW86667zAYEGhUxAAAAALCMIAYAAAAAlhHEAAAAAMAyghgAAAAAWEYQAwAAAADLCGIAAAAAYBlBDAAAAAAsI4gBAAAAgGUEMQAAAACwjCAGAAAAAJYRxAAAAADAMoIYAAAAAFhGEAMAAAAAywhiAAAAAGAZQQwAAAAALCOIAQAAAIBlBDEAAAAAsIwgBgAAAACWEcQAAAAAwLIQ23eI9K3z7Dm+O9iIEZI12NmfFeyNdP4/odCGj4uTfbHliDhdz+rB4nTz8jcTJyt+IUqcrmSRMuJkE/56X5yuX62+4nQTDi4SJytweJ04Xq6GgT4DIF1w9rtcAAAAAEiHCGIAAAAAYBlBDAAAAAAsI4gBAAAAgGUEMQAAAACwzPkt37TrW2ioDBw4MMW3P3bsmE/PBwAAAADSfRCLiIhI1e1TE+IAAAAAwNcYmggAAAAAlhHEAAAAAMAyghgAAAAAWEYQAwAAAADLCGIAAAAAYBlBDAAAAAAsI4gBAAAAgGUEMQAAAACwjCAGAAAAAJYRxAAAAADAMoIYAAAAAFgWYvsOAQAAkLGcOnVKJk+ebL4PCgqSrFmzyl133SXVqlVL1nE2b94sVapU8Xr9vn37ZM2aNXL//fcneqy//vpLLl++LA0bNkzWOQC+QkUMAAAAfnXs2DF5/fXX5cyZM3L69GnZs2ePNG/eXGbNmpXkYxw/flzuu+++BPeJjo6WixcvJikY3nvvvbJo0aIk3z/ga1TEAAAA4Hc5c+aUN954w/1z7dq1ZdKkSVKvXj35559/TDjKly+f3H333SawffPNN2a/tm3bSv78+U1o0xA3ZcoUefzxx+X8+fPy7bffSlRUlNmnYMGCkjlzZgkPDzdBb+fOnabytm3bNlN9u+WWW9z33bt37wQra4ANBDEAAAAk2ZUrV8zmjYYf3RITGhoqV69elR07dkiPHj2kUaNG0rRpUzlx4oRUr17dBDQ9zrBhw+TPP/80la5r166ZAKZb/fr1pWbNmuY4Wm379ddfTaCbPn26ZM+eXR566CFznOLFi8tzzz0nW7ZskTJlysiHH34opUqVkhIlSpj7AgIlQwaxoUOHSmRkZKBPI13qHegTAAAAfhURESEjR470ev3w4cNlxIgRN1yu4clVEdPq16effur+uUCBAvLFF1+4j9+mTRv54IMPzM8vvfSSvPvuu/Lss8/KRx99JIMGDZIJEyZI7ty5pVKlSmYfDVhaXWvSpIn7/rSKtnjxYjMnTe979erVJkDOmDFDlixZIhMnTvTxIwMkT4YMYhrCxo4dG+jTSJe2L1gY6FMAAAB+/kBbw5A33qphsbGxZsihBqMcOXLI7NmzzZDBhQsXmiDlosMK69Sp4/5Zq14zZ86Mc6zdu3eb+9HjqVq1aknVqlXj7FOhQgVzX0pDm1bfdEiiXv7OO+/IihUrTJVN54npfDXAtgwZxAAAAJAySR16mNgcMU/BwcHu73UooQ4jdNm0aZMUKVLEHapU0aJF5fDhw+7jLV++XGJiYkyzDpdMmW7sSdeuXTszHFEDnHZM1AqZfgUCgSAGAAAAx3jsscekRo0acunSJRP4Pv/8czP/KywszISvMWPGmDll+rVbt25mCKJW13QYonZWTMjgwYPd348bN86Esg4dOlj4rYAbEcQAAADgV9oNsW/fvvFeV7ZsWenYsaP752LFisn69evNnDGtWOl6X66hizpEUbsh6pyyjRs3mn10/tfSpUvNfLF///1XOnXqdMMxW7VqZS7zpF0bk9LqHvAXghgAAAD8SoOTzi2Lj87Z0s2TDj0cMGDADft6Vq+0XX2/fv3iXF+uXDmzuY7rEt/6Yw0aNEjBbwL4Dgs6AwAAAIBlBDEAAAAAsIwgBgAAAACWEcQAAAAAwDKCGAAAAABYRhADAAAAAMsIYgAAAABgGUEMAAAAACwjiAEAAACAZQQxAAAAALCMIAYAAAAAlhHEAAAAAMAyghgAAAAAWEYQAwAAAADLCGIAAAAAYBlBDAAAAAAsI4gBAAAAgGUEMQAAAACwLMT2HQLJkT8si6MfsKV7TovT9aycW5ysbN4wcbpc186J0xUKd/a/lZp5g8TpYsMqipNlOrVfnG7CwUXidP2KNRcnG/N5L3G68IoNA30KQLpARQwAAAAALCOIAQAAAIBlBDEAAAAAsIwgBgAAAACWEcQAAAAAwDKCGAAAAABYRhADAAAAAMsIYgAAAABgGUEMAAAAACwjiAEAAACAZQQxAAAAALAsRDKA0NBQGThwoPvnY8eOBfR8AAAAAGRsGSKIRURExPnZM5QBAAAAgG0MTQQAAAAAywhiAAAAAGAZQQwAAAAALCOIAQAAAIBlBDEAAAAAsIwgBgAAAACWZYj29QAAAAicQ4cOyaBBg8z3QUFBkjVrVmncuLE8/PDDkilT0uoCMTEx8tVXX0mnTp287rNlyxb58ccf5fnnn/e6z9q1a+Wjjz6SzJkzyxNPPCG33HJLCn4jIPWoiAEAAMCvzp07Jz/99JN06NBB2rdvL40aNZKxY8fK6NGjk3yMY8eOydChQxPcp0CBAlK/fn2v1+/evducQ6lSpaRQoUJy1113yalTp5L1uwC+QkUMAAAAfpctWzbp0qWL++c8efJIRESENG/eXFauXCl79+6VsmXLSu/evWXjxo3y8ccfm/26d+8uNWvWlDfeeEOOHj0qzz77rIwZM0Z27twpH374oURFRZnKWp06deT48ePmWDlz5jRfIyMjZdu2bdKiRQu57777TDXum2++kVq1apkK2/Tp0+XIkSOSN29eXgGwjooYAAAAkuzKlSumwuVt0+uTWuHSwHT48GEZPHiw5MiRQ8qUKWMCVrNmzaRgwYJSokQJE6LWr19vKl3h4eHStGlTOXjwoLRp00aKFy9uhhY+9NBDZsihhqply5aZYz799NOyf/9+qVy5svTo0UM2bNhgjq8hTANYpUqVTGWOoYkIFCpiSaSlcP1UBQnrzQMEAEC6plWskSNHer1++PDhMmLEiBsu1yGAroqYfv/HH3/Id999ZypaGpaGDRtmrnvllVfM3C3XzzqHbOrUqfLyyy9L9uzZpVWrVvLmm2+aOV6rV682+4SFhclnn30mrVu3dt9f9erVTeVMrVmzxlTGqlWr5r5Oz/OFF16QpUuXmiGKgG0EsSTSEKZjmZGw7QsW8hABAJDOP5x2Nd6Ijzbi8DY0Uedn6fBADU4zZsww87QWLlwohQsXdu+nVa3atWu7fy5durQJbZ50iKKGqrZt27ov03lfFy9edP9ctGhR9/ehoaFmKKJL1apVzaYVsy+//JIghoAgiAEAACDJNGh5C1vJmSPmScOZS8WKFWXJkiXy+OOPm59//vlnKVeuXJx9br75ZjPU8IEHHjAVs2nTppnOjLly5UrwHDT0afhyHVvnomkgAwKBIAYAAADH0GYdn3zyiWm+oYFPA9by5cvNfDKthPXs2VMmTZpkWtBrVUybfmijjxUrVsjff/+d4LE1dPXt29ccPzo62gyL1GMBgUAQAwAAgF8VK1ZMJk6cGO91Gqa0WYeLzgPTOV06HFEbf2hDDR1aqPRybUGvP+v1q1atkvPnz0vDhg3N7XTe2JAhQ6R8+fJxjqlzzrT5R5EiRcxaYxrssmTJIg0aNDC3AQKBIAYAAAC/0o6I7dq1i/c6nR/mOUdMaUiKr4GGDlvUTYWEhMgdd9wR53qdc6ab67gunnPOdIjkPffck8rfCEg92tcDAAAAgGUEMQAAAACwjCAGAAAAAJYRxAAAAADAMoIYAAAAAFhGEAMAAAAAywhiAAAAAGAZQQwAAAAALCOIAQAAAIBlBDEAAAAAsIwgBgAAAACWEcQAAAAAwDKCGAAAAABYRhADAAAAAMsIYgAAAABgGUEMAAAAACwjiAEAAACAZQQxAAAAALAsRDKg0NBQGThwYLJuc+zYMb+dT3oyp0tnnx1rhIgUCHf2S7THbQXF6TJdOC5O1rRMfnG6aVud/RiqluWzi5MFbZwvTnft4jlxspP1u4nTFTi8TpxuzOe9xMmefXCqON2kri8F+hSAdMHZ73L9JCIiItm3SW5wAwAAAABvGJoIAAAAAJYRxAAAAADAMoIYAAAAAFhGEAMAAAAAywhiAAAAAGAZQQwAAAAALCOIAQAAAIBlBDEAAAAAsIwgBgAAAACWEcQAAAAAwDKCGAAAAABYRhADAAAAAMsIYgAAAABgGUEMAAAAACwjiAEAAACAZQQxAAAAALCMIAYAAAAAlhHEAAAAAMAyghgAAAD8avfu3VKuXDmzlS9fXm699VZ5+umn5cKFC0k+xpUrV2T48OEJ7vPHH39I7969E9znk08+kfr168udd94pCxYsSPL9A75GEAMAAIBfRUVFycWLF2XhwoUm/MyaNUv27dsnw4YNS/IxTp8+LTNnzkxwn+rVq8vIkSO9Xv/bb7/J0KFD5ZVXXpFXX31VnnnmGdmyZUuyfhfAVwhiAAAA8Lvg4GB3VaxKlSry1FNPyfLly83Wt29fadasmbz44otmXw1cDRo0MNvHH39sLnv00Uflv//+k+bNm5ufv/32W2nUqJGpbk2ePNlctn79elM102M++eST8tBDD0mNGjVM4IuNjZWlS5dKr169pGXLlnLXXXdJjx49ZO7cuTz7CIiQwNwtAAAA0iIdIqibN1mzZjVbQlyhqGzZsqZSpsMFv/rqK/OzhiitWk2ZMsUc5/HHH5cCBQrIqFGjZOvWrebyDRs2yP/+9z8ZN26chIaGyqBBg6RIkSKSLVs2OXTokDnmRx99JJ9++qn06dNHunTpInfffbeUKFHChLzIyEjJlCmTuS+9DAgEglgS6T/ygQMH+vfZSAdy5coV6FMAAAB+FBERkeDwP61IjRgx4obLjxw5YqphrmGGefPmle+//1727t1rqlauSpcGLZ0/5vpZQ5lWvzSIZc6cWUqWLCnTpk0zt3vkkUfMPufOnZMff/xROnbs6L4/raZ17drVfK/VtoMHD5oKmQa+ggULmvcsWlHTQAYEAkEsGX90kLj4/vACAID0Q4ORVqC88VYN06qWzhELCgqSsLAwU8FSGqg0lLloAw+tjLlkz55dzp8/H+dYuo8OK9ThjS45cuSQzZs3u3/OnTt3nGGRWoXLkiWL/PDDD3LixAkJDw837+/0OiAQ+AgAAAAASaZBK2fOnF43b0HMNUfspptucoew+NSpU8cMH7x06ZJp8jF9+nRTMdPK1dWrV937LFq0yAS4MmXKyHvvvWeqa4lZsWKFPPzww5InTx5TldMhka1bt+bZR0AQxAAAAOAYGpRKlSolhQsXNkMIQ0JCTHdDDU/R0dFStWpVuf/++83QQ53fpZdv27bNPQwxIfXq1ZOzZ8+aAFehQgXT0KNWrVpWfi/gegxNBAAAgF9pFez333+P9zpdz6tatWpxKmefffaZGY6oTUHy58/vvm7Pnj1y6tQpM7xROyVqsw5tzKHDHpWGs8qVK5v5X57H1CGI2shDj/3dd9/JsWPHzNBE3YBAIYgBAADAr7TJRunSpeO9TueL6XY9nfOlmyed46WVMm+31bClm+s6F1dQc9FKGxBoDE0EAAAAAMsIYgAAAABgGUEMAAAAACwjiAEAAACAZQQxAAAAALCMIAYAAAAAlhHEAAAAAMAyghgAAAAAWEYQAwAAAADLCGIAAAAAYBlBDAAAAAAsI4gBAAAAgGUEMQAAAACwjCAGAAAAAJYRxAAAAADAMoIYAAAAAFhGEAMAAAAAywhiAAAAAGBZUGxsbKztOwUAAACAjIyKGAAAAABYRhADAAAAAMsIYgAAAABgGUEMAAAAACwjiAEAAACAZQQxAAAAALCMIAYAAAAAlhHEAAAAAMAyghgAAAAAiF3/B2OO2XKtVW+vAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "aa.AAPredPlot().clustermap(\n", + " data=data, names=names, labels=labels,\n", + " colors={1: \"tab:red\", 0: \"tab:gray\"}, cmap=\"RdBu_r\",\n", + " figsize=(8, 8), cbar_label=\"Pearson correlation (r)\",\n", + " title=\"Explanation-similarity clustering\")\n", + "plt.show()" + ] } ], "metadata": { diff --git a/examples/prediction/aapred_plot_comparison.ipynb b/examples/prediction/aapred_plot_comparison.ipynb index e03ec13f..a83d79aa 100644 --- a/examples/prediction/aapred_plot_comparison.ipynb +++ b/examples/prediction/aapred_plot_comparison.ipynb @@ -14,10 +14,10 @@ "id": "3b59d33e", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:04:45.809816Z", - "iopub.status.busy": "2026-07-02T12:04:45.809753Z", - "iopub.status.idle": "2026-07-02T12:04:47.318878Z", - "shell.execute_reply": "2026-07-02T12:04:47.318674Z" + "iopub.execute_input": "2026-07-04T13:09:30.209140Z", + "iopub.status.busy": "2026-07-04T13:09:30.209068Z", + "iopub.status.idle": "2026-07-04T13:09:31.619783Z", + "shell.execute_reply": "2026-07-04T13:09:31.619571Z" } }, "outputs": [ @@ -32,58 +32,58 @@ "data": { "text/html": [ "\n", - "\n", + "
\n", " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", "
 groupconditionvaluegroupconditionvalue
1Scale-basedSubstrate611Scale-basedSubstrate61
2Scale-basedNon-substrate602Scale-basedNon-substrate60
3CPPSubstrate713CPPSubstrate71
4CPPNon-substrate744CPPNon-substrate74
\n" @@ -123,10 +123,10 @@ "id": "6263175b", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:04:47.319967Z", - "iopub.status.busy": "2026-07-02T12:04:47.319900Z", - "iopub.status.idle": "2026-07-02T12:04:47.379095Z", - "shell.execute_reply": "2026-07-02T12:04:47.378873Z" + "iopub.execute_input": "2026-07-04T13:09:31.621031Z", + "iopub.status.busy": "2026-07-04T13:09:31.620955Z", + "iopub.status.idle": "2026-07-04T13:09:31.676515Z", + "shell.execute_reply": "2026-07-04T13:09:31.676292Z" } }, "outputs": [ @@ -148,6 +148,54 @@ "plt.tight_layout()\n", "plt.show()" ] + }, + { + "cell_type": "markdown", + "id": "pc1md001", + "metadata": {}, + "source": [ + "**Further parameters.** The full call controls bar order, colors, labels and annotations: ``group_order`` / ``condition_order`` set the ordering, ``colors`` the bar colors, ``baseline_label`` the legend text of the baseline line, ``annotate`` / ``annotation_fmt`` / ``fontsize_annotations`` the value labels, ``bar_width`` the cluster width, and ``figsize`` / ``xlabel`` / ``title`` / ``ylim`` / ``xtick_rotation`` the axes:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "pc1cd001", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-04T13:09:31.677651Z", + "iopub.status.busy": "2026-07-04T13:09:31.677587Z", + "iopub.status.idle": "2026-07-04T13:09:31.720898Z", + "shell.execute_reply": "2026-07-04T13:09:31.720643Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "aa.AAPredPlot().comparison(\n", + " df_eval, group=\"group\", condition=\"condition\", value=\"value\",\n", + " baseline=50, baseline_label=\"chance (50%)\",\n", + " annotate=True, annotation_fmt=\"{:.0f}%\",\n", + " group_order=[\"CPP\", \"Scale-based\"],\n", + " condition_order=[\"Substrate\", \"Non-substrate\"],\n", + " colors={\"CPP\": \"tab:blue\", \"Scale-based\": \"0.6\"},\n", + " bar_width=0.7, figsize=(7, 4.5),\n", + " xlabel=\"Class\", ylabel=\"Balanced accuracy [%]\",\n", + " title=\"CPP vs scale-based benchmark\",\n", + " ylim=(0, 100), fontsize_annotations=11, xtick_rotation=15)\n", + "plt.tight_layout()\n", + "plt.show()" + ] } ], "metadata": { diff --git a/examples/prediction/aapred_plot_cutoff.ipynb b/examples/prediction/aapred_plot_cutoff.ipynb index 8fbe5f6c..fdb0cf1b 100644 --- a/examples/prediction/aapred_plot_cutoff.ipynb +++ b/examples/prediction/aapred_plot_cutoff.ipynb @@ -14,10 +14,10 @@ "id": "208e5df5", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:04:48.791780Z", - "iopub.status.busy": "2026-07-02T12:04:48.791709Z", - "iopub.status.idle": "2026-07-02T12:04:50.354704Z", - "shell.execute_reply": "2026-07-02T12:04:50.354451Z" + "iopub.execute_input": "2026-07-04T13:09:43.928846Z", + "iopub.status.busy": "2026-07-04T13:09:43.928698Z", + "iopub.status.idle": "2026-07-04T13:09:45.374931Z", + "shell.execute_reply": "2026-07-04T13:09:45.374639Z" } }, "outputs": [], @@ -54,10 +54,10 @@ "id": "5ee56207", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:04:50.355972Z", - "iopub.status.busy": "2026-07-02T12:04:50.355905Z", - "iopub.status.idle": "2026-07-02T12:04:50.407851Z", - "shell.execute_reply": "2026-07-02T12:04:50.407627Z" + "iopub.execute_input": "2026-07-04T13:09:45.376251Z", + "iopub.status.busy": "2026-07-04T13:09:45.376182Z", + "iopub.status.idle": "2026-07-04T13:09:45.424322Z", + "shell.execute_reply": "2026-07-04T13:09:45.424109Z" } }, "outputs": [ @@ -80,6 +80,46 @@ "plt.tight_layout()\n", "plt.show()" ] + }, + { + "cell_type": "markdown", + "id": "pf1md001", + "metadata": {}, + "source": [ + "**Further parameters.** ``scores`` are the per-sample scores; ``n_steps`` sets the cutoff resolution, ``color`` the line color, and ``figsize`` / ``xlabel`` / ``ylabel`` the axes:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "pf1cd001", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-04T13:09:45.425416Z", + "iopub.status.busy": "2026-07-04T13:09:45.425353Z", + "iopub.status.idle": "2026-07-04T13:09:45.452185Z", + "shell.execute_reply": "2026-07-04T13:09:45.451986Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "aapred_plot.cutoff(scores=pred, n_steps=51, color=\"tab:blue\", figsize=(6, 4),\n", + " xlabel=\"Score cutoff\", ylabel=\"Samples above cutoff [%]\",\n", + " thresholds=[0.5])\n", + "plt.tight_layout()\n", + "plt.show()" + ] } ], "metadata": { diff --git a/examples/prediction/aapred_plot_domain.ipynb b/examples/prediction/aapred_plot_domain.ipynb index a9994355..75a2e907 100644 --- a/examples/prediction/aapred_plot_domain.ipynb +++ b/examples/prediction/aapred_plot_domain.ipynb @@ -14,10 +14,10 @@ "id": "9e2bef6f", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:04:52.021400Z", - "iopub.status.busy": "2026-07-02T12:04:52.021322Z", - "iopub.status.idle": "2026-07-02T12:04:53.703335Z", - "shell.execute_reply": "2026-07-02T12:04:53.703081Z" + "iopub.execute_input": "2026-07-04T13:09:46.845127Z", + "iopub.status.busy": "2026-07-04T13:09:46.844930Z", + "iopub.status.idle": "2026-07-04T13:09:48.431526Z", + "shell.execute_reply": "2026-07-04T13:09:48.431208Z" } }, "outputs": [], @@ -54,10 +54,10 @@ "id": "c5cc358a", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:04:53.704694Z", - "iopub.status.busy": "2026-07-02T12:04:53.704624Z", - "iopub.status.idle": "2026-07-02T12:04:53.758827Z", - "shell.execute_reply": "2026-07-02T12:04:53.758601Z" + "iopub.execute_input": "2026-07-04T13:09:48.432810Z", + "iopub.status.busy": "2026-07-04T13:09:48.432744Z", + "iopub.status.idle": "2026-07-04T13:09:48.482858Z", + "shell.execute_reply": "2026-07-04T13:09:48.482640Z" } }, "outputs": [ @@ -80,6 +80,45 @@ "plt.tight_layout()\n", "plt.show()" ] + }, + { + "cell_type": "markdown", + "id": "pdm1md01", + "metadata": {}, + "source": [ + "**Further parameters.** ``color`` sets the line color and ``figsize`` / ``xlabel`` / ``ylabel`` the axes:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "pdm1cd01", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-04T13:09:48.483948Z", + "iopub.status.busy": "2026-07-04T13:09:48.483891Z", + "iopub.status.idle": "2026-07-04T13:09:48.514146Z", + "shell.execute_reply": "2026-07-04T13:09:48.513939Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "aapred_plot.domain(df_domain, color=\"tab:green\", figsize=(6, 4.5),\n", + " xlabel=\"Boundary offset [residues]\", ylabel=\"Prediction score\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] } ], "metadata": { diff --git a/examples/prediction/aapred_plot_eval.ipynb b/examples/prediction/aapred_plot_eval.ipynb index bd440e6e..ef78251b 100644 --- a/examples/prediction/aapred_plot_eval.ipynb +++ b/examples/prediction/aapred_plot_eval.ipynb @@ -14,10 +14,10 @@ "id": "c99cddcb", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:04:55.270154Z", - "iopub.status.busy": "2026-07-02T12:04:55.270079Z", - "iopub.status.idle": "2026-07-02T12:04:57.606699Z", - "shell.execute_reply": "2026-07-02T12:04:57.606449Z" + "iopub.execute_input": "2026-07-04T14:50:50.455316Z", + "iopub.status.busy": "2026-07-04T14:50:50.454888Z", + "iopub.status.idle": "2026-07-04T14:50:52.610649Z", + "shell.execute_reply": "2026-07-04T14:50:52.610340Z" } }, "outputs": [], @@ -55,10 +55,10 @@ "id": "7e62d418", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:04:57.608159Z", - "iopub.status.busy": "2026-07-02T12:04:57.608081Z", - "iopub.status.idle": "2026-07-02T12:04:57.675689Z", - "shell.execute_reply": "2026-07-02T12:04:57.675446Z" + "iopub.execute_input": "2026-07-04T14:50:52.611964Z", + "iopub.status.busy": "2026-07-04T14:50:52.611901Z", + "iopub.status.idle": "2026-07-04T14:50:52.673492Z", + "shell.execute_reply": "2026-07-04T14:50:52.673259Z" } }, "outputs": [ @@ -81,6 +81,132 @@ "plt.tight_layout()\n", "plt.show()" ] + }, + { + "cell_type": "markdown", + "id": "pe1md001", + "metadata": {}, + "source": [ + "**Further parameters.** Set the figure size, the y-axis label, and a chance line:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "pe1cd001", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-04T14:50:52.674563Z", + "iopub.status.busy": "2026-07-04T14:50:52.674503Z", + "iopub.status.idle": "2026-07-04T14:50:52.710611Z", + "shell.execute_reply": "2026-07-04T14:50:52.710407Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "aapred_plot.eval(df_eval, figsize=(7, 4), ylabel=\"Score [0-1]\", baseline=0.5)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "pe1md002", + "metadata": {}, + "source": [ + "Comparing several **methods**: pass multiple models so each becomes a colored bar (the hue), recolored via ``dict_color``. (To compare CPP *parameter combinations* instead, use the feature-optimization protocol ``aap.find_features`` and its heatmap ``aap.plot_eval``.)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "pe1cd002", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-04T14:50:52.711666Z", + "iopub.status.busy": "2026-07-04T14:50:52.711604Z", + "iopub.status.idle": "2026-07-04T14:50:53.496242Z", + "shell.execute_reply": "2026-07-04T14:50:53.495944Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n", + "/Users/stephanbreimann/Programming/1Packages/aaanalysis/.venv/lib/python3.13/site-packages/sklearn/svm/_base.py:239: FutureWarning: The `probability` parameter was deprecated in 1.9 and will be removed in version 1.11. Use `CalibratedClassifierCV(SVC(), ensemble=False)` instead of `SVC(probability=True)`\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "aapred = aa.AAPred(models=[\"svm\", \"rf\"], random_state=42)\n", + "df_eval_multi = aapred.eval(X_tr, y_tr)\n", + "model_names = df_eval_multi[\"model\"].unique()\n", + "aapred_plot.eval(df_eval_multi,\n", + " dict_color={model_names[0]: \"tab:blue\", model_names[1]: \"tab:green\"})\n", + "plt.tight_layout()\n", + "plt.show()" + ] } ], "metadata": { diff --git a/examples/prediction/aapred_plot_hist.ipynb b/examples/prediction/aapred_plot_hist.ipynb index 55c3a552..cee345bc 100644 --- a/examples/prediction/aapred_plot_hist.ipynb +++ b/examples/prediction/aapred_plot_hist.ipynb @@ -14,10 +14,10 @@ "id": "bfe819f2", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:04:59.313025Z", - "iopub.status.busy": "2026-07-02T12:04:59.312959Z", - "iopub.status.idle": "2026-07-02T12:05:00.877745Z", - "shell.execute_reply": "2026-07-02T12:05:00.877437Z" + "iopub.execute_input": "2026-07-04T13:10:43.458914Z", + "iopub.status.busy": "2026-07-04T13:10:43.458523Z", + "iopub.status.idle": "2026-07-04T13:10:44.893005Z", + "shell.execute_reply": "2026-07-04T13:10:44.892730Z" } }, "outputs": [], @@ -55,10 +55,10 @@ "id": "b46daeac", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:05:00.879220Z", - "iopub.status.busy": "2026-07-02T12:05:00.879125Z", - "iopub.status.idle": "2026-07-02T12:05:00.947804Z", - "shell.execute_reply": "2026-07-02T12:05:00.947558Z" + "iopub.execute_input": "2026-07-04T13:10:44.894326Z", + "iopub.status.busy": "2026-07-04T13:10:44.894259Z", + "iopub.status.idle": "2026-07-04T13:10:44.954239Z", + "shell.execute_reply": "2026-07-04T13:10:44.954022Z" } }, "outputs": [ @@ -81,6 +81,47 @@ "plt.tight_layout()\n", "plt.show()" ] + }, + { + "cell_type": "markdown", + "id": "ph1md001", + "metadata": {}, + "source": [ + "**Further parameters.** ``scores`` are the per-sample scores; ``bins`` sets the number of histogram bins, ``dict_color`` the per-class colors, and ``figsize`` / ``xlabel`` / ``ylabel`` the axes:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ph1cd001", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-04T13:10:44.955336Z", + "iopub.status.busy": "2026-07-04T13:10:44.955274Z", + "iopub.status.idle": "2026-07-04T13:10:44.990635Z", + "shell.execute_reply": "2026-07-04T13:10:44.990422Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "aapred_plot.hist(scores=pred, labels=labels, bins=15,\n", + " dict_color={1: \"tab:red\", 0: \"tab:gray\"}, figsize=(6, 4),\n", + " xlabel=\"Prediction score\", ylabel=\"Number of samples\",\n", + " thresholds=[0.5])\n", + "plt.tight_layout()\n", + "plt.show()" + ] } ], "metadata": { diff --git a/examples/prediction/aapred_plot_ranking.ipynb b/examples/prediction/aapred_plot_ranking.ipynb index a3dad307..ce033d03 100644 --- a/examples/prediction/aapred_plot_ranking.ipynb +++ b/examples/prediction/aapred_plot_ranking.ipynb @@ -14,10 +14,10 @@ "id": "58de3fde", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:05:02.579069Z", - "iopub.status.busy": "2026-07-02T12:05:02.578997Z", - "iopub.status.idle": "2026-07-02T12:05:04.107832Z", - "shell.execute_reply": "2026-07-02T12:05:04.107627Z" + "iopub.execute_input": "2026-07-04T13:09:52.882688Z", + "iopub.status.busy": "2026-07-04T13:09:52.882567Z", + "iopub.status.idle": "2026-07-04T13:09:54.304588Z", + "shell.execute_reply": "2026-07-04T13:09:54.304342Z" } }, "outputs": [ @@ -32,105 +32,105 @@ "data": { "text/html": [ "\n", - "\n", + "
\n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", "
 namescoregroupstdnamescoregroupstd
1Gene054.923699Substrate1.3485171Gene054.923699Substrate1.348517
2Gene157.537562Non-substrate1.0808742Gene157.537562Non-substrate1.080874
3Gene258.443169Non-substrate4.3304793Gene258.443169Non-substrate4.330479
4Gene365.417407Substrate4.1126274Gene365.417407Substrate4.112627
5Gene465.672878Substrate4.4800495Gene465.672878Substrate4.480049
6Gene569.179619Non-substrate4.9144736Gene569.179619Non-substrate4.914473
7Gene671.983117Non-substrate4.1966347Gene671.983117Non-substrate4.196634
8Gene776.487309Non-substrate2.8459178Gene776.487309Non-substrate2.845917
9Gene887.965245Non-substrate4.1221179Gene887.965245Non-substrate4.122117
10Gene992.638079Substrate1.47309810Gene992.638079Substrate1.473098
\n" @@ -173,10 +173,10 @@ "id": "a75842ab", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:05:04.108991Z", - "iopub.status.busy": "2026-07-02T12:05:04.108923Z", - "iopub.status.idle": "2026-07-02T12:05:04.174445Z", - "shell.execute_reply": "2026-07-02T12:05:04.174235Z" + "iopub.execute_input": "2026-07-04T13:09:54.305684Z", + "iopub.status.busy": "2026-07-04T13:09:54.305626Z", + "iopub.status.idle": "2026-07-04T13:09:54.366878Z", + "shell.execute_reply": "2026-07-04T13:09:54.366661Z" } }, "outputs": [ @@ -199,6 +199,48 @@ "plt.tight_layout()\n", "plt.show()" ] + }, + { + "cell_type": "markdown", + "id": "pr1md001", + "metadata": {}, + "source": [ + "**Further parameters.** ``col_name`` / ``col_score`` name the label and score columns, ``colors`` maps each class to a color, ``top_n`` keeps only the best candidates, ``ascending`` sets the sort direction, and ``figsize`` / ``title`` the axes:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "pr1cd001", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-04T13:09:54.368038Z", + "iopub.status.busy": "2026-07-04T13:09:54.367979Z", + "iopub.status.idle": "2026-07-04T13:09:54.407306Z", + "shell.execute_reply": "2026-07-04T13:09:54.407093Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "aa.AAPredPlot().ranking(\n", + " df_pred, col_name=\"name\", col_score=\"score\", col_group=\"group\", col_std=\"std\",\n", + " colors={\"Substrate\": \"tab:red\", \"Non-substrate\": \"0.6\"},\n", + " cutoffs=(50, 80), top_n=8, ascending=False, figsize=(5, 4),\n", + " xlabel=\"Substrate prediction score [%]\", title=\"Top candidates\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] } ], "metadata": { diff --git a/examples/prediction/aapred_plot_scatter.ipynb b/examples/prediction/aapred_plot_scatter.ipynb index 1679095d..72fc3fd4 100644 --- a/examples/prediction/aapred_plot_scatter.ipynb +++ b/examples/prediction/aapred_plot_scatter.ipynb @@ -14,10 +14,10 @@ "id": "6023f9c9", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:05:05.796385Z", - "iopub.status.busy": "2026-07-02T12:05:05.796322Z", - "iopub.status.idle": "2026-07-02T12:05:07.441072Z", - "shell.execute_reply": "2026-07-02T12:05:07.440801Z" + "iopub.execute_input": "2026-07-04T13:10:46.267264Z", + "iopub.status.busy": "2026-07-04T13:10:46.266922Z", + "iopub.status.idle": "2026-07-04T13:10:47.750031Z", + "shell.execute_reply": "2026-07-04T13:10:47.749753Z" } }, "outputs": [], @@ -57,10 +57,10 @@ "id": "a5e1db74", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:05:07.442343Z", - "iopub.status.busy": "2026-07-02T12:05:07.442272Z", - "iopub.status.idle": "2026-07-02T12:05:07.501902Z", - "shell.execute_reply": "2026-07-02T12:05:07.501641Z" + "iopub.execute_input": "2026-07-04T13:10:47.751336Z", + "iopub.status.busy": "2026-07-04T13:10:47.751269Z", + "iopub.status.idle": "2026-07-04T13:10:47.804833Z", + "shell.execute_reply": "2026-07-04T13:10:47.804637Z" } }, "outputs": [ @@ -84,6 +84,47 @@ "plt.tight_layout()\n", "plt.show()" ] + }, + { + "cell_type": "markdown", + "id": "pst1md01", + "metadata": {}, + "source": [ + "**Further parameters.** ``scores_x`` / ``scores_y`` are the two predictors' scores; ``dict_color`` sets the per-class colors, ``marker_size`` the point size, ``diagonal`` toggles the ``y = x`` line, and ``figsize`` sizes the figure:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "pst1cd01", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-04T13:10:47.805935Z", + "iopub.status.busy": "2026-07-04T13:10:47.805876Z", + "iopub.status.idle": "2026-07-04T13:10:47.837710Z", + "shell.execute_reply": "2026-07-04T13:10:47.837514Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "aapred_plot.scatter(scores_x=pred_1, scores_y=pred_2, labels=labels,\n", + " dict_color={1: \"tab:red\", 0: \"tab:gray\"}, marker_size=40,\n", + " diagonal=True, figsize=(5.5, 5.5),\n", + " xlabel=\"Predictor 1 score\", ylabel=\"Predictor 2 score\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] } ], "metadata": { diff --git a/examples/prediction/aapred_plot_window.ipynb b/examples/prediction/aapred_plot_window.ipynb index 35b184e5..58b844f8 100644 --- a/examples/prediction/aapred_plot_window.ipynb +++ b/examples/prediction/aapred_plot_window.ipynb @@ -14,10 +14,10 @@ "id": "9fd8d1bc", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:05:08.918787Z", - "iopub.status.busy": "2026-07-02T12:05:08.918716Z", - "iopub.status.idle": "2026-07-02T12:05:10.507947Z", - "shell.execute_reply": "2026-07-02T12:05:10.507709Z" + "iopub.execute_input": "2026-07-04T13:09:58.815970Z", + "iopub.status.busy": "2026-07-04T13:09:58.815559Z", + "iopub.status.idle": "2026-07-04T13:10:00.317909Z", + "shell.execute_reply": "2026-07-04T13:10:00.317620Z" } }, "outputs": [], @@ -57,10 +57,10 @@ "id": "2fabc0ca", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:05:10.509241Z", - "iopub.status.busy": "2026-07-02T12:05:10.509166Z", - "iopub.status.idle": "2026-07-02T12:05:10.566568Z", - "shell.execute_reply": "2026-07-02T12:05:10.566337Z" + "iopub.execute_input": "2026-07-04T13:10:00.319276Z", + "iopub.status.busy": "2026-07-04T13:10:00.319210Z", + "iopub.status.idle": "2026-07-04T13:10:00.374247Z", + "shell.execute_reply": "2026-07-04T13:10:00.374002Z" } }, "outputs": [ @@ -83,6 +83,50 @@ "plt.tight_layout()\n", "plt.show()" ] + }, + { + "cell_type": "markdown", + "id": "pwn1md01", + "metadata": {}, + "source": [ + "**Further parameters.** ``list_annotations`` adds per-residue annotation tracks (topology, pLDDT, domains, ...) below the profile as color strips; ``color`` sets the line color and ``figsize`` / ``xlabel`` / ``ylabel`` the axes:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "pwn1cd01", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-04T13:10:00.375372Z", + "iopub.status.busy": "2026-07-04T13:10:00.375290Z", + "iopub.status.idle": "2026-07-04T13:10:00.421576Z", + "shell.execute_reply": "2026-07-04T13:10:00.421366Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "n_pos = len(df_window) # positions of the single plotted entry (P05067)\n", + "list_annotations = [{\"values\": np.linspace(0, 1, n_pos), \"label\": \"pLDDT\",\n", + " \"cmap\": \"viridis\"}]\n", + "aapred_plot.window(df_window, list_annotations=list_annotations, threshold=0.75,\n", + " color=\"tab:green\", figsize=(10, 4.5),\n", + " xlabel=\"Residue position\", ylabel=\"Prediction score\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] } ], "metadata": { diff --git a/examples/prediction/aapred_predict_domain.ipynb b/examples/prediction/aapred_predict_domain.ipynb index 3681cd4c..dcdefb66 100644 --- a/examples/prediction/aapred_predict_domain.ipynb +++ b/examples/prediction/aapred_predict_domain.ipynb @@ -14,17 +14,17 @@ "id": "a02cd9a0", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:05:15.189250Z", - "iopub.status.busy": "2026-07-02T12:05:15.189187Z", - "iopub.status.idle": "2026-07-02T12:05:16.766292Z", - "shell.execute_reply": "2026-07-02T12:05:16.766001Z" + "iopub.execute_input": "2026-07-04T13:09:19.698047Z", + "iopub.status.busy": "2026-07-04T13:09:19.697852Z", + "iopub.status.idle": "2026-07-04T13:09:21.153737Z", + "shell.execute_reply": "2026-07-04T13:09:21.153502Z" } }, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 1, @@ -63,10 +63,10 @@ "id": "94c928a9", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:05:16.767510Z", - "iopub.status.busy": "2026-07-02T12:05:16.767434Z", - "iopub.status.idle": "2026-07-02T12:05:16.906762Z", - "shell.execute_reply": "2026-07-02T12:05:16.906505Z" + "iopub.execute_input": "2026-07-04T13:09:21.154966Z", + "iopub.status.busy": "2026-07-04T13:09:21.154893Z", + "iopub.status.idle": "2026-07-04T13:09:21.284367Z", + "shell.execute_reply": "2026-07-04T13:09:21.284139Z" } }, "outputs": [ @@ -81,84 +81,84 @@ "data": { "text/html": [ "\n", - "\n", + "
\n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", "
 entryoffsetscoreis_bestentryoffsetscoreis_best
1P05067-30.270000False1P05067-30.270000False
2P05067-20.790000False2P05067-20.790000False
3P05067-10.730000False3P05067-10.730000False
4P0506700.960000True4P0506700.960000True
5P0506710.840000False5P0506710.840000False
6P0506720.530000False6P0506720.530000False
7P0506730.450000False7P0506730.450000False
\n" @@ -175,6 +175,134 @@ "df_domain = aapred.predict_domain(df_seq[df_seq[\"entry\"] == \"P05067\"], window=3)\n", "aa.display_df(df_domain, n_rows=10, show_shape=True)" ] + }, + { + "cell_type": "markdown", + "id": "pd1md001", + "metadata": {}, + "source": [ + "**Further parameters.** ``list_parts`` selects which sequence parts are built for featurization (defaults to the standard CPP parts):" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "pd1cd001", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-04T13:09:21.285468Z", + "iopub.status.busy": "2026-07-04T13:09:21.285401Z", + "iopub.status.idle": "2026-07-04T13:09:21.392983Z", + "shell.execute_reply": "2026-07-04T13:09:21.392740Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataFrame shape: (7, 4)\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 entryoffsetscoreis_best
1P05067-30.270000False
2P05067-20.790000False
3P05067-10.730000False
4P0506700.960000True
5P0506710.840000False
6P0506720.530000False
7P0506730.450000False
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_domain = aapred.predict_domain(df_seq[df_seq[\"entry\"] == \"P05067\"],\n", + " window=3, list_parts=[\"tmd\", \"jmd_n_tmd_n\", \"tmd_c_jmd_c\"])\n", + "aa.display_df(df_domain, n_rows=10, show_shape=True)" + ] } ], "metadata": { diff --git a/examples/prediction/aapred_predict_seq.ipynb b/examples/prediction/aapred_predict_seq.ipynb index ee2891e2..a208c287 100644 --- a/examples/prediction/aapred_predict_seq.ipynb +++ b/examples/prediction/aapred_predict_seq.ipynb @@ -14,17 +14,17 @@ "id": "75cb1ed8", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:05:21.737635Z", - "iopub.status.busy": "2026-07-02T12:05:21.737563Z", - "iopub.status.idle": "2026-07-02T12:05:23.288096Z", - "shell.execute_reply": "2026-07-02T12:05:23.287841Z" + "iopub.execute_input": "2026-07-04T13:09:16.812899Z", + "iopub.status.busy": "2026-07-04T13:09:16.812530Z", + "iopub.status.idle": "2026-07-04T13:09:18.256571Z", + "shell.execute_reply": "2026-07-04T13:09:18.256325Z" } }, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 1, @@ -63,10 +63,10 @@ "id": "dd5b0c00", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:05:23.289270Z", - "iopub.status.busy": "2026-07-02T12:05:23.289201Z", - "iopub.status.idle": "2026-07-02T12:05:23.332446Z", - "shell.execute_reply": "2026-07-02T12:05:23.332220Z" + "iopub.execute_input": "2026-07-04T13:09:18.257755Z", + "iopub.status.busy": "2026-07-04T13:09:18.257692Z", + "iopub.status.idle": "2026-07-04T13:09:18.297036Z", + "shell.execute_reply": "2026-07-04T13:09:18.296786Z" } }, "outputs": [ @@ -81,94 +81,94 @@ "data": { "text/html": [ "\n", - "\n", + "
\n", " \n", " \n", " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", "
 entryscorescore_stdentryscorescore_std
1P050670.9600000.0000001P050670.9600000.000000
2P149250.9400000.0000002P149250.9400000.000000
3P701800.9700000.0000003P701800.9700000.000000
4Q031570.9900000.0000004Q031570.9900000.000000
5Q064811.0000000.0000005Q064811.0000000.000000
6P356130.9400000.0000006P356130.9400000.000000
7P350700.6300000.0000007P350700.6300000.000000
8P098030.9900000.0000008P098030.9900000.000000
9P190221.0000000.0000009P190221.0000000.000000
10P160700.9300000.00000010P160700.9300000.000000
\n" @@ -185,6 +185,143 @@ "df_pred = aapred.predict_seq(df_seq.head(10))\n", "aa.display_df(df_pred, n_rows=10, show_shape=True)" ] + }, + { + "cell_type": "markdown", + "id": "ps1md001", + "metadata": {}, + "source": [ + "**Further parameters.** ``list_parts`` selects which sequence parts are built for featurization (defaults to the standard CPP parts):" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ps1cd001", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-04T13:09:18.298125Z", + "iopub.status.busy": "2026-07-04T13:09:18.298063Z", + "iopub.status.idle": "2026-07-04T13:09:18.316563Z", + "shell.execute_reply": "2026-07-04T13:09:18.316382Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataFrame shape: (10, 3)\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 entryscorescore_std
1P050670.9600000.000000
2P149250.9400000.000000
3P701800.9700000.000000
4Q031570.9900000.000000
5Q064811.0000000.000000
6P356130.9400000.000000
7P350700.6300000.000000
8P098030.9900000.000000
9P190221.0000000.000000
10P160700.9300000.000000
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_pred = aapred.predict_seq(df_seq.head(10), list_parts=[\"tmd\", \"jmd_n_tmd_n\", \"tmd_c_jmd_c\"])\n", + "aa.display_df(df_pred, n_rows=10, show_shape=True)" + ] } ], "metadata": { diff --git a/examples/prediction/aapred_predict_window.ipynb b/examples/prediction/aapred_predict_window.ipynb index 70bd94aa..c69ef9a1 100644 --- a/examples/prediction/aapred_predict_window.ipynb +++ b/examples/prediction/aapred_predict_window.ipynb @@ -14,17 +14,17 @@ "id": "784c0c5b", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:05:24.752695Z", - "iopub.status.busy": "2026-07-02T12:05:24.752624Z", - "iopub.status.idle": "2026-07-02T12:05:26.319691Z", - "shell.execute_reply": "2026-07-02T12:05:26.319445Z" + "iopub.execute_input": "2026-07-04T13:09:22.781052Z", + "iopub.status.busy": "2026-07-04T13:09:22.780929Z", + "iopub.status.idle": "2026-07-04T13:09:24.228522Z", + "shell.execute_reply": "2026-07-04T13:09:24.228314Z" } }, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 1, @@ -63,10 +63,10 @@ "id": "29e5c4e5", "metadata": { "execution": { - "iopub.execute_input": "2026-07-02T12:05:26.320884Z", - "iopub.status.busy": "2026-07-02T12:05:26.320813Z", - "iopub.status.idle": "2026-07-02T12:05:26.368146Z", - "shell.execute_reply": "2026-07-02T12:05:26.367918Z" + "iopub.execute_input": "2026-07-04T13:09:24.229627Z", + "iopub.status.busy": "2026-07-04T13:09:24.229567Z", + "iopub.status.idle": "2026-07-04T13:09:24.271736Z", + "shell.execute_reply": "2026-07-04T13:09:24.271531Z" } }, "outputs": [ @@ -81,105 +81,105 @@ "data": { "text/html": [ "\n", - "\n", + "
\n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", "
 entrypositionscorescore_stdentrypositionscorescore_std
1P05067220.2900000.0000001P05067220.2900000.000000
2P05067270.2700000.0000002P05067270.2700000.000000
3P05067320.0400000.0000003P05067320.0400000.000000
4P05067370.1000000.0000004P05067370.1000000.000000
5P05067420.1200000.0000005P05067420.1200000.000000
6P05067470.0200000.0000006P05067470.0200000.000000
7P05067520.1200000.0000007P05067520.1200000.000000
8P05067570.0700000.0000008P05067570.0700000.000000
9P05067620.0700000.0000009P05067620.0700000.000000
10P05067670.2500000.00000010P05067670.2500000.000000
\n" @@ -199,6 +199,156 @@ " tmd_len=tmd_len, step=5)\n", "aa.display_df(df_window, n_rows=10, show_shape=True)" ] + }, + { + "cell_type": "markdown", + "id": "pw1md001", + "metadata": {}, + "source": [ + "**Further parameters.** ``jmd_n_len`` / ``jmd_c_len`` set the flanking region required around each window, and ``list_parts`` selects which sequence parts are built for featurization:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "pw1cd001", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-04T13:09:24.272772Z", + "iopub.status.busy": "2026-07-04T13:09:24.272714Z", + "iopub.status.idle": "2026-07-04T13:09:24.293316Z", + "shell.execute_reply": "2026-07-04T13:09:24.293134Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataFrame shape: (146, 4)\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 entrypositionscorescore_std
1P05067220.2900000.000000
2P05067270.2700000.000000
3P05067320.0400000.000000
4P05067370.1000000.000000
5P05067420.1200000.000000
6P05067470.0200000.000000
7P05067520.1200000.000000
8P05067570.0700000.000000
9P05067620.0700000.000000
10P05067670.2500000.000000
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_window = aapred.predict_window(df_seq[df_seq[\"entry\"] == \"P05067\"][[\"entry\", \"sequence\"]],\n", + " tmd_len=tmd_len, step=5,\n", + " jmd_n_len=10, jmd_c_len=10, list_parts=[\"tmd\", \"jmd_n_tmd_n\", \"tmd_c_jmd_c\"])\n", + "aa.display_df(df_window, n_rows=10, show_shape=True)" + ] } ], "metadata": { diff --git a/tests/unit/api_tests/notebook_param_coverage_baseline.txt b/tests/unit/api_tests/notebook_param_coverage_baseline.txt new file mode 100644 index 00000000..87373695 --- /dev/null +++ b/tests/unit/api_tests/notebook_param_coverage_baseline.txt @@ -0,0 +1,259 @@ +# Known undemonstrated example-notebook params (backlog to burn down; NEVER add rows). +# Enforced by test_notebook_param_coverage.py. Prediction notebooks are excluded (held to zero). +AAMut::run::scales +AAMutPlot::aa_comparison::figsize +AAMutPlot::scale_ranking::color +AAMutPlot::scale_ranking::figsize +AAMutPlot::substitution_matrix::cmap +AAMutPlot::substitution_matrix::figsize +AAWindowSampler::sample_different_protein::context_out +AAWindowSampler::sample_different_protein::label_test +AAWindowSampler::sample_motif_matched::aa_context_col +AAWindowSampler::sample_motif_matched::context_in +AAWindowSampler::sample_motif_matched::context_out +AAWindowSampler::sample_motif_matched::label_ref +AAWindowSampler::sample_motif_matched::label_test +AAWindowSampler::sample_same_protein::context_out +AAWindowSampler::sample_same_protein::label_test +AAWindowSampler::sample_same_protein::max_distance_to_pos +AAWindowSampler::sample_synthetic::pos_col +AAclust::__init__::random_state +AAclust::__init__::verbose +AAclust::comp_medoids::metric +AAclustPlot::__init__::random_state +AAclustPlot::__init__::verbose +AAclustPlot::correlation::ytick_label_rotation +AAclustPlot::eval::figsize +AAlogoPlot::multi_logo::fontsize_labels +AAlogoPlot::multi_logo::logo_font_name +AAlogoPlot::multi_logo::logo_stack_order +AAlogoPlot::multi_logo::logo_vpad +AAlogoPlot::multi_logo::logo_vsep +AAlogoPlot::multi_logo::logo_width +AAlogoPlot::multi_logo::name_data_fontsize +AAlogoPlot::multi_logo::xtick_length +AAlogoPlot::multi_logo::xtick_size +AAlogoPlot::multi_logo::xtick_width +AAlogoPlot::single_logo::fontsize_labels +AAlogoPlot::single_logo::logo_font_name +AAlogoPlot::single_logo::logo_vpad +AAlogoPlot::single_logo::logo_vsep +AAlogoPlot::single_logo::logo_width +AAlogoPlot::single_logo::name_data_color +AAlogoPlot::single_logo::name_data_fontsize +AAlogoPlot::single_logo::xtick_length +AAlogoPlot::single_logo::xtick_width +AnnotationPreprocessor::build_cat::dim_names_override +AnnotationPreprocessor::build_scales::dim_names_override +AnnotationPreprocessor::build_scales::return_std +AnnotationPreprocessor::encode::on_mismatch +AnnotationPreprocessor::encode::return_df +AnnotationPreprocessor::fetch_uniprot::max_workers +AnnotationPreprocessor::fetch_uniprot::timeout +AnnotationPreprocessor::register_feature::normalization +AnnotationPreprocessor::to_df_seq::aa_context_col +AnnotationPreprocessor::to_df_seq::exclude_other_annotations +AnnotationPreprocessor::to_df_seq::match_residue_type +AnnotationPreprocessor::to_df_seq::pos_col +CPP::eval::label_test +CPP::eval::min_th +CPP::eval::n_jobs +CPP::run::jmd_c_len +CPP::run::jmd_n_len +CPP::run::n_batches +CPP::run::n_pre_filter +CPP::run::n_sample_batches +CPP::run_num::dict_num_parts +CPP::run_num::jmd_c_len +CPP::run_num::jmd_n_len +CPP::run_num::n_batches +CPP::run_num::n_pre_filter +CPP::run_num::n_sample_batches +CPP::simplify::allow_drop +CPPGrid::eval::ascending +CPPGrid::run::params_parts +CPPGrid::run::params_scales +CPPGrid::run::params_split +CPPPlot::__init__::accept_gaps +CPPPlot::__init__::verbose +CPPPlot::feature::label_ref +CPPPlot::feature::label_test +CPPPlot::feature_map::cbar_pct +CPPPlot::feature_map::imp_bar_label_type +CPPPlot::heatmap::cbar_pct +CPPPlot::profile::weight_tmd_jmd +CPPPlot::ranking::figsize +CPPStructurePlot::__init__::df_scales +CPPStructurePlot::explore::chain +CPPStructurePlot::explore::col_imp +CPPStructurePlot::explore::col_val +CPPStructurePlot::explore::focus_region +CPPStructurePlot::explore::n_jobs +CPPStructurePlot::explore::normalize_by_span +CPPStructurePlot::explore::pdb +CPPStructurePlot::explore::shap_plot +CPPStructurePlot::interactive::chain +CPPStructurePlot::interactive::col_val +CPPStructurePlot::interactive::focus_region +CPPStructurePlot::interactive::pdb +CPPStructurePlot::interactive::shap_plot +CPPStructurePlot::map_structure::chain +CPPStructurePlot::map_structure::normalize_by_span +CPPStructurePlot::map_structure::pdb +CPPStructurePlot::map_structure::sequence +CPPStructurePlot::map_structure::size_by_impact +CPPStructurePlot::plot_combined::chain +CPPStructurePlot::plot_combined::col_val +CPPStructurePlot::plot_combined::feature_map_kws +CPPStructurePlot::plot_combined::focus_region +CPPStructurePlot::plot_combined::jmd_c_seq +CPPStructurePlot::plot_combined::jmd_n_seq +CPPStructurePlot::plot_combined::pdb +CPPStructurePlot::plot_combined::sequence +CPPStructurePlot::plot_combined::shap_plot +CPPStructurePlot::plot_combined::tmd_seq +CPPStructurePlot::plot_linked::chain +CPPStructurePlot::plot_linked::col_val +CPPStructurePlot::plot_linked::feature_map_dpi +CPPStructurePlot::plot_linked::feature_map_kws +CPPStructurePlot::plot_linked::focus_region +CPPStructurePlot::plot_linked::jmd_c_seq +CPPStructurePlot::plot_linked::jmd_n_seq +CPPStructurePlot::plot_linked::pdb +CPPStructurePlot::plot_linked::sequence +CPPStructurePlot::plot_linked::shap_plot +CPPStructurePlot::plot_linked::tmd_seq +EmbeddingPreprocessor::build_cat::df_stds +EmbeddingPreprocessor::build_cat::metric +EmbeddingPreprocessor::build_cat::random_state +EmbeddingPreprocessor::build_scales::return_std +EmbeddingPreprocessor::encode::clip +EmbeddingPreprocessor::encode::return_df +EmbeddingPreprocessor::fetch_embeddings::allow_oversized +EmbeddingPreprocessor::fetch_embeddings::batch_size +EmbeddingPreprocessor::fetch_embeddings::device +EmbeddingPreprocessor::fetch_embeddings::layer +EmbeddingPreprocessor::fetch_embeddings::max_length +EmbeddingPreprocessor::fetch_embeddings::on_failure +EmbeddingPreprocessor::fetch_embeddings::source +NumericalFeature::get_parts::all_parts +NumericalFeature::get_parts::jmd_c_len +NumericalFeature::get_parts::jmd_n_len +NumericalFeature::get_parts::list_parts +NumericalFeature::get_parts::tmd_len +SeqMut::eval::th +SeqMut::mutate::jmd_c_len +SeqMut::mutate::jmd_n_len +SeqMut::scan::jmd_c_len +SeqMut::scan::jmd_n_len +SeqMut::scan::to_aa +SeqMut::suggest::jmd_c_len +SeqMut::suggest::jmd_n_len +SeqMut::suggest::to_aa +SeqMut::suggest::weight +SeqMutPlot::mutation_landscape::cmap +SeqMutPlot::residue_mutation_impact::color +SeqMutPlot::residue_mutation_impact::figsize +SeqOpt::run::init +SeqOpt::run::jmd_c_len +SeqOpt::run::jmd_n_len +SeqOpt::run::seed +SeqOpt::run::to_aa +SeqOptPlot::convergence::figsize +SeqOptPlot::genealogy::cmap +SeqOptPlot::genealogy::figsize +SeqOptPlot::hypervolume::figsize +SeqOptPlot::mutation_map::cmap +SeqOptPlot::mutation_map::figsize +SeqOptPlot::parallel_coordinates::cmap +SeqOptPlot::parallel_coordinates::figsize +SeqOptPlot::pareto_front::cmap +SeqOptPlot::pareto_front::figsize +SeqOptPlot::pareto_front::front_only +SequenceFeature::feature_matrix::df_scales +SequenceFeature::get_df_feat::accept_gaps +SequenceFeature::get_df_feat::df_cat +SequenceFeature::get_df_feat::df_scales +SequenceFeature::get_df_feat::jmd_c_len +SequenceFeature::get_df_feat::jmd_n_len +SequenceFeature::get_df_feat::n_jobs +SequenceFeature::get_df_pos::jmd_c_len +SequenceFeature::get_df_pos::jmd_n_len +SequenceFeature::get_feature_names::jmd_c_len +SequenceFeature::get_feature_names::jmd_n_len +SequenceFeature::get_feature_positions::jmd_c_len +SequenceFeature::get_feature_positions::jmd_c_seq +SequenceFeature::get_feature_positions::jmd_n_len +SequenceFeature::get_feature_positions::jmd_n_seq +SequenceFeature::get_labels_ovo::dict_num_parts +SequenceFeature::get_labels_ovo::label_ref +SequenceFeature::get_labels_ovo::label_test +SequenceFeature::get_labels_quantile::label_ref +SequenceFeature::get_labels_quantile::label_test +SequenceFeature::get_labels_tiered::dict_num_parts +SequenceFeature::get_labels_tiered::label_ref +SequenceFeature::get_labels_tiered::label_test +SequencePreprocessor::get_aa_window::gap +SequencePreprocessor::get_sliding_aa_window::gap +ShapModel::add_feat_impact::normalize +ShapModel::add_feat_impact::sample_positions +ShapModel::add_sample_mean_dif::sample_positions +ShapModel::fit::n_background_data +StructurePreprocessor::build_cat::dim_names_override +StructurePreprocessor::build_scales::dim_names_override +StructurePreprocessor::build_scales::return_std +StructurePreprocessor::encode_domains::on_failure +StructurePreprocessor::encode_domains::return_df +StructurePreprocessor::encode_dssp::gap_handling +StructurePreprocessor::encode_dssp::on_failure +StructurePreprocessor::encode_dssp::return_df +StructurePreprocessor::encode_dssp::ss_mode +StructurePreprocessor::encode_pae::on_failure +StructurePreprocessor::encode_pae::pae_band_edges +StructurePreprocessor::encode_pae::return_df +StructurePreprocessor::encode_pdb::on_failure +StructurePreprocessor::encode_pdb::plddt_disorder_threshold +StructurePreprocessor::encode_pdb::return_df +StructurePreprocessor::fetch_alphafold::file_format +StructurePreprocessor::fetch_alphafold::max_workers +StructurePreprocessor::fetch_alphafold::on_failure +StructurePreprocessor::fetch_alphafold::return_df +StructurePreprocessor::fetch_alphafold::skip_existing +StructurePreprocessor::fetch_alphafold::timeout +StructurePreprocessor::get_domains::chainsaw_path +StructurePreprocessor::get_domains::on_failure +StructurePreprocessor::get_domains::pdb_folder +StructurePreprocessor::get_domains::threshold +StructurePreprocessor::get_dssp::gap_handling +TreeModel::__init__::is_preselected +TreeModel::eval::n_cv +TreeModel::fit::n_cv +comp_auc_adjusted::None::label_ref +comp_auc_adjusted::None::label_test +comp_auc_adjusted::None::n_jobs +comp_kld::None::label_ref +comp_kld::None::label_test +comp_seq_sim::None::df_seq +dPULearn::eval::n_jobs +dPULearn::fit::label_pos +dPULearn::fit::n_unl_to_neg +dPULearnPlot::eval::legend +display_df::None::df +plot_gcfs::None::option +plot_legend::None::frameon +plot_legend::None::hatchcolor +plot_rank::None::col_group +plot_rank::None::col_score +plot_rank::None::dict_color +plot_rank::None::figsize +plot_rank::None::fontsize_labels +plot_rank::None::group_order +plot_rank::None::marker_size +plot_rank::None::xlabel +plot_rank::None::ylabel +plot_settings::None::adjust_further_elements +plot_settings::None::no_ticks_x +plot_settings::None::short_ticks_y +plot_settings::None::show_options +scan_motif::None::bg_file +scan_motif::None::pos_col diff --git a/tests/unit/api_tests/test_notebook_param_coverage.py b/tests/unit/api_tests/test_notebook_param_coverage.py new file mode 100644 index 00000000..83929b21 --- /dev/null +++ b/tests/unit/api_tests/test_notebook_param_coverage.py @@ -0,0 +1,190 @@ +"""Test that every public parameter is *demonstrated* in its example notebook. + +House rule (``.claude/rules/notebooks.md``): each public method/function has one +example notebook (wired via a ``.. include:: examples/.rst`` in its docstring), +and that notebook must "cover every public parameter of the demonstrated method". This +gate makes the rule enforceable instead of aspirational — the AAPred notebooks shipped +without full parameter coverage precisely because nothing checked it. + +Approach (deliberately name-based, mirroring ``test_param_coverage.py``): +1. For every symbol in ``aaanalysis.__all__``, enumerate its public methods/functions. +2. For each that carries an ``.. include:: examples/.rst`` docstring directive, + locate ``examples/**/.ipynb`` and read its **code** cells. +3. Every public parameter of that method must appear by **name** in the notebook code + (i.e. be passed, almost always as an explicit keyword — the house demo style). +Missing parameters fail the test unless justified in ``ALLOWLIST``. + +This is a coarse, string-based signal: a param name appearing does not prove a +*meaningful* demonstration, but a name never appearing proves the parameter is +undemonstrated. Keeping the allowlist tiny keeps the gate honest. +""" +import ast +import inspect +import json +import re +from pathlib import Path + +import pytest + +import aaanalysis as aa + +_REPO_ROOT = Path(__file__).resolve().parents[3] +_EXAMPLES_ROOT = _REPO_ROOT / "examples" +_SKIP_PARAMS = {"self", "cls"} +_VAR_KINDS = {inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD} +_INCLUDE_RE = re.compile(r"\.\.\s+include::\s+examples/([\w\-]+)\.rst") + +# Ambient params that are structurally hard to demo by name and add no teaching value. +# Keep this SMALL — behavioural params must be shown, not allowlisted. +_AMBIENT = {"ax"} + +# (symbol, method_or_None, param) -> reason. Only genuine non-demonstrables. +ALLOWLIST: dict = {} + +# Committed backlog of known-undemonstrated params (pyright-style ratchet). NEW notebooks +# and the prediction notebooks are NOT in it, so they must have zero gaps; existing rows are +# burned down over time and MUST be removed once fixed (guarded below). +_BASELINE_PATH = Path(__file__).with_name("notebook_param_coverage_baseline.txt") + + +def _load_baseline(): + if not _BASELINE_PATH.exists(): + return set() + return { + line.strip() + for line in _BASELINE_PATH.read_text(encoding="utf-8").splitlines() + if line.strip() and not line.startswith("#") + } + + +def _gap_key(symbol, method_name, param): + return f"{symbol}::{method_name}::{param}" + + +def _current_gaps(): + """Set of ``symbol::method::param`` keys for every currently-undemonstrated param.""" + gaps = set() + for symbol, method_name, _fn, nb, params in iter_documented_methods(): + if nb is None: + continue + code = _notebook_code(nb) + for p in params: + if p in _AMBIENT or (symbol, method_name, p) in ALLOWLIST: + continue + if not re.search(rf"\b{re.escape(p)}\b", code): + gaps.add(_gap_key(symbol, method_name, p)) + return gaps + + +def is_missing_feature_stub(obj): + """True if ``obj`` is the ``missing_feature_stub`` lambda for an absent extra.""" + if not (inspect.isfunction(obj) and obj.__name__ == ""): + return False + kinds = [p.kind for p in inspect.signature(obj).parameters.values()] + return kinds == [inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD] + + +def _iter_methods(cls): + yield "__init__", cls.__init__ + for name in dir(cls): + if name.startswith("_"): + continue + if isinstance(inspect.getattr_static(cls, name, None), property): + continue + member = getattr(cls, name) + if callable(member): + yield name, member + + +def _include_name(fn): + """Return the ``examples/.rst`` stem from the docstring, or None.""" + doc = inspect.getdoc(fn) or "" + m = _INCLUDE_RE.search(doc) + return m.group(1) if m else None + + +def _find_notebook(name): + hits = list(_EXAMPLES_ROOT.rglob(f"{name}.ipynb")) + return hits[0] if hits else None + + +def _notebook_code(path): + """Concatenated source of all code cells in the notebook.""" + nb = json.loads(path.read_text(encoding="utf-8")) + return "\n".join( + "".join(c.get("source", [])) + for c in nb.get("cells", []) + if c.get("cell_type") == "code" + ) + + +def _public_params(fn): + try: + sig = inspect.signature(fn) + except (TypeError, ValueError): + return [] + return [p for p, v in sig.parameters.items() + if p not in _SKIP_PARAMS and v.kind not in _VAR_KINDS] + + +def iter_documented_methods(): + """Yield ``(symbol, method_name, fn, notebook_path, [params])`` for methods that + have an example notebook via their docstring include.""" + for symbol in aa.__all__: + obj = getattr(aa, symbol) + if not (inspect.isclass(obj) or inspect.isfunction(obj)): + continue + if is_missing_feature_stub(obj): + continue + targets = _iter_methods(obj) if inspect.isclass(obj) else [(None, obj)] + for method_name, fn in targets: + name = _include_name(fn) + if name is None: + continue + nb = _find_notebook(name) + yield symbol, method_name, fn, nb, _public_params(fn) + + +class TestNotebookParamCoverageMachinery: + """Guards so the gate can never pass vacuously.""" + + def test_enumeration_is_non_trivial(self): + rows = list(iter_documented_methods()) + assert len(rows) > 30, f"only {len(rows)} documented methods found — enumeration broke" + + def test_every_documented_notebook_exists(self): + missing = [f"{s}.{m}" for s, m, _fn, nb, _p in iter_documented_methods() if nb is None] + assert not missing, f"docstring includes with no example notebook: {missing}" + + def test_allowlist_entries_are_real(self): + valid = {(s, m, p) for s, m, _fn, _nb, params in iter_documented_methods() for p in params} + stale = [k for k in ALLOWLIST if k not in valid] + assert not stale, f"stale ALLOWLIST entries (param no longer exists): {stale}" + + +class TestNotebookParamCoverage: + def test_no_new_undemonstrated_params(self): + """Every undemonstrated param must be a known-backlog baseline entry. Prediction + notebooks and any new notebook are not baselined, so they must have zero gaps.""" + new = sorted(_current_gaps() - _load_baseline()) + assert not new, ( + "Example notebooks must demonstrate every public parameter " + "(.claude/rules/notebooks.md). These are NOT in the baseline and must be fixed " + "(add the param as an explicit kwarg in the notebook), not baselined:\n" + + "\n".join(f" {k}" for k in new) + ) + + def test_baseline_has_no_stale_entries(self): + """Once a notebook is fixed, its baseline row must be removed — this forces the + backlog to ratchet down and can never silently drift up.""" + stale = sorted(_load_baseline() - _current_gaps()) + assert not stale, ( + "These baseline rows no longer correspond to a real gap — the param is now " + "demonstrated. Remove them from notebook_param_coverage_baseline.txt:\n" + + "\n".join(f" {k}" for k in stale) + ) + + def test_prediction_notebooks_fully_covered(self): + """The prediction (AAPred/AAPredPlot) notebooks are held to zero gaps.""" + pred = sorted(k for k in _current_gaps() if k.startswith(("AAPred::", "AAPredPlot::"))) + assert not pred, "Prediction notebooks must demonstrate every param:\n" + "\n".join(f" {k}" for k in pred) diff --git a/tests/unit/prediction_tests/test_aa_pred_plot.py b/tests/unit/prediction_tests/test_aa_pred_plot.py index 205c72da..a8f4cbe9 100644 --- a/tests/unit/prediction_tests/test_aa_pred_plot.py +++ b/tests/unit/prediction_tests/test_aa_pred_plot.py @@ -26,6 +26,19 @@ def _df_eval(holdout=False): return aa.AAPred(random_state=0).eval(X, labels, metrics=["accuracy", "balanced_accuracy"], **kwargs) +def _df_eval_grid(models, metrics): + """Synthetic df_eval with a chosen number of models x metrics (controls 1D vs 2D).""" + import aaanalysis.utils as ut + rows = [{ut.COL_MODEL: m, ut.COL_METRIC: me, ut.COL_PRINCIPLE: "cv", + ut.COL_SCORE: 0.6 + 0.05 * (i + j), ut.COL_SCORE_STD: 0.02} + for i, m in enumerate(models) for j, me in enumerate(metrics)] + return pd.DataFrame(rows) + + +def _is_bar(ax): + return any(type(p).__name__ == "Rectangle" for p in ax.patches) + + def _scores(seed=0): X, labels = _data(seed=seed) aapred = aa.AAPred(random_state=seed).fit(X, labels) @@ -73,6 +86,18 @@ def test_ylabel(self): fig, ax = aa.AAPredPlot().eval(_df_eval(), ylabel="Balanced accuracy") assert ax.get_ylabel() == "Balanced accuracy" + def test_multi_model_is_bars_with_hue(self): + # Comparing methods (multiple models) -> grouped bars, one color (hue) per model. + fig, ax = aa.AAPredPlot().eval(_df_eval_grid(["svm", "rf", "log"], ["acc", "auc"])) + assert _is_bar(ax) + colors = {tuple(round(c, 4) for c in p.get_facecolor()) + for p in ax.patches if type(p).__name__ == "Rectangle"} + assert len(colors) >= 3 # a distinct hue per model + + def test_single_model_is_bars(self): + fig, ax = aa.AAPredPlot().eval(_df_eval_grid(["svm"], ["acc", "auc", "f1"])) + assert _is_bar(ax) + def _df_comp(): return pd.DataFrame({"group": ["A", "A", "B", "B"],