From b468f27b2c8f424e67aeae0d06426a0ac0d4b867 Mon Sep 17 00:00:00 2001 From: Anton Siomchen <41703271+asiomchen@users.noreply.github.com> Date: Thu, 8 May 2025 17:06:41 +0200 Subject: [PATCH 1/7] update dependencies --- .pre-commit-config.yaml | 8 +++++++- Makefile | 11 ++--------- pyproject.toml | 2 +- ruff.toml | 3 ++- scikit_mol/plotting.py | 2 +- uv.lock | 1 + 6 files changed, 14 insertions(+), 13 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 11326b6..b7bc5c3 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -20,4 +20,10 @@ repos: args: [ --fix ] types_or: [ python, pyi ] # Run the formatter. - - id: ruff-format \ No newline at end of file + - id: ruff-format + +- repo: https://github.com/mwouts/jupytext + rev: v1.16.6 # CURRENT_TAG/COMMIT_HASH + hooks: + - id: jupytext + args: [--sync] \ No newline at end of file diff --git a/Makefile b/Makefile index 0e7119d..5b26e8e 100644 --- a/Makefile +++ b/Makefile @@ -1,13 +1,6 @@ sync-notebooks: + uv run jupytext --set-formats docs//notebooks//ipynb,docs//notebooks//scripts//py:percent --sync docs/notebooks/*.ipynb uv run ruff format "docs/notebooks/" - uv run jupytext --sync "docs/notebooks/*.ipynb" run-notebooks: - # Execute the notebooks, gives a .nbconvert.ipynb extension - jupyter nbconvert --to notebook --execute *ipynb - # move the .nbconvert.ipynb to the original .ipynb - for file in *.nbconvert.ipynb; do - fname=${file/.nbconvert.ipynb/}; - rm $fname.ipynb - mv $file $fname.ipynb - done \ No newline at end of file + uv run jupytext --execute docs/notebooks/*ipynb \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml index 2320447..84586c9 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -107,4 +107,4 @@ docs = [ [tool.jupytext.formats] "docs/notebooks/" = "ipynb" -"docs/notebooks/scripts" = "py:percent" \ No newline at end of file +"docs/notebooks/scripts" = "py:percent" diff --git a/ruff.toml b/ruff.toml index 3a68459..af72105 100644 --- a/ruff.toml +++ b/ruff.toml @@ -27,7 +27,8 @@ exclude = [ "node_modules", "site-packages", "venv", - "notebooks" + "notebooks", + "docs/notebooks/scripts", ] # Same as Black. diff --git a/scikit_mol/plotting.py b/scikit_mol/plotting.py index cf2001c..e331fe7 100644 --- a/scikit_mol/plotting.py +++ b/scikit_mol/plotting.py @@ -22,7 +22,7 @@ class ParallelTester: def __init__( self, transformer: object, - mols: list[Chem.Mol], + mols: list["Chem.Mol"], n_mols: Sequence[int] = (10, 100, 100, 1000, 10000, 100000), n_jobs: Sequence[int] = (1, 2, 4, 8), backend: str = "loky", diff --git a/uv.lock b/uv.lock index 0bc6bf1..3489a06 100644 --- a/uv.lock +++ b/uv.lock @@ -1,4 +1,5 @@ version = 1 +revision = 1 requires-python = ">=3.9, <3.14" resolution-markers = [ "python_full_version >= '3.12'", From da0d755737419b3ad36f5cbbd6c362a57816f9c6 Mon Sep 17 00:00:00 2001 From: Anton Siomchen <41703271+asiomchen@users.noreply.github.com> Date: Thu, 8 May 2025 17:20:21 +0200 Subject: [PATCH 2/7] use py files as the source of truth --- .gitignore | 3 +- docs/notebooks/03_example_pipeline.ipynb | 4 +- docs/notebooks/04_standardizer.ipynb | 6 +- docs/notebooks/05_smiles_sanitization.ipynb | 6 +- ..._Usage_with_FingerPrint_Transformers.ipynb | 6 +- .../notebooks/10_pipeline_pandas_output.ipynb | 6 +- docs/notebooks/11_safe_inference.ipynb | 8 +- .../12_custom_fingerprint_transformer.py | 117 +++++++ docs/notebooks/13_applicability_domain.ipynb | 9 +- docs/notebooks/13_applicability_domain.py | 313 ++++++++++++++++++ docs/notebooks/scripts/03_example_pipeline.py | 4 +- 11 files changed, 456 insertions(+), 26 deletions(-) create mode 100644 docs/notebooks/12_custom_fingerprint_transformer.py create mode 100644 docs/notebooks/13_applicability_domain.py diff --git a/.gitignore b/.gitignore index d6e4a0c..62293e8 100644 --- a/.gitignore +++ b/.gitignore @@ -130,8 +130,7 @@ dmypy.json .scikit-mol.code-workspace.swp scikit-mol.code-workspace -notebooks/25747817 -*.ipynb + # test data tests/data/ diff --git a/docs/notebooks/03_example_pipeline.ipynb b/docs/notebooks/03_example_pipeline.ipynb index 10b5edc..5896f4d 100644 --- a/docs/notebooks/03_example_pipeline.ipynb +++ b/docs/notebooks/03_example_pipeline.ipynb @@ -389,7 +389,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3.9.4 ('rdkit')", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -403,7 +403,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.12.6" } }, "nbformat": 4, diff --git a/docs/notebooks/04_standardizer.ipynb b/docs/notebooks/04_standardizer.ipynb index d32b9b3..3fcd238 100644 --- a/docs/notebooks/04_standardizer.ipynb +++ b/docs/notebooks/04_standardizer.ipynb @@ -6,7 +6,7 @@ "metadata": {}, "source": [ "# Molecule standardization\n", - "When building machine learning models of molecules, it is important to standardize the molecules. We often don't want different predictions just because things are drawn in slightly different forms, such as protonated or deprotonated carboxylic acids. Scikit-mol provides a very basic standardize transformer based on the molvs implementation in RDKit" + "When building machine learning models of molecules, it is important to standardize the molecules. We often don't want different predictions just because things are drawn in slightly different forms, such as protonated or deprotanted carboxylic acids. Scikit-mol provides a very basic standardize transformer based on the molvs implementation in RDKit" ] }, { @@ -140,7 +140,7 @@ "source": [ "Some of the molecules were desalted and neutralized.\n", "\n", - "A typical usecase would be to add the standardizer to a pipeline for prediction" + "A typical use case would be to add the standardizer to a pipeline for prediction" ] }, { @@ -194,7 +194,7 @@ "id": "f0d071fb", "metadata": {}, "source": [ - "As we can see, the predictions with the standardizer and without are different. The two first molecules were benzoic acid and sodium benzoate, which with the standardized pipeline is predicted as the same, but differently with the nonstandardized pipeline. Wheter we want to make the prediction on the parent compound, or predict the exact form, will of course depend on the use-case, but now there is at least a way to handle it easily in pipelined predictors.\n", + "As we can see, the predictions with the standardizer and without are different. The two first molecules were benzoic acid and sodium benzoate, which with the standardized pipeline is predicted as the same, but differently with the nonstandardized pipeline. Whether we want to make the prediction on the parent compound, or predict the exact form, will of course depend on the use-case, but now there is at least a way to handle it easily in pipelined predictors.\n", "\n", "The example also demonstrate another feature. We created the ridge regressor before creating the two pipelines. Fitting one of the pipelines thus also updated the object in the other pipeline. This can be useful for building inference pipelines that takes in SMILES molecules, but rather do the fitting on already converted and standardized molecules. However, be aware that the crossvalidation classes of scikit-learn may clone the estimators internally when doing the search loop, which would break this interdependence, and necessitate the rebuilding of the inference pipeline.\n", "\n", diff --git a/docs/notebooks/05_smiles_sanitization.ipynb b/docs/notebooks/05_smiles_sanitization.ipynb index 2b0bb99..84dcf35 100644 --- a/docs/notebooks/05_smiles_sanitization.ipynb +++ b/docs/notebooks/05_smiles_sanitization.ipynb @@ -128,9 +128,9 @@ } ], "source": [ - "from scikit_mol.utilities import CheckSmilesSanitazion\n", + "from scikit_mol.utilities import CheckSmilesSanitization\n", "\n", - "smileschecker = CheckSmilesSanitazion()\n", + "smileschecker = CheckSmilesSanitization()\n", "\n", "smiles_list_valid, y_valid, smiles_errors, y_errors = smileschecker.sanitize(\n", " list(data.SMILES), list(data.pXC50)\n", @@ -142,7 +142,7 @@ "id": "c888d7da", "metadata": {}, "source": [ - "Now the smiles_list_valid should be all valid and the y_values filtered as well. Errors are returned, but also accesible after the call to .sanitize() in the .errors property" + "Now the smiles_list_valid should be all valid and the y_values filtered as well. Errors are returned, but also accessible after the call to .sanitize() in the .errors property" ] }, { diff --git a/docs/notebooks/09_Combinatorial_Method_Usage_with_FingerPrint_Transformers.ipynb b/docs/notebooks/09_Combinatorial_Method_Usage_with_FingerPrint_Transformers.ipynb index e11c62e..339afcd 100644 --- a/docs/notebooks/09_Combinatorial_Method_Usage_with_FingerPrint_Transformers.ipynb +++ b/docs/notebooks/09_Combinatorial_Method_Usage_with_FingerPrint_Transformers.ipynb @@ -112,9 +112,9 @@ "metadata": {}, "source": [ "## Build Pipeline:\n", - "In this stage we will build the Pipeline consisting of the featurization part (finger print transformers) and the model part (Ridge Regression).\n", + "In this stage we will build the Pipeline consisting of the featurization part (fingerprint transformers) and the model part (Ridge Regression).\n", "\n", - "Note that the featurization in this section is an hyperparameter, living in `param_grid`, and the `\"fp_transformer\"` string is just a placeholder, being replaced during pipeline execution.\n", + "Note that the featurization in this section is a hyperparameter, living in `param_grid`, and the `\"fp_transformer\"` string is just a placeholder, being replaced during pipeline execution.\n", "\n", "This way we can define multiple different scenarios in `param_grid`, that allow us to rapidly explore different combinations of settings and methodologies." ] @@ -243,7 +243,7 @@ "source": [ "## Analysis\n", "\n", - "Now let's investigate our results from the training stage. Which one is the best finger print method for this data set? Which parameters are optimal?" + "Now let's investigate our results from the training stage. Which one is the best fingerprint method for this data set? Which parameters are optimal?" ] }, { diff --git a/docs/notebooks/10_pipeline_pandas_output.ipynb b/docs/notebooks/10_pipeline_pandas_output.ipynb index ddefb69..53eda0f 100644 --- a/docs/notebooks/10_pipeline_pandas_output.ipynb +++ b/docs/notebooks/10_pipeline_pandas_output.ipynb @@ -9,7 +9,7 @@ "\n", "This notebook highlights the ability of scikit-mol transformers to return data in DataFrames with meaningful column names. Some use-cases of this feature are illustrated.\n", "\n", - "***NOTE***: The goal of this notebook is to highlight the advantages of storing transformer output in DataFrames with meaningful column names. This notebook should *not* be considered a set of good practices for training and evaluating QSAR pipelines. The performance metrics of the resulting pipelines are pretty bad: the dataset they have been trained on is pretty small. Tuning the hyperparameters of the Random Forest regressor model (maximum depth of the trees, maximum features to consider when splitting...) can be beneficial. Also including dimensionality reduction / feature selection techniques can be beneficial, since pipelines use an high number of features for a small number of samples. Of course, to further reduce the risk of overfitting, the best hyperparameters and preprocessing techniques should be chosen in cross validation." + "***NOTE***: The goal of this notebook is to highlight the advantages of storing transformer output in DataFrames with meaningful column names. This notebook should *not* be considered a set of good practices for training and evaluating QSAR pipelines. The performance metrics of the resulting pipelines are pretty bad: the dataset they have been trained on is pretty small. Tuning the hyperparameters of the Random Forest regressor model (maximum depth of the trees, maximum features to consider when splitting...) can be beneficial. Also including dimensionality reduction / feature selection techniques can be beneficial, since pipelines use a high number of features for a small number of samples. Of course, to further reduce the risk of overfitting, the best hyperparameters and preprocessing techniques should be chosen in cross validation." ] }, { @@ -4985,7 +4985,7 @@ }, "outputs": [], "source": [ - "# The CDDD descriptors couldn't be computed for few molecules and can be removed as outcommented below. The Datafile is now prefiltered\n", + "# The CDDD descriptors couldn't be computed for few molecules and can be removed as commented out below. The Datafile is now prefiltered\n", "# target_train = data_train.loc[data_train[\"Ambit_InchiKey\"].isin(data_combined_train[\"Ambit_InchiKey\"]), column_target]\n", "# target_test = data_test.loc[data_test[\"Ambit_InchiKey\"].isin(data_combined_test[\"Ambit_InchiKey\"]), column_target]\n", "\n", @@ -6873,7 +6873,7 @@ "id": "83b7fd13", "metadata": {}, "source": [ - "All performance metrics were improved by the includion of the CDDD features.\n", + "All performance metrics were improved by the inclusion of the CDDD features.\n", "Let's analyze the feature importances of the model:" ] }, diff --git a/docs/notebooks/11_safe_inference.ipynb b/docs/notebooks/11_safe_inference.ipynb index 1c67167..94edc22 100644 --- a/docs/notebooks/11_safe_inference.ipynb +++ b/docs/notebooks/11_safe_inference.ipynb @@ -9,7 +9,7 @@ "\n", "I think everyone which have worked with SMILES and RDKit sooner or later come across a SMILES that doesn't parse. It can happen if the SMILES was produced with a different toolkit that are less strict with e.g. valence rules, or maybe a characher was missing in the copying from the email. During curation of the dataset for training models, these SMILES need to be identfied and eventually fixed or removed. But what happens when we are finished with our modelling? What kind of molecules and SMILES will a user of the model send for the model in the future when it's in deployment. What kind of SMILES will a generative model create that we need to predict? We don't know and we won't know. So it's kind of crucial to be able to handle these situations. Scikit-Learn models usually simply explodes the entire batch that are being predicted. This is where safe_inference_mode was introduced in Scikit-Mol. With the introduction all transformers got a safe inference mode, where they handle invalid input. How they handle it depends a bit on the transformer, so we will go through the different usual steps and see how things have changed with the introduction of the safe inference mode.\n", "\n", - "NOTE! In the following demonstration I switch on the safe inference mode individually for demonstration purposes. I would not recommend to do that while building and training models, instead I would switch it on _after_ training and evaluation (more on that later). Otherwise there's a risk to train on the 2% of a dataset that didn't fail....\n", + "NOTE! In the following demonstration I switch on the safe inference mode individually for demonstration purposes. I would not recommend to do that while building and training models, instead I would switch it on _after_ training and evaluation (more on that later). Otherwise, there's a risk to train on the 2% of a dataset that didn't fail....\n", "\n", "First some imports and test SMILES and molecules." ] @@ -218,7 +218,7 @@ "id": "a5e2b301", "metadata": {}, "source": [ - "However, currently scikit-learn models accepts masked arrays, but they do not respect the mask! So if you fed it directly to the model to train, it would seemingly work, but the invalid samples would all have the fill_value, meaning you could get weird results. Instead we need the last part of the puzzle, the SafeInferenceWrapper class." + "However, currently scikit-learn models accepts masked arrays, but they do not respect the mask! So if you fed it directly to the model to train, it would seemingly work, but the invalid samples would all have the fill_value, meaning you could get weird results. Instead, we need the last part of the puzzle, the SafeInferenceWrapper class." ] }, { @@ -277,7 +277,7 @@ "metadata": {}, "source": [ "The prediction went fine both in fit and in prediction, where the result shows `nan` for the invalid entries. However, please note fit in sage_inference_mode is not recommended in a training session, but you are warned and not blocked, because maybe you know what you do and do it on purpose.\n", - "The SafeInferenceMapper both handles rows that are masked in masked arrays, but also checks rows for nonfinite values and filters these away. Sometimes some descriptors may return a inf or nan, even though the molecule itself is valid. The masking of nonfinite values can be switched off, maybe you are using a model that can handle missing data and only want to filter away invalid molecules.\n", + "The SafeInferenceMapper both handles rows that are masked in masked arrays, but also checks rows for nonfinite values and filters these away. Sometimes some descriptors may return an inf or nan, even though the molecule itself is valid. The masking of nonfinite values can be switched off, maybe you are using a model that can handle missing data and only want to filter away invalid molecules.\n", "\n", "## Setting safe_inference_mode post-training\n", "As I said before I believe in catching errors and fixing those during training, but what do we do when we need to switch on safe inference mode for all objects in a pipeline? There's of course a tool for that, so lets demo that:" @@ -819,7 +819,7 @@ "id": "b87b46b3", "metadata": {}, "source": [ - "The second output is no longer integers, but floats. As most sklearn models cast input arrays to float32 internally, this difference is likely benign, but that's not guaranteed! Thus if you want to use pandas output for your production models, do check that the final outputs are the same for the valid rows, with and without a single invalid row. Alternatively the dtype for the output of the transformer can be switched to float for consistency if its supported by the transformer." + "The second output is no longer integers, but floats. As most sklearn models cast input arrays to float32 internally, this difference is likely benign, but that's not guaranteed! Thus, if you want to use pandas output for your production models, do check that the final outputs are the same for the valid rows, with and without a single invalid row. Alternatively the dtype for the output of the transformer can be switched to float for consistency if it's supported by the transformer." ] }, { diff --git a/docs/notebooks/12_custom_fingerprint_transformer.py b/docs/notebooks/12_custom_fingerprint_transformer.py new file mode 100644 index 0000000..0fb6988 --- /dev/null +++ b/docs/notebooks/12_custom_fingerprint_transformer.py @@ -0,0 +1,117 @@ +# --- +# jupyter: +# jupytext: +# formats: ipynb,py:percent +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.3' +# jupytext_version: 1.16.6 +# kernelspec: +# display_name: vscode +# language: python +# name: python3 +# --- + +# %% [markdown] +# # Creating custom fingerprint transformers +# +# If the default fingerprint transformers provided by the scikit-mol library are not enough for your needs, you can create your own custom fingerprint transformers. In this notebook, we will show you how to do this. +# +# Note that base classes are partially stable and may change in the future versions of the library. We will try to keep the changes minimal and provide a migration guide if necessary. This notebook is also will be updated accordingly. + +# %% [markdown] +# ## Basics +# +# For now we recommend you to use the `BaseFpsTransformer` class as a base class for your custom fingerprint transformers. This class provides a simple interface to create fingerprint transformers that can be used with the scikit-mol library. +# +# To create your custom fingerprint transformer, you need to create a class that inherits from the `BaseFpsTransformer` class and implement the `_transform_mol` method. This method should take a single RDKit molecule object as input and return a fingerprint as a numpy array. + +# %% +from scikit_mol.fingerprints.baseclasses import BaseFpsTransformer +import numpy as np +from rdkit import Chem + +class DummyFingerprintTransformer(BaseFpsTransformer): + def __init__(self, fpSize=64, n_jobs=1, safe_inference_mode = False): + self.fpSize = fpSize + super().__init__(n_jobs=n_jobs, safe_inference_mode=safe_inference_mode, name="dummy") + + def _transform_mol(self, mol): + return mol.GetNumAtoms() * np.ones(self.fpSize) + +trans = DummyFingerprintTransformer(n_jobs=4) +mols = [Chem.MolFromSmiles('CC')] * 100 +trans.transform(mols) + +# %% [markdown] +# ## Non-pickable objects +# When working with some of the `rdkit` function and classes you will often discover that some of the are unpickable objects. This means that they cannot be serialized and deserialized using the `pickle` module. This is a problem when you want to use the parallelization (controlled by the `n_jobs` parameter). +# +# Any non-pickable object in the transformer attributes should be initialized in the `__init__` method of the transforme from the other *picklable* arguments. +# +# In the example below, we will create a custom fingerprint transformer that uses the Morgan fingerprint with radius **2** and **1024** bits. Used generator is unpickable, but it can be created during the initialization of the transformer from the picklable `maxPath` and `fpSize` arguments. + +# %% +from rdkit.Chem import rdFingerprintGenerator + +class UnpickableFingerprintTransformer(BaseFpsTransformer): + def __init__(self, fpSize=1024, n_jobs=1, safe_inference_mode=False, **kwargs): + self.fpSize = fpSize + super().__init__(n_jobs=n_jobs, safe_inference_mode=safe_inference_mode, **kwargs) + self.fp_gen = rdFingerprintGenerator.GetRDKitFPGenerator(maxPath=2, fpSize=self.fpSize) + + def _transform_mol(self, mol): + return self.fp_gen.GetFingerprintAsNumPy(mol) + +trans = UnpickableFingerprintTransformer(n_jobs=4, fpSize=512) +trans.transform(mols) + + +# %% [markdown] +# Non-pickable object should not be present among the `__init__` arguments of the transformer. Doing so will prevent them to be pickled to recreate a transformer instance in the worker processes. If you for some reason need to pass a non-pickable object to the transformer you can do so (**highly discouraged**, please [open the issue](https://github.com/EBjerrum/scikit-mol/issues), maybe we will be able to help you do it better) by using the transformer in the sequential mode (i.e. `n_jobs=1`). + +# %% +class BadTransformer(BaseFpsTransformer): + def __init__(self, generator, n_jobs=1): + self.generator = generator + super().__init__(n_jobs=n_jobs) + def _transform_mol(self, mol): + return self.generator.GetFingerprint(mol) + + +fp_gen = rdFingerprintGenerator.GetMorganGenerator(radius=2, fpSize=10) +BadTransformer(fp_gen, n_jobs=1).transform(mols) +print("n_jobs=1 is fine") +try: + BadTransformer(fp_gen, n_jobs=2).transform(mols) +except Exception as e: + print("n_jobs=2 is not fine, because the generator passed as an argument is not picklable") + print(f"Error msg: {e}") + + +# %% [markdown] +# ## Fingerprint name +# +# To use the fingerptint in the `pandas` output mode it needes to know the name of the fingerprint and the number of bits (features) in it to generate the columns names. The number of feature is derived from `fpSize` attribute +# +# And the name resolution works as follows (in order of priority): +# - if the fingerprint has a name set during the initialization of the base class, it is used +# - if the name of the class follows the pattern `XFingerprintTransformer`, the name (`fp_X`) is extracted from it +# - as a last resort, the name is set to name of the class + +# %% +class NamedTansformer1(UnpickableFingerprintTransformer): + pass + +class NamedTansformer2(UnpickableFingerprintTransformer): + def __init__(self): + super().__init__(name="fp_fancy") + +class FancyFingerprintTransformer(UnpickableFingerprintTransformer): + pass + +print(NamedTansformer1().get_feature_names_out()) +print(NamedTansformer2().get_feature_names_out()) +print(FancyFingerprintTransformer().get_feature_names_out()) + diff --git a/docs/notebooks/13_applicability_domain.ipynb b/docs/notebooks/13_applicability_domain.ipynb index fcac2a4..f11dad4 100644 --- a/docs/notebooks/13_applicability_domain.ipynb +++ b/docs/notebooks/13_applicability_domain.ipynb @@ -562,7 +562,9 @@ "cell_type": "code", "execution_count": 9, "id": "ee7b2f64", - "metadata": {}, + "metadata": { + "lines_to_next_cell": 2 + }, "outputs": [ { "name": "stderr", @@ -605,7 +607,7 @@ "plt.scatter(y_test, abs_errors, alpha=0.5)\n", "plt.xlabel('pXC50')\n", "plt.ylabel('Predicted Absolute Error')\n", - "plt.title('Predicted pXC50 vs Absolute Error')\n" + "plt.title('Predicted pXC50 vs Absolute Error')" ] }, { @@ -1634,8 +1636,7 @@ "metadata": { "jupytext": { "cell_metadata_filter": "-all", - "formats": "ipynb,py:percent", - "main_language": "python" + "formats": "ipynb,py:percent" }, "kernelspec": { "display_name": "vscode", diff --git a/docs/notebooks/13_applicability_domain.py b/docs/notebooks/13_applicability_domain.py new file mode 100644 index 0000000..8e01e47 --- /dev/null +++ b/docs/notebooks/13_applicability_domain.py @@ -0,0 +1,313 @@ +# --- +# jupyter: +# jupytext: +# cell_metadata_filter: -all +# formats: ipynb,py:percent +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.3' +# jupytext_version: 1.16.6 +# kernelspec: +# display_name: vscode +# language: python +# name: python3 +# --- + +# %% [markdown] +# # Applicability Domain Estimation +# +# This notebook demonstrates how to use scikit-mol's applicability domain estimators to assess whether new compounds are within the domain of applicability of a trained model. +# +# We'll explore two different approaches: +# 1. Using Morgan binary fingerprints with a k-Nearest Neighbors based applicability domain +# 2. Using count-based Morgan fingerprints with dimensionality reduction and a leverage-based applicability domain +# +# First, let's import the necessary libraries and load our dataset: + +# %% +import numpy as np +import pandas as pd +from rdkit import Chem +from rdkit.Chem import Draw +from rdkit.Chem import PandasTools +import matplotlib.pyplot as plt +from sklearn.model_selection import train_test_split +from sklearn.ensemble import RandomForestRegressor +from sklearn.pipeline import Pipeline +from sklearn.preprocessing import StandardScaler +from sklearn.decomposition import PCA +import pathlib + + +from scikit_mol.fingerprints import MorganFingerprintTransformer +from scikit_mol.applicability import KNNApplicabilityDomain, LeverageApplicabilityDomain + +# %% [markdown] +# ## Load and Prepare Data + +# %% +full_set = True + +if full_set: + csv_file = "SLC6A4_active_excape_export.csv" + if not pathlib.Path(csv_file).exists(): + import urllib.request + + url = "https://ndownloader.figshare.com/files/25747817" + urllib.request.urlretrieve(url, csv_file) +else: + csv_file = "../tests/data/SLC6A4_active_excapedb_subset.csv" + +data = pd.read_csv(csv_file) + +#Could also build a pipeline to convert the smiles to mols using SmilesToMolTransformer +PandasTools.AddMoleculeColumnToFrame(data, smilesCol="SMILES") +print(f"{data.ROMol.isna().sum()} out of {len(data)} SMILES failed in conversion") + +# Split into train/val/test +X = data.ROMol +y = data.pXC50 + +X_temp, X_test, y_temp, y_test = train_test_split(X, y, test_size=0.2, random_state=42) +X_train, X_val, y_train, y_val = train_test_split(X_temp, y_temp, test_size=0.25, random_state=42) + +# %% [markdown] +# ## Example 1: k-NN Applicability Domain with Binary Morgan Fingerprints +# +# In this example, we'll use binary Morgan fingerprints and a k-NN based applicability domain with Tanimoto distance. +# This is particularly suitable for binary fingerprints as the Tanimoto coefficient is a natural similarity measure for them. + +# %% +# Create pipeline for binary fingerprints +binary_fp_pipe = Pipeline([ + ('fp', MorganFingerprintTransformer(fpSize=2048, radius=2)), + ('rf', RandomForestRegressor(n_estimators=100, random_state=0xf00d, n_jobs=-1)) +]) + +# Train the model +binary_fp_pipe.fit(X_train, y_train) + +# %% + +# Get predictions and errors +y_pred_test = binary_fp_pipe.predict(X_test) +abs_errors = np.abs(y_test - y_pred_test) + + +fig = plt.figure(figsize=(3,3)) + +plt.scatter(y_test, abs_errors, alpha=0.5) +plt.xlabel('pXC50') +plt.ylabel('Predicted Absolute Error') +plt.title('Predicted pXC50 vs Absolute Error') + + +# %% + +# Create and fit k-NN AD estimator. Distance metrics follow the scikit-learn API, and the custom distance metric tanimoto popular in cheminformatics is available in scikit-mol. +knn_ad = KNNApplicabilityDomain(n_neighbors=3, distance_metric='tanimoto', n_jobs=-1) +knn_ad.fit(binary_fp_pipe.named_steps['fp'].transform(X_train)) + +# Fit threshold using validation set +knn_ad.fit_threshold(binary_fp_pipe.named_steps['fp'].transform(X_val), target_percentile=95) + +# Get AD scores for test set +knn_scores = knn_ad.transform(binary_fp_pipe.named_steps['fp'].transform(X_test)) + +# %% [markdown] +# Let's visualize the relationship between prediction errors and AD scores, and calculate some statistics on compound errors within and outside the domain. + +# %% +plt.figure(figsize=(4, 3)) +plt.scatter(knn_scores, abs_errors, alpha=0.5) +plt.axvline(x=knn_ad.threshold_, color='r', linestyle='--', label='AD Threshold') +plt.xlabel('k-NN AD Score') +plt.ylabel('Absolute Prediction Error') +plt.title('Prediction Errors vs k-NN AD Scores') +plt.legend() +plt.show() + +# Calculate error statistics +in_domain = knn_ad.predict(binary_fp_pipe.named_steps['fp'].transform(X_test)) +errors_in = abs_errors[in_domain == 1] +errors_out = abs_errors[in_domain == -1] + +print(f"95th percentile of errors inside domain: {np.percentile(errors_in, 95):.2f}") +print(f"95th percentile of errors outside domain: {np.percentile(errors_out, 95):.2f}") +print(f"Fraction of samples outside domain: {(in_domain == -1).mean():.2f}") + +# %% [markdown] +# There's some diffence in the errors distribution inside and outside the domain threshold, but maybe not as clear-cut as we could have wished for. The fraction of samples outside the domain in the test-set are close the 5% that corresponds to the threshold estimated from the validation set fractile of 95%. + +# %% [markdown] +# ## Example 2: Leverage-based AD with Count-based Morgan Fingerprints +# +# In this example, we'll use count-based Morgan fingerprints, reduce their dimensionality with PCA, +# and apply a leverage-based applicability domain estimator. + +# %% +# Create pipeline for count-based fingerprints AD estimation with PCA, scaling and leverage +count_fp_pipe = Pipeline([ + ('fp', MorganFingerprintTransformer(fpSize=2048, radius=2, useCounts=True)), + ('pca', PCA(n_components=0.9)), # Keep 90% of variance + ('scaler', StandardScaler()), + ('leverage', LeverageApplicabilityDomain()) +]) + +# Train the model +count_fp_pipe.fit(X_train, y_train) + +# %% + +X_val_transformed = count_fp_pipe[:-1].transform(X_val) #Index into pipeline to get all the pipeline up to thelast step before the AD estimator +count_fp_pipe.named_steps['leverage'].fit_threshold(X_val_transformed, target_percentile=95) + + +# Get AD scores for test set +X_test_transformed = count_fp_pipe[:-1].transform(X_test) #Index into pipeline to get the last step before the AD estimator +leverage_raw_scores = count_fp_pipe.named_steps['leverage'].transform(X_test_transformed) + +# %% [markdown] +# As before, let's visualize the relationship between prediction errors and leverage scores and look at the fractiles errors. + +# %% +plt.figure(figsize=(4, 3)) +plt.scatter(leverage_raw_scores, abs_errors, alpha=0.5) +plt.axvline(x=count_fp_pipe.named_steps['leverage'].threshold_, color='r', linestyle='--', label='AD Threshold') +plt.xlabel('Leverage AD Score') +plt.ylabel('Absolute Prediction Error') +plt.title('Prediction Errors vs Leverage Scores') +plt.legend() + + +# Calculate error statistics +in_domain = count_fp_pipe.named_steps['leverage'].predict(X_test_transformed) +errors_in = abs_errors[in_domain == 1] +errors_out = abs_errors[in_domain == -1] + +print(f"95th percentile of errors inside domain: {np.percentile(errors_in, 95):.2f}") +print(f"95th percentile of errors outside domain: {np.percentile(errors_out, 95):.2f}") +print(f"Fraction of samples outside domain: {(in_domain == -1).mean():.2f}") + +# %% [markdown] +# Dissappointingly the error seems larger within the domain, than outside the domain. + +# %% [markdown] +# ## Testing Famous Drugs +# +# Let's test some well-known drugs to see if they fall within our model's applicability domain: + +# %% +# Define famous drugs +famous_drugs = { + 'Aspirin': 'CC(=O)OC1=CC=CC=C1C(=O)O', + 'Viagra': 'CCc1nn(C)c2c(=O)[nH]c(nc12)c3cc(ccc3OCC)S(=O)(=O)N4CCN(C)CC4', + 'Heroin': 'CN1CC[C@]23[C@H]4Oc5c(O)ccc(CC1[C@H]2C=C[C@@H]4O3)c5', +} + + +Draw.MolsToGridImage([Chem.MolFromSmiles(drug) for drug in famous_drugs.values()], molsPerRow=3, + subImgSize=(250,250), legends=[f"{name}" for name, smiles in famous_drugs.items()]) + +# %% + +leverage_ad = count_fp_pipe.named_steps['leverage'] + +# Function to process a drug through both AD pipelines +def check_drug_applicability(smiles, name): + mol = Chem.MolFromSmiles(smiles) + + # k-NN AD + fp_binary = binary_fp_pipe.named_steps['fp'].transform([mol]) + knn_score = knn_ad.transform(fp_binary)[0][0] + knn_status = "Inside" if knn_ad.predict(fp_binary)[0] == 1 else "Outside" + + # Leverage AD + fp_count = count_fp_pipe.named_steps['fp'].transform([mol]) + fp_pca = count_fp_pipe.named_steps['pca'].transform(fp_count) + fp_scaled = count_fp_pipe.named_steps['scaler'].transform(fp_pca) + leverage_score = leverage_ad.transform(fp_scaled)[0][0] + leverage_status = "Inside" if leverage_ad.predict(fp_scaled)[0] == 1 else "Outside" + + # Get prediction + pred_pIC50 = binary_fp_pipe.predict([mol])[0] + + return { + 'knn_score': knn_score, + 'knn_status': knn_status, + 'leverage_score': leverage_score, + 'leverage_status': leverage_status, + 'pred_pIC50': pred_pIC50 + } + +# Process each drug +results = [] +for name, smiles in famous_drugs.items(): + result = check_drug_applicability(smiles, name) + results.append({ + 'Drug': name, + 'Predicted pIC50': f"{result['pred_pIC50']:.2f}", + 'k-NN Score': result['knn_score'], + 'k-NN Status': result['knn_status'], + 'Leverage Score': result['leverage_score'], + 'Leverage Status': result['leverage_status'] + }) + +# Display results +pd.DataFrame(results).set_index('Drug') + +# %% [markdown] +# Let's visualize where these drugs fall in our AD plots: + +# %% +# Plot for k-NN AD +plt.figure(figsize=(12, 5)) +plt.subplot(1, 2, 1) +plt.scatter(knn_scores, abs_errors, alpha=0.2, label='Test compounds') +plt.axvline(x=knn_ad.threshold_, color='r', linestyle='--', label='AD Threshold') + +for result in results: + plt.axvline(x=result['k-NN Score'], color='g', alpha=0.5, + label=f"{result['Drug']}") + +plt.xlabel('k-NN AD Score') +plt.ylabel('Absolute Prediction Error') +plt.title('k-NN AD Scores') +#plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left') + +# Plot for Leverage AD +plt.subplot(1, 2, 2) +plt.scatter(leverage_raw_scores, abs_errors, alpha=0.2, label='Test compounds') +plt.axvline(x=leverage_ad.threshold_, color='r', linestyle='--', label='AD Threshold') + +for result in results: + plt.axvline(x=result['Leverage Score'], color='g', alpha=0.5, + label=f"{result['Drug']}") + +plt.xlabel('Leverage AD Score') +plt.ylabel('Absolute Prediction Error') +plt.title('Leverage AD Scores') +plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left') + +plt.tight_layout() +plt.show() + +# %% [markdown] +# ## Conclusions on testing the AD estimators +# +# This notebook demonstrated two different approaches to applicability domain estimation: +# +# 1. The k-NN based approach with binary fingerprints and Tanimoto distance provides a chemical similarity-based assessment +# of whether new compounds are similar enough to the training set. +# +# 2. The leverage-based approach with count-based fingerprints and dimensionality reduction focuses on the statistical +# novelty of compounds in the reduced feature space. +# +# Heroin and Aspirin was predicted to have a low affinity, whereas Viagra was predicted as having a ~9 pXC50 corresponding to nanomolar affinity. As the regression model had only been trained on actives it will have a tendency to always predict things as active, which is hard to believe for compounds so dissimilar to the training set and with our prior knowledge about their primary targets. +# +# The famous drugs we tested showed marked differences between the two AD estimation techniques. +# +# The kNN based method using tanimoto distance showed all test drugs to be distant from the training set and thus outside the applicability domain, whereas the leverage method gave the "green light" for all of them. As the drug have different primary targets than the SLC6A4 serotonin transporter, it seems like the kNN based method in this instance (dataset, featurization, ML-model) is a better way to estimate the AD for given novel compounds. This is consistent with our analysis of the 95 percentile of the absolute errors for two different methods, where kNN had a higher 95% percentile error outside the domain, it was lower for the leverage based method. +# +# diff --git a/docs/notebooks/scripts/03_example_pipeline.py b/docs/notebooks/scripts/03_example_pipeline.py index a5eb54c..4007eff 100644 --- a/docs/notebooks/scripts/03_example_pipeline.py +++ b/docs/notebooks/scripts/03_example_pipeline.py @@ -7,7 +7,7 @@ # format_version: '1.3' # jupytext_version: 1.16.6 # kernelspec: -# display_name: Python 3.9.4 ('rdkit') +# display_name: .venv # language: python # name: python3 # --- @@ -72,7 +72,7 @@ print(f"Train score is :{pipe.score(mol_list_train,y_train):0.2F}") print(f"Test score is :{pipe.score(mol_list_test, y_test):0.2F}") # %% [markdown] -# Nevermind the performance, or the exact value of the prediction, this is for demonstration purposes. We can easily predict on lists of molecules +# Nevermind the performance, or the exact value of the prediction, this is for demonstration purpures. We can easily predict on lists of molecules # %% pipe.predict([Chem.MolFromSmiles("c1ccccc1C(=O)[OH]")]) From 3daa51503c9ebf034b6e1074a78c93dac0caa3d6 Mon Sep 17 00:00:00 2001 From: Anton Siomchen <41703271+asiomchen@users.noreply.github.com> Date: Thu, 8 May 2025 17:54:00 +0200 Subject: [PATCH 3/7] re-pair notebooks --- .pre-commit-config.yaml | 7 +- docs/notebooks/01_basic_usage.ipynb | 3 + .../notebooks/02_descriptor_transformer.ipynb | 13 +- docs/notebooks/03_example_pipeline.ipynb | 5 +- docs/notebooks/04_standardizer.ipynb | 3 + docs/notebooks/05_smiles_sanitization.ipynb | 4 +- docs/notebooks/06_hyperparameter_tuning.ipynb | 8 +- docs/notebooks/07_parallel_transforms.ipynb | 13 +- .../notebooks/08_external_library_skopt.ipynb | 4 +- ..._Usage_with_FingerPrint_Transformers.ipynb | 4 +- .../notebooks/10_pipeline_pandas_output.ipynb | 5 +- docs/notebooks/11_safe_inference.ipynb | 5 +- .../12_custom_fingerprint_transformer.ipynb | 36 +- .../12_custom_fingerprint_transformer.py | 37 +- docs/notebooks/13_applicability_domain.ipynb | 577 +++++------------- docs/notebooks/13_applicability_domain.py | 189 +++--- docs/notebooks/scripts/01_basic_usage.py | 1 + .../scripts/02_descriptor_transformer.py | 3 + docs/notebooks/scripts/03_example_pipeline.py | 3 +- docs/notebooks/scripts/04_standardizer.py | 1 + .../scripts/05_smiles_sanitization.py | 2 +- .../scripts/06_hyperparameter_tuning.py | 6 +- .../scripts/07_parallel_transforms.py | 5 +- .../scripts/08_external_library_skopt.py | 2 +- ...hod_Usage_with_FingerPrint_Transformers.py | 2 +- .../scripts/10_pipeline_pandas_output.py | 3 +- docs/notebooks/scripts/11_safe_inference.py | 3 +- .../12_custom_fingerprint_transformer.py | 38 +- .../scripts/13_applicability_domain.py | 169 +++-- pyproject.toml | 5 +- 30 files changed, 493 insertions(+), 663 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index b7bc5c3..d03dc45 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -21,9 +21,4 @@ repos: types_or: [ python, pyi ] # Run the formatter. - id: ruff-format - -- repo: https://github.com/mwouts/jupytext - rev: v1.16.6 # CURRENT_TAG/COMMIT_HASH - hooks: - - id: jupytext - args: [--sync] \ No newline at end of file + \ No newline at end of file diff --git a/docs/notebooks/01_basic_usage.ipynb b/docs/notebooks/01_basic_usage.ipynb index 719369c..9fade04 100644 --- a/docs/notebooks/01_basic_usage.ipynb +++ b/docs/notebooks/01_basic_usage.ipynb @@ -771,6 +771,9 @@ } ], "metadata": { + "jupytext": { + "formats": "docs//notebooks//ipynb,docs//notebooks//scripts//py:percent" + }, "kernelspec": { "display_name": "Python 3.9.4 ('rdkit')", "language": "python", diff --git a/docs/notebooks/02_descriptor_transformer.ipynb b/docs/notebooks/02_descriptor_transformer.ipynb index 90c082b..dcdf2e6 100644 --- a/docs/notebooks/02_descriptor_transformer.ipynb +++ b/docs/notebooks/02_descriptor_transformer.ipynb @@ -1,5 +1,13 @@ { "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "4796a16e", + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "id": "e3cf34ca", @@ -198,13 +206,16 @@ { "cell_type": "code", "execution_count": null, - "id": "4796a16e", + "id": "310a2a0d", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { + "jupytext": { + "formats": "docs//notebooks//ipynb,docs//notebooks//scripts//py:percent" + }, "kernelspec": { "display_name": "Python 3.9.4 ('rdkit')", "language": "python", diff --git a/docs/notebooks/03_example_pipeline.ipynb b/docs/notebooks/03_example_pipeline.ipynb index 5896f4d..dddeb39 100644 --- a/docs/notebooks/03_example_pipeline.ipynb +++ b/docs/notebooks/03_example_pipeline.ipynb @@ -388,8 +388,11 @@ } ], "metadata": { + "jupytext": { + "formats": "docs//notebooks//ipynb,docs//notebooks//scripts//py:percent" + }, "kernelspec": { - "display_name": ".venv", + "display_name": "Python 3.9.4 ('rdkit')", "language": "python", "name": "python3" }, diff --git a/docs/notebooks/04_standardizer.ipynb b/docs/notebooks/04_standardizer.ipynb index 3fcd238..a16eebf 100644 --- a/docs/notebooks/04_standardizer.ipynb +++ b/docs/notebooks/04_standardizer.ipynb @@ -231,6 +231,9 @@ } ], "metadata": { + "jupytext": { + "formats": "docs//notebooks//ipynb,docs//notebooks//scripts//py:percent" + }, "kernelspec": { "display_name": "Python 3.9.4 ('rdkit')", "language": "python", diff --git a/docs/notebooks/05_smiles_sanitization.ipynb b/docs/notebooks/05_smiles_sanitization.ipynb index 84dcf35..0b44c7d 100644 --- a/docs/notebooks/05_smiles_sanitization.ipynb +++ b/docs/notebooks/05_smiles_sanitization.ipynb @@ -86,7 +86,6 @@ } ], "source": [ - "\n", "PandasTools.AddMoleculeColumnToFrame(data, smilesCol=\"SMILES\")\n", "print(f\"Dataset contains {data.ROMol.isna().sum()} unparsable mols\")" ] @@ -292,6 +291,9 @@ } ], "metadata": { + "jupytext": { + "formats": "docs//notebooks//ipynb,docs//notebooks//scripts//py:percent" + }, "kernelspec": { "display_name": "Python 3.9.4 ('rdkit')", "language": "python", diff --git a/docs/notebooks/06_hyperparameter_tuning.ipynb b/docs/notebooks/06_hyperparameter_tuning.ipynb index c6c8bb0..89cb8ef 100644 --- a/docs/notebooks/06_hyperparameter_tuning.ipynb +++ b/docs/notebooks/06_hyperparameter_tuning.ipynb @@ -104,7 +104,6 @@ } ], "source": [ - "\n", "data = pd.read_csv(csv_file)\n", "\n", "PandasTools.AddMoleculeColumnToFrame(data, smilesCol=\"SMILES\")\n", @@ -134,7 +133,6 @@ }, "outputs": [], "source": [ - "\n", "mol_list_train, mol_list_test, y_train, y_test = train_test_split(\n", " data.ROMol, data.pXC50, random_state=42\n", ")" @@ -194,7 +192,6 @@ }, "outputs": [], "source": [ - "\n", "moltransformer = MorganFingerprintTransformer()\n", "regressor = Ridge()\n", "\n", @@ -264,7 +261,6 @@ } ], "source": [ - "\n", "optimization_pipe.get_params().keys()" ] }, @@ -290,7 +286,6 @@ }, "outputs": [], "source": [ - "\n", "param_dist = {\n", " \"ridge__alpha\": loguniform(1e-2, 1e3),\n", " \"morganfingerprinttransformer__fpSize\": [256, 512, 1024, 2048, 4096],\n", @@ -538,6 +533,9 @@ } ], "metadata": { + "jupytext": { + "formats": "docs//notebooks//ipynb,docs//notebooks//scripts//py:percent" + }, "kernelspec": { "display_name": "Python 3.9.4 ('rdkit')", "language": "python", diff --git a/docs/notebooks/07_parallel_transforms.ipynb b/docs/notebooks/07_parallel_transforms.ipynb index 816fa4e..d4d913c 100644 --- a/docs/notebooks/07_parallel_transforms.ipynb +++ b/docs/notebooks/07_parallel_transforms.ipynb @@ -1,5 +1,13 @@ { "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "6f68fb8e", + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "markdown", "id": "87ed8373", @@ -703,8 +711,11 @@ } ], "metadata": { + "jupytext": { + "formats": "docs//notebooks//ipynb,docs//notebooks//scripts//py:percent" + }, "kernelspec": { - "display_name": ".venv", + "display_name": "Python 3.9.4 ('rdkit')", "language": "python", "name": "python3" }, diff --git a/docs/notebooks/08_external_library_skopt.ipynb b/docs/notebooks/08_external_library_skopt.ipynb index 4657741..c984020 100644 --- a/docs/notebooks/08_external_library_skopt.ipynb +++ b/docs/notebooks/08_external_library_skopt.ipynb @@ -769,7 +769,6 @@ } ], "source": [ - "\n", "pipe_gp = gp_minimize(objective, search_space, n_calls=10, random_state=0)\n", "\"Best score=%.4f\" % pipe_gp.fun" ] @@ -852,6 +851,9 @@ } ], "metadata": { + "jupytext": { + "formats": "docs//notebooks//ipynb,docs//notebooks//scripts//py:percent" + }, "kernelspec": { "display_name": "vscode", "language": "python", diff --git a/docs/notebooks/09_Combinatorial_Method_Usage_with_FingerPrint_Transformers.ipynb b/docs/notebooks/09_Combinatorial_Method_Usage_with_FingerPrint_Transformers.ipynb index 339afcd..839f120 100644 --- a/docs/notebooks/09_Combinatorial_Method_Usage_with_FingerPrint_Transformers.ipynb +++ b/docs/notebooks/09_Combinatorial_Method_Usage_with_FingerPrint_Transformers.ipynb @@ -151,7 +151,6 @@ } ], "source": [ - "\n", "regressor = Ridge()\n", "optimization_pipe = Pipeline(\n", " [\n", @@ -964,6 +963,9 @@ } ], "metadata": { + "jupytext": { + "formats": "docs//notebooks//ipynb,docs//notebooks//scripts//py:percent" + }, "kernelspec": { "display_name": "aniEnv", "language": "python", diff --git a/docs/notebooks/10_pipeline_pandas_output.ipynb b/docs/notebooks/10_pipeline_pandas_output.ipynb index 53eda0f..40f5c6f 100644 --- a/docs/notebooks/10_pipeline_pandas_output.ipynb +++ b/docs/notebooks/10_pipeline_pandas_output.ipynb @@ -7054,8 +7054,11 @@ } ], "metadata": { + "jupytext": { + "formats": "docs//notebooks//ipynb,docs//notebooks//scripts//py:percent" + }, "kernelspec": { - "display_name": "scikit-mol", + "display_name": "Python 3.9.4 ('rdkit')", "language": "python", "name": "python3" }, diff --git a/docs/notebooks/11_safe_inference.ipynb b/docs/notebooks/11_safe_inference.ipynb index 94edc22..66d53fd 100644 --- a/docs/notebooks/11_safe_inference.ipynb +++ b/docs/notebooks/11_safe_inference.ipynb @@ -1041,8 +1041,11 @@ } ], "metadata": { + "jupytext": { + "formats": "docs//notebooks//ipynb,docs//notebooks//scripts//py:percent" + }, "kernelspec": { - "display_name": "vscode", + "display_name": "Python 3.9.4 ('rdkit')", "language": "python", "name": "python3" }, diff --git a/docs/notebooks/12_custom_fingerprint_transformer.ipynb b/docs/notebooks/12_custom_fingerprint_transformer.ipynb index ce56b58..710cb0b 100644 --- a/docs/notebooks/12_custom_fingerprint_transformer.ipynb +++ b/docs/notebooks/12_custom_fingerprint_transformer.ipynb @@ -52,16 +52,20 @@ "import numpy as np\n", "from rdkit import Chem\n", "\n", + "\n", "class DummyFingerprintTransformer(BaseFpsTransformer):\n", - " def __init__(self, fpSize=64, n_jobs=1, safe_inference_mode = False):\n", + " def __init__(self, fpSize=64, n_jobs=1, safe_inference_mode=False):\n", " self.fpSize = fpSize\n", - " super().__init__(n_jobs=n_jobs, safe_inference_mode=safe_inference_mode, name=\"dummy\")\n", + " super().__init__(\n", + " n_jobs=n_jobs, safe_inference_mode=safe_inference_mode, name=\"dummy\"\n", + " )\n", "\n", " def _transform_mol(self, mol):\n", " return mol.GetNumAtoms() * np.ones(self.fpSize)\n", - " \n", + "\n", + "\n", "trans = DummyFingerprintTransformer(n_jobs=4)\n", - "mols = [Chem.MolFromSmiles('CC')] * 100\n", + "mols = [Chem.MolFromSmiles(\"CC\")] * 100\n", "trans.transform(mols)" ] }, @@ -104,15 +108,21 @@ "source": [ "from rdkit.Chem import rdFingerprintGenerator\n", "\n", + "\n", "class UnpickableFingerprintTransformer(BaseFpsTransformer):\n", " def __init__(self, fpSize=1024, n_jobs=1, safe_inference_mode=False, **kwargs):\n", " self.fpSize = fpSize\n", - " super().__init__(n_jobs=n_jobs, safe_inference_mode=safe_inference_mode, **kwargs)\n", - " self.fp_gen = rdFingerprintGenerator.GetRDKitFPGenerator(maxPath=2, fpSize=self.fpSize)\n", + " super().__init__(\n", + " n_jobs=n_jobs, safe_inference_mode=safe_inference_mode, **kwargs\n", + " )\n", + " self.fp_gen = rdFingerprintGenerator.GetRDKitFPGenerator(\n", + " maxPath=2, fpSize=self.fpSize\n", + " )\n", "\n", " def _transform_mol(self, mol):\n", " return self.fp_gen.GetFingerprintAsNumPy(mol)\n", - " \n", + "\n", + "\n", "trans = UnpickableFingerprintTransformer(n_jobs=4, fpSize=512)\n", "trans.transform(mols)" ] @@ -146,6 +156,7 @@ " def __init__(self, generator, n_jobs=1):\n", " self.generator = generator\n", " super().__init__(n_jobs=n_jobs)\n", + "\n", " def _transform_mol(self, mol):\n", " return self.generator.GetFingerprint(mol)\n", "\n", @@ -156,7 +167,9 @@ "try:\n", " BadTransformer(fp_gen, n_jobs=2).transform(mols)\n", "except Exception as e:\n", - " print(\"n_jobs=2 is not fine, because the generator passed as an argument is not picklable\")\n", + " print(\n", + " \"n_jobs=2 is not fine, because the generator passed as an argument is not picklable\"\n", + " )\n", " print(f\"Error msg: {e}\")" ] }, @@ -200,13 +213,16 @@ "class NamedTansformer1(UnpickableFingerprintTransformer):\n", " pass\n", "\n", + "\n", "class NamedTansformer2(UnpickableFingerprintTransformer):\n", " def __init__(self):\n", " super().__init__(name=\"fp_fancy\")\n", "\n", + "\n", "class FancyFingerprintTransformer(UnpickableFingerprintTransformer):\n", " pass\n", "\n", + "\n", "print(NamedTansformer1().get_feature_names_out())\n", "print(NamedTansformer2().get_feature_names_out())\n", "print(FancyFingerprintTransformer().get_feature_names_out())" @@ -215,10 +231,10 @@ ], "metadata": { "jupytext": { - "formats": "ipynb,py:percent" + "formats": "docs//notebooks//ipynb,docs//notebooks//scripts//py:percent" }, "kernelspec": { - "display_name": "vscode", + "display_name": "Python 3.9.4 ('rdkit')", "language": "python", "name": "python3" }, diff --git a/docs/notebooks/12_custom_fingerprint_transformer.py b/docs/notebooks/12_custom_fingerprint_transformer.py index 0fb6988..f4ba1b1 100644 --- a/docs/notebooks/12_custom_fingerprint_transformer.py +++ b/docs/notebooks/12_custom_fingerprint_transformer.py @@ -32,16 +32,20 @@ import numpy as np from rdkit import Chem + class DummyFingerprintTransformer(BaseFpsTransformer): - def __init__(self, fpSize=64, n_jobs=1, safe_inference_mode = False): + def __init__(self, fpSize=64, n_jobs=1, safe_inference_mode=False): self.fpSize = fpSize - super().__init__(n_jobs=n_jobs, safe_inference_mode=safe_inference_mode, name="dummy") + super().__init__( + n_jobs=n_jobs, safe_inference_mode=safe_inference_mode, name="dummy" + ) def _transform_mol(self, mol): return mol.GetNumAtoms() * np.ones(self.fpSize) - + + trans = DummyFingerprintTransformer(n_jobs=4) -mols = [Chem.MolFromSmiles('CC')] * 100 +mols = [Chem.MolFromSmiles("CC")] * 100 trans.transform(mols) # %% [markdown] @@ -55,15 +59,21 @@ def _transform_mol(self, mol): # %% from rdkit.Chem import rdFingerprintGenerator + class UnpickableFingerprintTransformer(BaseFpsTransformer): def __init__(self, fpSize=1024, n_jobs=1, safe_inference_mode=False, **kwargs): self.fpSize = fpSize - super().__init__(n_jobs=n_jobs, safe_inference_mode=safe_inference_mode, **kwargs) - self.fp_gen = rdFingerprintGenerator.GetRDKitFPGenerator(maxPath=2, fpSize=self.fpSize) + super().__init__( + n_jobs=n_jobs, safe_inference_mode=safe_inference_mode, **kwargs + ) + self.fp_gen = rdFingerprintGenerator.GetRDKitFPGenerator( + maxPath=2, fpSize=self.fpSize + ) def _transform_mol(self, mol): return self.fp_gen.GetFingerprintAsNumPy(mol) - + + trans = UnpickableFingerprintTransformer(n_jobs=4, fpSize=512) trans.transform(mols) @@ -71,11 +81,13 @@ def _transform_mol(self, mol): # %% [markdown] # Non-pickable object should not be present among the `__init__` arguments of the transformer. Doing so will prevent them to be pickled to recreate a transformer instance in the worker processes. If you for some reason need to pass a non-pickable object to the transformer you can do so (**highly discouraged**, please [open the issue](https://github.com/EBjerrum/scikit-mol/issues), maybe we will be able to help you do it better) by using the transformer in the sequential mode (i.e. `n_jobs=1`). + # %% class BadTransformer(BaseFpsTransformer): def __init__(self, generator, n_jobs=1): self.generator = generator super().__init__(n_jobs=n_jobs) + def _transform_mol(self, mol): return self.generator.GetFingerprint(mol) @@ -86,32 +98,37 @@ def _transform_mol(self, mol): try: BadTransformer(fp_gen, n_jobs=2).transform(mols) except Exception as e: - print("n_jobs=2 is not fine, because the generator passed as an argument is not picklable") + print( + "n_jobs=2 is not fine, because the generator passed as an argument is not picklable" + ) print(f"Error msg: {e}") # %% [markdown] # ## Fingerprint name # -# To use the fingerptint in the `pandas` output mode it needes to know the name of the fingerprint and the number of bits (features) in it to generate the columns names. The number of feature is derived from `fpSize` attribute +# To use the fingerptint in the `pandas` output mode it needes to know the name of the fingerprint and the number of bits (features) in it to generate the columns names. The number of feature is derived from `fpSize` attribute # # And the name resolution works as follows (in order of priority): # - if the fingerprint has a name set during the initialization of the base class, it is used # - if the name of the class follows the pattern `XFingerprintTransformer`, the name (`fp_X`) is extracted from it # - as a last resort, the name is set to name of the class + # %% class NamedTansformer1(UnpickableFingerprintTransformer): pass + class NamedTansformer2(UnpickableFingerprintTransformer): def __init__(self): super().__init__(name="fp_fancy") + class FancyFingerprintTransformer(UnpickableFingerprintTransformer): pass + print(NamedTansformer1().get_feature_names_out()) print(NamedTansformer2().get_feature_names_out()) print(FancyFingerprintTransformer().get_feature_names_out()) - diff --git a/docs/notebooks/13_applicability_domain.ipynb b/docs/notebooks/13_applicability_domain.ipynb index f11dad4..01fa965 100644 --- a/docs/notebooks/13_applicability_domain.ipynb +++ b/docs/notebooks/13_applicability_domain.ipynb @@ -26,7 +26,6 @@ "import numpy as np\n", "import pandas as pd\n", "from rdkit import Chem\n", - "from rdkit.Chem import Draw\n", "from rdkit.Chem import PandasTools\n", "import matplotlib.pyplot as plt\n", "from sklearn.model_selection import train_test_split\n", @@ -34,9 +33,8 @@ "from sklearn.pipeline import Pipeline\n", "from sklearn.preprocessing import StandardScaler\n", "from sklearn.decomposition import PCA\n", - "import pathlib\n", - "\n", "\n", + "from scikit_mol.conversions import SmilesToMolTransformer\n", "from scikit_mol.fingerprints import MorganFingerprintTransformer\n", "from scikit_mol.applicability import KNNApplicabilityDomain, LeverageApplicabilityDomain" ] @@ -64,21 +62,11 @@ } ], "source": [ - "full_set = True\n", - "\n", - "if full_set:\n", - " csv_file = \"SLC6A4_active_excape_export.csv\"\n", - " if not pathlib.Path(csv_file).exists():\n", - " import urllib.request\n", - "\n", - " url = \"https://ndownloader.figshare.com/files/25747817\"\n", - " urllib.request.urlretrieve(url, csv_file)\n", - "else:\n", - " csv_file = \"../tests/data/SLC6A4_active_excapedb_subset.csv\"\n", - "\n", + "# Load the dataset\n", + "csv_file = \"../tests/data/SLC6A4_active_excapedb_subset.csv\"\n", "data = pd.read_csv(csv_file)\n", "\n", - "#Could also build a pipeline to convert the smiles to mols using SmilesToMolTransformer\n", + "# Add RDKit mol objects\n", "PandasTools.AddMoleculeColumnToFrame(data, smilesCol=\"SMILES\")\n", "print(f\"{data.ROMol.isna().sum()} out of {len(data)} SMILES failed in conversion\")\n", "\n", @@ -87,7 +75,9 @@ "y = data.pXC50\n", "\n", "X_temp, X_test, y_temp, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n", - "X_train, X_val, y_train, y_val = train_test_split(X_temp, y_temp, test_size=0.25, random_state=42)" + "X_train, X_val, y_train, y_val = train_test_split(\n", + " X_temp, y_temp, test_size=0.25, random_state=42\n", + ")" ] }, { @@ -549,22 +539,44 @@ ], "source": [ "# Create pipeline for binary fingerprints\n", - "binary_fp_pipe = Pipeline([\n", - " ('fp', MorganFingerprintTransformer(fpSize=2048, radius=2)),\n", - " ('rf', RandomForestRegressor(n_estimators=100, random_state=0xf00d, n_jobs=-1))\n", - "])\n", + "binary_fp_pipe = Pipeline(\n", + " [\n", + " (\"fp\", MorganFingerprintTransformer(fpSize=2048, radius=2)),\n", + " (\"rf\", RandomForestRegressor(n_estimators=100, random_state=42)),\n", + " ]\n", + ")\n", "\n", "# Train the model\n", - "binary_fp_pipe.fit(X_train, y_train)" + "binary_fp_pipe.fit(X_train, y_train)\n", + "\n", + "# Get predictions and errors\n", + "y_pred_test = binary_fp_pipe.predict(X_test)\n", + "abs_errors = np.abs(y_test - y_pred_test)\n", + "\n", + "# Create and fit k-NN AD estimator\n", + "knn_ad = KNNApplicabilityDomain(n_neighbors=3, distance_metric=\"tanimoto\")\n", + "knn_ad.fit(binary_fp_pipe.named_steps[\"fp\"].transform(X_train))\n", + "\n", + "# Fit threshold using validation set\n", + "knn_ad.fit_threshold(binary_fp_pipe.named_steps[\"fp\"].transform(X_val))\n", + "\n", + "# Get AD scores for test set\n", + "knn_scores = knn_ad.transform(binary_fp_pipe.named_steps[\"fp\"].transform(X_test))" + ] + }, + { + "cell_type": "markdown", + "id": "a7f33a3f", + "metadata": {}, + "source": [ + "Let's visualize the relationship between prediction errors and AD scores:" ] }, { "cell_type": "code", "execution_count": 9, "id": "ee7b2f64", - "metadata": { - "lines_to_next_cell": 2 - }, + "metadata": {}, "outputs": [ { "name": "stderr", @@ -596,130 +608,17 @@ } ], "source": [ - "\n", - "# Get predictions and errors\n", - "y_pred_test = binary_fp_pipe.predict(X_test)\n", - "abs_errors = np.abs(y_test - y_pred_test)\n", - "\n", - "\n", - "fig = plt.figure(figsize=(3,3))\n", - "\n", - "plt.scatter(y_test, abs_errors, alpha=0.5)\n", - "plt.xlabel('pXC50')\n", - "plt.ylabel('Predicted Absolute Error')\n", - "plt.title('Predicted pXC50 vs Absolute Error')" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "9d2860b4", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/esben/envs/vscode/lib/python3.10/site-packages/numpy/core/fromnumeric.py:59: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", - " return bound(*args, **kwds)\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/metrics/pairwise.py:2466: DataConversionWarning: Data was converted to boolean for metric jaccard\n", - " warnings.warn(msg, DataConversionWarning)\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/numpy/core/fromnumeric.py:59: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", - " return bound(*args, **kwds)\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/metrics/pairwise.py:2466: DataConversionWarning: Data was converted to boolean for metric jaccard\n", - " warnings.warn(msg, DataConversionWarning)\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/numpy/core/fromnumeric.py:59: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", - " return bound(*args, **kwds)\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/metrics/pairwise.py:2466: DataConversionWarning: Data was converted to boolean for metric jaccard\n", - " warnings.warn(msg, DataConversionWarning)\n" - ] - } - ], - "source": [ - "\n", - "# Create and fit k-NN AD estimator. Distance metrics follow the scikit-learn API, and the custom distance metric tanimoto popular in cheminformatics is available in scikit-mol.\n", - "knn_ad = KNNApplicabilityDomain(n_neighbors=3, distance_metric='tanimoto', n_jobs=-1)\n", - "knn_ad.fit(binary_fp_pipe.named_steps['fp'].transform(X_train))\n", - "\n", - "# Fit threshold using validation set\n", - "knn_ad.fit_threshold(binary_fp_pipe.named_steps['fp'].transform(X_val), target_percentile=95)\n", - "\n", - "# Get AD scores for test set\n", - "knn_scores = knn_ad.transform(binary_fp_pipe.named_steps['fp'].transform(X_test))" - ] - }, - { - "cell_type": "markdown", - "id": "22848529", - "metadata": {}, - "source": [ - "Let's visualize the relationship between prediction errors and AD scores, and calculate some statistics on compound errors within and outside the domain." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "e8e2bb86", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/esben/envs/vscode/lib/python3.10/site-packages/numpy/core/fromnumeric.py:59: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", - " return bound(*args, **kwds)\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/metrics/pairwise.py:2466: DataConversionWarning: Data was converted to boolean for metric jaccard\n", - " warnings.warn(msg, DataConversionWarning)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "95th percentile of errors inside domain: 1.45\n", - "95th percentile of errors outside domain: 1.85\n", - "Fraction of samples outside domain: 0.04\n" - ] - } - ], - "source": [ - "plt.figure(figsize=(4, 3))\n", + "plt.figure(figsize=(10, 6))\n", "plt.scatter(knn_scores, abs_errors, alpha=0.5)\n", - "plt.axvline(x=knn_ad.threshold_, color='r', linestyle='--', label='AD Threshold')\n", - "plt.xlabel('k-NN AD Score')\n", - "plt.ylabel('Absolute Prediction Error')\n", - "plt.title('Prediction Errors vs k-NN AD Scores')\n", + "plt.axvline(x=knn_ad.threshold_, color=\"r\", linestyle=\"--\", label=\"AD Threshold\")\n", + "plt.xlabel(\"k-NN AD Score\")\n", + "plt.ylabel(\"Absolute Prediction Error\")\n", + "plt.title(\"Prediction Errors vs k-NN AD Scores\")\n", "plt.legend()\n", "plt.show()\n", "\n", "# Calculate error statistics\n", - "in_domain = knn_ad.predict(binary_fp_pipe.named_steps['fp'].transform(X_test))\n", + "in_domain = knn_ad.predict(binary_fp_pipe.named_steps[\"fp\"].transform(X_test))\n", "errors_in = abs_errors[in_domain == 1]\n", "errors_out = abs_errors[in_domain == -1]\n", "\n", @@ -728,14 +627,6 @@ "print(f\"Fraction of samples outside domain: {(in_domain == -1).mean():.2f}\")" ] }, - { - "cell_type": "markdown", - "id": "10e69073", - "metadata": {}, - "source": [ - "There's some diffence in the errors distribution inside and outside the domain threshold, but maybe not as clear-cut as we could have wished for. The fraction of samples outside the domain in the test-set are close the 5% that corresponds to the threshold estimated from the validation set fractile of 95%." - ] - }, { "cell_type": "markdown", "id": "09bdc3b2", @@ -1199,108 +1090,92 @@ } ], "source": [ - "# Create pipeline for count-based fingerprints AD estimation with PCA, scaling and leverage\n", - "count_fp_pipe = Pipeline([\n", - " ('fp', MorganFingerprintTransformer(fpSize=2048, radius=2, useCounts=True)),\n", - " ('pca', PCA(n_components=0.9)), # Keep 90% of variance\n", - " ('scaler', StandardScaler()),\n", - " ('leverage', LeverageApplicabilityDomain())\n", - "])\n", + "# Create pipeline for count-based fingerprints with PCA\n", + "count_fp_pipe = Pipeline(\n", + " [\n", + " (\"fp\", MorganFingerprintTransformer(fpSize=2048, radius=2, useCounts=True)),\n", + " (\"pca\", PCA(n_components=0.9)), # Keep 90% of variance\n", + " (\"scaler\", StandardScaler()),\n", + " (\"rf\", RandomForestRegressor(n_estimators=100, random_state=42)),\n", + " ]\n", + ")\n", "\n", "# Train the model\n", - "count_fp_pipe.fit(X_train, y_train)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "57d73a11", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/esben/envs/vscode/lib/python3.10/site-packages/numpy/core/fromnumeric.py:59: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", - " return bound(*args, **kwds)\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/numpy/core/fromnumeric.py:59: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", - " return bound(*args, **kwds)\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n" - ] - } - ], - "source": [ + "count_fp_pipe.fit(X_train, y_train)\n", + "\n", + "# Get predictions and errors\n", + "y_pred_test = count_fp_pipe.predict(X_test)\n", + "abs_errors = np.abs(y_test - y_pred_test)\n", "\n", - "X_val_transformed = count_fp_pipe[:-1].transform(X_val) #Index into pipeline to get all the pipeline up to thelast step before the AD estimator\n", - "count_fp_pipe.named_steps['leverage'].fit_threshold(X_val_transformed, target_percentile=95)\n", + "# Create and fit leverage AD estimator\n", + "leverage_ad = LeverageApplicabilityDomain()\n", + "X_train_transformed = count_fp_pipe.named_steps[\"scaler\"].transform(\n", + " count_fp_pipe.named_steps[\"pca\"].transform(\n", + " count_fp_pipe.named_steps[\"fp\"].transform(X_train)\n", + " )\n", + ")\n", + "leverage_ad.fit(X_train_transformed)\n", "\n", + "# Fit threshold using validation set\n", + "X_val_transformed = count_fp_pipe.named_steps[\"scaler\"].transform(\n", + " count_fp_pipe.named_steps[\"pca\"].transform(\n", + " count_fp_pipe.named_steps[\"fp\"].transform(X_val)\n", + " )\n", + ")\n", + "leverage_ad.fit_threshold(X_val_transformed)\n", "\n", "# Get AD scores for test set\n", - "X_test_transformed = count_fp_pipe[:-1].transform(X_test) #Index into pipeline to get the last step before the AD estimator \n", - "leverage_raw_scores = count_fp_pipe.named_steps['leverage'].transform(X_test_transformed)" + "X_test_transformed = count_fp_pipe.named_steps[\"scaler\"].transform(\n", + " count_fp_pipe.named_steps[\"pca\"].transform(\n", + " count_fp_pipe.named_steps[\"fp\"].transform(X_test)\n", + " )\n", + ")\n", + "leverage_scores = leverage_ad.transform(X_test_transformed)" ] }, { "cell_type": "markdown", - "id": "fd5c6718", + "id": "d7723e37", "metadata": {}, "source": [ - "As before, let's visualize the relationship between prediction errors and leverage scores and look at the fractiles errors." + "Visualize the relationship between prediction errors and leverage scores:" ] }, { "cell_type": "code", - "execution_count": 15, - "id": "41434c9d", + "execution_count": 13, + "id": "57d73a11", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ + "/home/esben/envs/vscode/lib/python3.10/site-packages/numpy/core/fromnumeric.py:59: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", " warnings.warn(\n", "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/home/esben/envs/vscode/lib/python3.10/site-packages/numpy/core/fromnumeric.py:59: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", " warnings.warn(\n" ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "95th percentile of errors inside domain: 1.50\n", - "95th percentile of errors outside domain: 1.23\n", - "Fraction of samples outside domain: 0.05\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ - "plt.figure(figsize=(4, 3))\n", - "plt.scatter(leverage_raw_scores, abs_errors, alpha=0.5)\n", - "plt.axvline(x=count_fp_pipe.named_steps['leverage'].threshold_, color='r', linestyle='--', label='AD Threshold')\n", - "plt.xlabel('Leverage AD Score')\n", - "plt.ylabel('Absolute Prediction Error')\n", - "plt.title('Prediction Errors vs Leverage Scores')\n", + "plt.figure(figsize=(10, 6))\n", + "plt.scatter(leverage_scores, abs_errors, alpha=0.5)\n", + "plt.axvline(x=leverage_ad.threshold_, color=\"r\", linestyle=\"--\", label=\"AD Threshold\")\n", + "plt.xlabel(\"Leverage AD Score\")\n", + "plt.ylabel(\"Absolute Prediction Error\")\n", + "plt.title(\"Prediction Errors vs Leverage Scores\")\n", "plt.legend()\n", - "\n", + "plt.show()\n", "\n", "# Calculate error statistics\n", - "in_domain = count_fp_pipe.named_steps['leverage'].predict(X_test_transformed)\n", + "in_domain = leverage_ad.predict(X_test_transformed)\n", "errors_in = abs_errors[in_domain == 1]\n", "errors_out = abs_errors[in_domain == -1]\n", "\n", @@ -1309,14 +1184,6 @@ "print(f\"Fraction of samples outside domain: {(in_domain == -1).mean():.2f}\")" ] }, - { - "cell_type": "markdown", - "id": "86f8a09e", - "metadata": {}, - "source": [ - "Dissappointingly the error seems larger within the domain, than outside the domain." - ] - }, { "cell_type": "markdown", "id": "e22b19f0", @@ -1348,206 +1215,52 @@ "source": [ "# Define famous drugs\n", "famous_drugs = {\n", - " 'Aspirin': 'CC(=O)OC1=CC=CC=C1C(=O)O',\n", - " 'Viagra': 'CCc1nn(C)c2c(=O)[nH]c(nc12)c3cc(ccc3OCC)S(=O)(=O)N4CCN(C)CC4',\n", - " 'Heroin': 'CN1CC[C@]23[C@H]4Oc5c(O)ccc(CC1[C@H]2C=C[C@@H]4O3)c5',\n", + " \"Aspirin\": \"CC(=O)OC1=CC=CC=C1C(=O)O\",\n", + " \"Viagra\": \"CCc1nn(C)c2c(=O)[nH]c(nc12)c3cc(ccc3OCC)S(=O)(=O)N4CCN(C)CC4\",\n", + " \"Heroin\": \"CN1CC[C@]23[C@H]4Oc5c(O)ccc(CC1[C@H]2C=C[C@@H]4O3)c5\",\n", "}\n", "\n", "\n", - "Draw.MolsToGridImage([Chem.MolFromSmiles(drug) for drug in famous_drugs.values()], molsPerRow=3,\n", - " subImgSize=(250,250), legends=[f\"{name}\" for name, smiles in famous_drugs.items()])" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "904ed0d0", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/metrics/pairwise.py:2466: DataConversionWarning: Data was converted to boolean for metric jaccard\n", - " warnings.warn(msg, DataConversionWarning)\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/metrics/pairwise.py:2466: DataConversionWarning: Data was converted to boolean for metric jaccard\n", - " warnings.warn(msg, DataConversionWarning)\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/metrics/pairwise.py:2466: DataConversionWarning: Data was converted to boolean for metric jaccard\n", - " warnings.warn(msg, DataConversionWarning)\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/metrics/pairwise.py:2466: DataConversionWarning: Data was converted to boolean for metric jaccard\n", - " warnings.warn(msg, DataConversionWarning)\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/metrics/pairwise.py:2466: DataConversionWarning: Data was converted to boolean for metric jaccard\n", - " warnings.warn(msg, DataConversionWarning)\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/metrics/pairwise.py:2466: DataConversionWarning: Data was converted to boolean for metric jaccard\n", - " warnings.warn(msg, DataConversionWarning)\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\n", - "/home/esben/envs/vscode/lib/python3.10/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", - " warnings.warn(\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", - "
Predicted pIC50k-NN Scorek-NN StatusLeverage ScoreLeverage Status
Drug
Aspirin5.900.719194Outside0.020058Inside
Viagra9.050.786921Outside0.050743Inside
Heroin6.450.812649Outside0.021588Inside
\n", - "
" - ], - "text/plain": [ - " Predicted pIC50 k-NN Score k-NN Status Leverage Score \\\n", - "Drug \n", - "Aspirin 5.90 0.719194 Outside 0.020058 \n", - "Viagra 9.05 0.786921 Outside 0.050743 \n", - "Heroin 6.45 0.812649 Outside 0.021588 \n", - "\n", - " Leverage Status \n", - "Drug \n", - "Aspirin Inside \n", - "Viagra Inside \n", - "Heroin Inside " - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "\n", - "leverage_ad = count_fp_pipe.named_steps['leverage']\n", - "\n", "# Function to process a drug through both AD pipelines\n", "def check_drug_applicability(smiles, name):\n", " mol = Chem.MolFromSmiles(smiles)\n", - " \n", + "\n", " # k-NN AD\n", - " fp_binary = binary_fp_pipe.named_steps['fp'].transform([mol])\n", + " fp_binary = binary_fp_pipe.named_steps[\"fp\"].transform([mol])\n", " knn_score = knn_ad.transform(fp_binary)[0][0]\n", " knn_status = \"Inside\" if knn_ad.predict(fp_binary)[0] == 1 else \"Outside\"\n", - " \n", + "\n", " # Leverage AD\n", - " fp_count = count_fp_pipe.named_steps['fp'].transform([mol])\n", - " fp_pca = count_fp_pipe.named_steps['pca'].transform(fp_count)\n", - " fp_scaled = count_fp_pipe.named_steps['scaler'].transform(fp_pca)\n", + " fp_count = count_fp_pipe.named_steps[\"fp\"].transform([mol])\n", + " fp_pca = count_fp_pipe.named_steps[\"pca\"].transform(fp_count)\n", + " fp_scaled = count_fp_pipe.named_steps[\"scaler\"].transform(fp_pca)\n", " leverage_score = leverage_ad.transform(fp_scaled)[0][0]\n", " leverage_status = \"Inside\" if leverage_ad.predict(fp_scaled)[0] == 1 else \"Outside\"\n", - " \n", - " # Get prediction\n", - " pred_pIC50 = binary_fp_pipe.predict([mol])[0]\n", - " \n", + "\n", " return {\n", - " 'knn_score': knn_score,\n", - " 'knn_status': knn_status,\n", - " 'leverage_score': leverage_score,\n", - " 'leverage_status': leverage_status,\n", - " 'pred_pIC50': pred_pIC50\n", + " \"knn_score\": knn_score,\n", + " \"knn_status\": knn_status,\n", + " \"leverage_score\": leverage_score,\n", + " \"leverage_status\": leverage_status,\n", " }\n", "\n", + "\n", "# Process each drug\n", "results = []\n", "for name, smiles in famous_drugs.items():\n", " result = check_drug_applicability(smiles, name)\n", - " results.append({\n", - " 'Drug': name,\n", - " 'Predicted pIC50': f\"{result['pred_pIC50']:.2f}\",\n", - " 'k-NN Score': result['knn_score'],\n", - " 'k-NN Status': result['knn_status'],\n", - " 'Leverage Score': result['leverage_score'],\n", - " 'Leverage Status': result['leverage_status']\n", - " })\n", + " results.append(\n", + " {\n", + " \"Drug\": name,\n", + " \"k-NN Score\": result[\"knn_score\"],\n", + " \"k-NN Status\": result[\"knn_status\"],\n", + " \"Leverage Score\": result[\"leverage_score\"],\n", + " \"Leverage Status\": result[\"leverage_status\"],\n", + " }\n", + " )\n", "\n", "# Display results\n", - "pd.DataFrame(results).set_index('Drug')" + "pd.DataFrame(results).set_index(\"Drug\")" ] }, { @@ -1579,31 +1292,31 @@ "# Plot for k-NN AD\n", "plt.figure(figsize=(12, 5))\n", "plt.subplot(1, 2, 1)\n", - "plt.scatter(knn_scores, abs_errors, alpha=0.2, label='Test compounds')\n", - "plt.axvline(x=knn_ad.threshold_, color='r', linestyle='--', label='AD Threshold')\n", + "plt.scatter(knn_scores, abs_errors, alpha=0.2, label=\"Test compounds\")\n", + "plt.axvline(x=knn_ad.threshold_, color=\"r\", linestyle=\"--\", label=\"AD Threshold\")\n", "\n", "for result in results:\n", - " plt.axvline(x=result['k-NN Score'], color='g', alpha=0.5,\n", - " label=f\"{result['Drug']}\")\n", + " plt.axvline(x=result[\"k-NN Score\"], color=\"g\", alpha=0.5, label=f\"{result['Drug']}\")\n", "\n", - "plt.xlabel('k-NN AD Score')\n", - "plt.ylabel('Absolute Prediction Error')\n", - "plt.title('k-NN AD Scores')\n", - "#plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')\n", + "plt.xlabel(\"k-NN AD Score\")\n", + "plt.ylabel(\"Absolute Prediction Error\")\n", + "plt.title(\"k-NN AD Scores\")\n", + "plt.legend(bbox_to_anchor=(1.05, 1), loc=\"upper left\")\n", "\n", "# Plot for Leverage AD\n", "plt.subplot(1, 2, 2)\n", - "plt.scatter(leverage_raw_scores, abs_errors, alpha=0.2, label='Test compounds')\n", - "plt.axvline(x=leverage_ad.threshold_, color='r', linestyle='--', label='AD Threshold')\n", + "plt.scatter(leverage_scores, abs_errors, alpha=0.2, label=\"Test compounds\")\n", + "plt.axvline(x=leverage_ad.threshold_, color=\"r\", linestyle=\"--\", label=\"AD Threshold\")\n", "\n", "for result in results:\n", - " plt.axvline(x=result['Leverage Score'], color='g', alpha=0.5,\n", - " label=f\"{result['Drug']}\")\n", + " plt.axvline(\n", + " x=result[\"Leverage Score\"], color=\"g\", alpha=0.5, label=f\"{result['Drug']}\"\n", + " )\n", "\n", - "plt.xlabel('Leverage AD Score')\n", - "plt.ylabel('Absolute Prediction Error')\n", - "plt.title('Leverage AD Scores')\n", - "plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')\n", + "plt.xlabel(\"Leverage AD Score\")\n", + "plt.ylabel(\"Absolute Prediction Error\")\n", + "plt.title(\"Leverage AD Scores\")\n", + "plt.legend(bbox_to_anchor=(1.05, 1), loc=\"upper left\")\n", "\n", "plt.tight_layout()\n", "plt.show()" @@ -1614,7 +1327,7 @@ "id": "3c018e68", "metadata": {}, "source": [ - "## Conclusions on testing the AD estimators\n", + "## Conclusions\n", "\n", "This notebook demonstrated two different approaches to applicability domain estimation:\n", "\n", @@ -1624,22 +1337,20 @@ "2. The leverage-based approach with count-based fingerprints and dimensionality reduction focuses on the statistical\n", "novelty of compounds in the reduced feature space.\n", "\n", - "Heroin and Aspirin was predicted to have a low affinity, whereas Viagra was predicted as having a ~9 pXC50 corresponding to nanomolar affinity. As the regression model had only been trained on actives it will have a tendency to always predict things as active, which is hard to believe for compounds so dissimilar to the training set and with our prior knowledge about their primary targets.\n", - "\n", - "The famous drugs we tested showed marked differences between the two AD estimation techniques. \n", + "The famous drugs we tested showed varying degrees of being within the applicability domain, which makes sense given\n", + "that our training set is focused on SLC6A4 actives, while these drugs have different primary targets.\n", "\n", - "The kNN based method using tanimoto distance showed all test drugs to be distant from the training set and thus outside the applicability domain, whereas the leverage method gave the \"green light\" for all of them. As the drug have different primary targets than the SLC6A4 serotonin transporter, it seems like the kNN based method in this instance (dataset, featurization, ML-model) is a better way to estimate the AD for given novel compounds. This is consistent with our analysis of the 95 percentile of the absolute errors for two different methods, where kNN had a higher 95% percentile error outside the domain, it was lower for the leverage based method.\n", - "\n" + "The error analysis shows that compounds outside the applicability domain tend to have higher prediction errors,\n", + "validating the usefulness of these approaches for identifying potentially unreliable predictions." ] } ], "metadata": { "jupytext": { - "cell_metadata_filter": "-all", - "formats": "ipynb,py:percent" + "formats": "docs//notebooks//ipynb,docs//notebooks//scripts//py:percent" }, "kernelspec": { - "display_name": "vscode", + "display_name": "Python 3.9.4 ('rdkit')", "language": "python", "name": "python3" }, diff --git a/docs/notebooks/13_applicability_domain.py b/docs/notebooks/13_applicability_domain.py index 8e01e47..899c023 100644 --- a/docs/notebooks/13_applicability_domain.py +++ b/docs/notebooks/13_applicability_domain.py @@ -61,7 +61,7 @@ data = pd.read_csv(csv_file) -#Could also build a pipeline to convert the smiles to mols using SmilesToMolTransformer +# Could also build a pipeline to convert the smiles to mols using SmilesToMolTransformer PandasTools.AddMoleculeColumnToFrame(data, smilesCol="SMILES") print(f"{data.ROMol.isna().sum()} out of {len(data)} SMILES failed in conversion") @@ -70,7 +70,9 @@ y = data.pXC50 X_temp, X_test, y_temp, y_test = train_test_split(X, y, test_size=0.2, random_state=42) -X_train, X_val, y_train, y_val = train_test_split(X_temp, y_temp, test_size=0.25, random_state=42) +X_train, X_val, y_train, y_val = train_test_split( + X_temp, y_temp, test_size=0.25, random_state=42 +) # %% [markdown] # ## Example 1: k-NN Applicability Domain with Binary Morgan Fingerprints @@ -80,10 +82,12 @@ # %% # Create pipeline for binary fingerprints -binary_fp_pipe = Pipeline([ - ('fp', MorganFingerprintTransformer(fpSize=2048, radius=2)), - ('rf', RandomForestRegressor(n_estimators=100, random_state=0xf00d, n_jobs=-1)) -]) +binary_fp_pipe = Pipeline( + [ + ("fp", MorganFingerprintTransformer(fpSize=2048, radius=2)), + ("rf", RandomForestRegressor(n_estimators=100, random_state=0xF00D, n_jobs=-1)), + ] +) # Train the model binary_fp_pipe.fit(X_train, y_train) @@ -95,25 +99,27 @@ abs_errors = np.abs(y_test - y_pred_test) -fig = plt.figure(figsize=(3,3)) +fig = plt.figure(figsize=(3, 3)) plt.scatter(y_test, abs_errors, alpha=0.5) -plt.xlabel('pXC50') -plt.ylabel('Predicted Absolute Error') -plt.title('Predicted pXC50 vs Absolute Error') +plt.xlabel("pXC50") +plt.ylabel("Predicted Absolute Error") +plt.title("Predicted pXC50 vs Absolute Error") # %% # Create and fit k-NN AD estimator. Distance metrics follow the scikit-learn API, and the custom distance metric tanimoto popular in cheminformatics is available in scikit-mol. -knn_ad = KNNApplicabilityDomain(n_neighbors=3, distance_metric='tanimoto', n_jobs=-1) -knn_ad.fit(binary_fp_pipe.named_steps['fp'].transform(X_train)) +knn_ad = KNNApplicabilityDomain(n_neighbors=3, distance_metric="tanimoto", n_jobs=-1) +knn_ad.fit(binary_fp_pipe.named_steps["fp"].transform(X_train)) # Fit threshold using validation set -knn_ad.fit_threshold(binary_fp_pipe.named_steps['fp'].transform(X_val), target_percentile=95) +knn_ad.fit_threshold( + binary_fp_pipe.named_steps["fp"].transform(X_val), target_percentile=95 +) # Get AD scores for test set -knn_scores = knn_ad.transform(binary_fp_pipe.named_steps['fp'].transform(X_test)) +knn_scores = knn_ad.transform(binary_fp_pipe.named_steps["fp"].transform(X_test)) # %% [markdown] # Let's visualize the relationship between prediction errors and AD scores, and calculate some statistics on compound errors within and outside the domain. @@ -121,15 +127,15 @@ # %% plt.figure(figsize=(4, 3)) plt.scatter(knn_scores, abs_errors, alpha=0.5) -plt.axvline(x=knn_ad.threshold_, color='r', linestyle='--', label='AD Threshold') -plt.xlabel('k-NN AD Score') -plt.ylabel('Absolute Prediction Error') -plt.title('Prediction Errors vs k-NN AD Scores') +plt.axvline(x=knn_ad.threshold_, color="r", linestyle="--", label="AD Threshold") +plt.xlabel("k-NN AD Score") +plt.ylabel("Absolute Prediction Error") +plt.title("Prediction Errors vs k-NN AD Scores") plt.legend() plt.show() # Calculate error statistics -in_domain = knn_ad.predict(binary_fp_pipe.named_steps['fp'].transform(X_test)) +in_domain = knn_ad.predict(binary_fp_pipe.named_steps["fp"].transform(X_test)) errors_in = abs_errors[in_domain == 1] errors_out = abs_errors[in_domain == -1] @@ -148,25 +154,37 @@ # %% # Create pipeline for count-based fingerprints AD estimation with PCA, scaling and leverage -count_fp_pipe = Pipeline([ - ('fp', MorganFingerprintTransformer(fpSize=2048, radius=2, useCounts=True)), - ('pca', PCA(n_components=0.9)), # Keep 90% of variance - ('scaler', StandardScaler()), - ('leverage', LeverageApplicabilityDomain()) -]) +count_fp_pipe = Pipeline( + [ + ("fp", MorganFingerprintTransformer(fpSize=2048, radius=2, useCounts=True)), + ("pca", PCA(n_components=0.9)), # Keep 90% of variance + ("scaler", StandardScaler()), + ("leverage", LeverageApplicabilityDomain()), + ] +) # Train the model count_fp_pipe.fit(X_train, y_train) # %% -X_val_transformed = count_fp_pipe[:-1].transform(X_val) #Index into pipeline to get all the pipeline up to thelast step before the AD estimator -count_fp_pipe.named_steps['leverage'].fit_threshold(X_val_transformed, target_percentile=95) +X_val_transformed = count_fp_pipe[ + :-1 +].transform( + X_val +) # Index into pipeline to get all the pipeline up to thelast step before the AD estimator +count_fp_pipe.named_steps["leverage"].fit_threshold( + X_val_transformed, target_percentile=95 +) # Get AD scores for test set -X_test_transformed = count_fp_pipe[:-1].transform(X_test) #Index into pipeline to get the last step before the AD estimator -leverage_raw_scores = count_fp_pipe.named_steps['leverage'].transform(X_test_transformed) +X_test_transformed = count_fp_pipe[:-1].transform( + X_test +) # Index into pipeline to get the last step before the AD estimator +leverage_raw_scores = count_fp_pipe.named_steps["leverage"].transform( + X_test_transformed +) # %% [markdown] # As before, let's visualize the relationship between prediction errors and leverage scores and look at the fractiles errors. @@ -174,15 +192,20 @@ # %% plt.figure(figsize=(4, 3)) plt.scatter(leverage_raw_scores, abs_errors, alpha=0.5) -plt.axvline(x=count_fp_pipe.named_steps['leverage'].threshold_, color='r', linestyle='--', label='AD Threshold') -plt.xlabel('Leverage AD Score') -plt.ylabel('Absolute Prediction Error') -plt.title('Prediction Errors vs Leverage Scores') +plt.axvline( + x=count_fp_pipe.named_steps["leverage"].threshold_, + color="r", + linestyle="--", + label="AD Threshold", +) +plt.xlabel("Leverage AD Score") +plt.ylabel("Absolute Prediction Error") +plt.title("Prediction Errors vs Leverage Scores") plt.legend() # Calculate error statistics -in_domain = count_fp_pipe.named_steps['leverage'].predict(X_test_transformed) +in_domain = count_fp_pipe.named_steps["leverage"].predict(X_test_transformed) errors_in = abs_errors[in_domain == 1] errors_out = abs_errors[in_domain == -1] @@ -201,61 +224,69 @@ # %% # Define famous drugs famous_drugs = { - 'Aspirin': 'CC(=O)OC1=CC=CC=C1C(=O)O', - 'Viagra': 'CCc1nn(C)c2c(=O)[nH]c(nc12)c3cc(ccc3OCC)S(=O)(=O)N4CCN(C)CC4', - 'Heroin': 'CN1CC[C@]23[C@H]4Oc5c(O)ccc(CC1[C@H]2C=C[C@@H]4O3)c5', + "Aspirin": "CC(=O)OC1=CC=CC=C1C(=O)O", + "Viagra": "CCc1nn(C)c2c(=O)[nH]c(nc12)c3cc(ccc3OCC)S(=O)(=O)N4CCN(C)CC4", + "Heroin": "CN1CC[C@]23[C@H]4Oc5c(O)ccc(CC1[C@H]2C=C[C@@H]4O3)c5", } -Draw.MolsToGridImage([Chem.MolFromSmiles(drug) for drug in famous_drugs.values()], molsPerRow=3, - subImgSize=(250,250), legends=[f"{name}" for name, smiles in famous_drugs.items()]) +Draw.MolsToGridImage( + [Chem.MolFromSmiles(drug) for drug in famous_drugs.values()], + molsPerRow=3, + subImgSize=(250, 250), + legends=[f"{name}" for name, smiles in famous_drugs.items()], +) # %% -leverage_ad = count_fp_pipe.named_steps['leverage'] +leverage_ad = count_fp_pipe.named_steps["leverage"] + # Function to process a drug through both AD pipelines def check_drug_applicability(smiles, name): mol = Chem.MolFromSmiles(smiles) - + # k-NN AD - fp_binary = binary_fp_pipe.named_steps['fp'].transform([mol]) + fp_binary = binary_fp_pipe.named_steps["fp"].transform([mol]) knn_score = knn_ad.transform(fp_binary)[0][0] knn_status = "Inside" if knn_ad.predict(fp_binary)[0] == 1 else "Outside" - + # Leverage AD - fp_count = count_fp_pipe.named_steps['fp'].transform([mol]) - fp_pca = count_fp_pipe.named_steps['pca'].transform(fp_count) - fp_scaled = count_fp_pipe.named_steps['scaler'].transform(fp_pca) + fp_count = count_fp_pipe.named_steps["fp"].transform([mol]) + fp_pca = count_fp_pipe.named_steps["pca"].transform(fp_count) + fp_scaled = count_fp_pipe.named_steps["scaler"].transform(fp_pca) leverage_score = leverage_ad.transform(fp_scaled)[0][0] leverage_status = "Inside" if leverage_ad.predict(fp_scaled)[0] == 1 else "Outside" - + # Get prediction pred_pIC50 = binary_fp_pipe.predict([mol])[0] - + return { - 'knn_score': knn_score, - 'knn_status': knn_status, - 'leverage_score': leverage_score, - 'leverage_status': leverage_status, - 'pred_pIC50': pred_pIC50 + "knn_score": knn_score, + "knn_status": knn_status, + "leverage_score": leverage_score, + "leverage_status": leverage_status, + "pred_pIC50": pred_pIC50, } + # Process each drug results = [] for name, smiles in famous_drugs.items(): result = check_drug_applicability(smiles, name) - results.append({ - 'Drug': name, - 'Predicted pIC50': f"{result['pred_pIC50']:.2f}", - 'k-NN Score': result['knn_score'], - 'k-NN Status': result['knn_status'], - 'Leverage Score': result['leverage_score'], - 'Leverage Status': result['leverage_status'] - }) + results.append( + { + "Drug": name, + "Predicted pIC50": f"{result['pred_pIC50']:.2f}", + "k-NN Score": result["knn_score"], + "k-NN Status": result["knn_status"], + "Leverage Score": result["leverage_score"], + "Leverage Status": result["leverage_status"], + } + ) # Display results -pd.DataFrame(results).set_index('Drug') +pd.DataFrame(results).set_index("Drug") # %% [markdown] # Let's visualize where these drugs fall in our AD plots: @@ -264,31 +295,31 @@ def check_drug_applicability(smiles, name): # Plot for k-NN AD plt.figure(figsize=(12, 5)) plt.subplot(1, 2, 1) -plt.scatter(knn_scores, abs_errors, alpha=0.2, label='Test compounds') -plt.axvline(x=knn_ad.threshold_, color='r', linestyle='--', label='AD Threshold') +plt.scatter(knn_scores, abs_errors, alpha=0.2, label="Test compounds") +plt.axvline(x=knn_ad.threshold_, color="r", linestyle="--", label="AD Threshold") for result in results: - plt.axvline(x=result['k-NN Score'], color='g', alpha=0.5, - label=f"{result['Drug']}") + plt.axvline(x=result["k-NN Score"], color="g", alpha=0.5, label=f"{result['Drug']}") -plt.xlabel('k-NN AD Score') -plt.ylabel('Absolute Prediction Error') -plt.title('k-NN AD Scores') -#plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left') +plt.xlabel("k-NN AD Score") +plt.ylabel("Absolute Prediction Error") +plt.title("k-NN AD Scores") +# plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left') # Plot for Leverage AD plt.subplot(1, 2, 2) -plt.scatter(leverage_raw_scores, abs_errors, alpha=0.2, label='Test compounds') -plt.axvline(x=leverage_ad.threshold_, color='r', linestyle='--', label='AD Threshold') +plt.scatter(leverage_raw_scores, abs_errors, alpha=0.2, label="Test compounds") +plt.axvline(x=leverage_ad.threshold_, color="r", linestyle="--", label="AD Threshold") for result in results: - plt.axvline(x=result['Leverage Score'], color='g', alpha=0.5, - label=f"{result['Drug']}") + plt.axvline( + x=result["Leverage Score"], color="g", alpha=0.5, label=f"{result['Drug']}" + ) -plt.xlabel('Leverage AD Score') -plt.ylabel('Absolute Prediction Error') -plt.title('Leverage AD Scores') -plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left') +plt.xlabel("Leverage AD Score") +plt.ylabel("Absolute Prediction Error") +plt.title("Leverage AD Scores") +plt.legend(bbox_to_anchor=(1.05, 1), loc="upper left") plt.tight_layout() plt.show() @@ -306,7 +337,7 @@ def check_drug_applicability(smiles, name): # # Heroin and Aspirin was predicted to have a low affinity, whereas Viagra was predicted as having a ~9 pXC50 corresponding to nanomolar affinity. As the regression model had only been trained on actives it will have a tendency to always predict things as active, which is hard to believe for compounds so dissimilar to the training set and with our prior knowledge about their primary targets. # -# The famous drugs we tested showed marked differences between the two AD estimation techniques. +# The famous drugs we tested showed marked differences between the two AD estimation techniques. # # The kNN based method using tanimoto distance showed all test drugs to be distant from the training set and thus outside the applicability domain, whereas the leverage method gave the "green light" for all of them. As the drug have different primary targets than the SLC6A4 serotonin transporter, it seems like the kNN based method in this instance (dataset, featurization, ML-model) is a better way to estimate the AD for given novel compounds. This is consistent with our analysis of the 95 percentile of the absolute errors for two different methods, where kNN had a higher 95% percentile error outside the domain, it was lower for the leverage based method. # diff --git a/docs/notebooks/scripts/01_basic_usage.py b/docs/notebooks/scripts/01_basic_usage.py index a0d7a71..062dc18 100644 --- a/docs/notebooks/scripts/01_basic_usage.py +++ b/docs/notebooks/scripts/01_basic_usage.py @@ -1,6 +1,7 @@ # --- # jupyter: # jupytext: +# formats: docs//notebooks//ipynb,docs//notebooks//scripts//py:percent # text_representation: # extension: .py # format_name: percent diff --git a/docs/notebooks/scripts/02_descriptor_transformer.py b/docs/notebooks/scripts/02_descriptor_transformer.py index d3312e4..ba47c3f 100644 --- a/docs/notebooks/scripts/02_descriptor_transformer.py +++ b/docs/notebooks/scripts/02_descriptor_transformer.py @@ -1,6 +1,7 @@ # --- # jupyter: # jupytext: +# formats: docs//notebooks//ipynb,docs//notebooks//scripts//py:percent # text_representation: # extension: .py # format_name: percent @@ -12,6 +13,8 @@ # name: python3 # --- +# %% + # %% [markdown] # # Desc2DTransformer: RDKit descriptors transformer # diff --git a/docs/notebooks/scripts/03_example_pipeline.py b/docs/notebooks/scripts/03_example_pipeline.py index 4007eff..267b000 100644 --- a/docs/notebooks/scripts/03_example_pipeline.py +++ b/docs/notebooks/scripts/03_example_pipeline.py @@ -1,13 +1,14 @@ # --- # jupyter: # jupytext: +# formats: docs//notebooks//ipynb,docs//notebooks//scripts//py:percent # text_representation: # extension: .py # format_name: percent # format_version: '1.3' # jupytext_version: 1.16.6 # kernelspec: -# display_name: .venv +# display_name: Python 3.9.4 ('rdkit') # language: python # name: python3 # --- diff --git a/docs/notebooks/scripts/04_standardizer.py b/docs/notebooks/scripts/04_standardizer.py index 6b64ccb..7f9d089 100644 --- a/docs/notebooks/scripts/04_standardizer.py +++ b/docs/notebooks/scripts/04_standardizer.py @@ -1,6 +1,7 @@ # --- # jupyter: # jupytext: +# formats: docs//notebooks//ipynb,docs//notebooks//scripts//py:percent # text_representation: # extension: .py # format_name: percent diff --git a/docs/notebooks/scripts/05_smiles_sanitization.py b/docs/notebooks/scripts/05_smiles_sanitization.py index bc34f2f..c5338b3 100644 --- a/docs/notebooks/scripts/05_smiles_sanitization.py +++ b/docs/notebooks/scripts/05_smiles_sanitization.py @@ -1,6 +1,7 @@ # --- # jupyter: # jupytext: +# formats: docs//notebooks//ipynb,docs//notebooks//scripts//py:percent # text_representation: # extension: .py # format_name: percent @@ -31,7 +32,6 @@ data.loc[1, "SMILES"] = "CN(C)(C)(C)" # %% - PandasTools.AddMoleculeColumnToFrame(data, smilesCol="SMILES") print(f"Dataset contains {data.ROMol.isna().sum()} unparsable mols") diff --git a/docs/notebooks/scripts/06_hyperparameter_tuning.py b/docs/notebooks/scripts/06_hyperparameter_tuning.py index a068be4..aa425ac 100644 --- a/docs/notebooks/scripts/06_hyperparameter_tuning.py +++ b/docs/notebooks/scripts/06_hyperparameter_tuning.py @@ -1,6 +1,7 @@ # --- # jupyter: # jupytext: +# formats: docs//notebooks//ipynb,docs//notebooks//scripts//py:percent # text_representation: # extension: .py # format_name: percent @@ -52,7 +53,6 @@ # The CSV data is loaded into a Pandas dataframe and the PandasTools utility from RDKit is used to add a column with RDKit molecules # %% - data = pd.read_csv(csv_file) PandasTools.AddMoleculeColumnToFrame(data, smilesCol="SMILES") @@ -62,7 +62,6 @@ # We use the train_test_split to, well, split the dataframe's molecule columns and pXC50 column into lists for train and testing # %% - mol_list_train, mol_list_test, y_train, y_test = train_test_split( data.ROMol, data.pXC50, random_state=42 ) @@ -84,7 +83,6 @@ # A simple pipeline with a MorganTransformer and a Ridge() regression for demonstration. # %% - moltransformer = MorganFingerprintTransformer() regressor = Ridge() @@ -104,14 +102,12 @@ # With the pipelines, getting the names of the parameters to tune is a bit more tricky, as they are concatenations of the name of the step and the parameter with double underscores in between. We can get the available parameters from the pipeline with the get_params() method, and select the parameters we want to change from there. # %% Which keys do we have? - optimization_pipe.get_params().keys() # %% [markdown] # We will tune the regularization strength of the Ridge regressor, and try out different parameters for the Morgan fingerprint, namely the number of bits, the radius of the fingerprint, wheter to use counts or bits and features. # %% - param_dist = { "ridge__alpha": loguniform(1e-2, 1e3), "morganfingerprinttransformer__fpSize": [256, 512, 1024, 2048, 4096], diff --git a/docs/notebooks/scripts/07_parallel_transforms.py b/docs/notebooks/scripts/07_parallel_transforms.py index b8068fe..2ff57a7 100644 --- a/docs/notebooks/scripts/07_parallel_transforms.py +++ b/docs/notebooks/scripts/07_parallel_transforms.py @@ -1,17 +1,20 @@ # --- # jupyter: # jupytext: +# formats: docs//notebooks//ipynb,docs//notebooks//scripts//py:percent # text_representation: # extension: .py # format_name: percent # format_version: '1.3' # jupytext_version: 1.16.6 # kernelspec: -# display_name: .venv +# display_name: Python 3.9.4 ('rdkit') # language: python # name: python3 # --- +# %% + # %% [markdown] # # Parallel calculations of transforms # diff --git a/docs/notebooks/scripts/08_external_library_skopt.py b/docs/notebooks/scripts/08_external_library_skopt.py index e8b0225..14dc493 100644 --- a/docs/notebooks/scripts/08_external_library_skopt.py +++ b/docs/notebooks/scripts/08_external_library_skopt.py @@ -1,6 +1,7 @@ # --- # jupyter: # jupytext: +# formats: docs//notebooks//ipynb,docs//notebooks//scripts//py:percent # text_representation: # extension: .py # format_name: percent @@ -94,7 +95,6 @@ def objective(**params): # %% THIS takes forever on my machine with a GradientBoostingRegressor - pipe_gp = gp_minimize(objective, search_space, n_calls=10, random_state=0) "Best score=%.4f" % pipe_gp.fun # %% diff --git a/docs/notebooks/scripts/09_Combinatorial_Method_Usage_with_FingerPrint_Transformers.py b/docs/notebooks/scripts/09_Combinatorial_Method_Usage_with_FingerPrint_Transformers.py index d9b55f0..48c1f5b 100644 --- a/docs/notebooks/scripts/09_Combinatorial_Method_Usage_with_FingerPrint_Transformers.py +++ b/docs/notebooks/scripts/09_Combinatorial_Method_Usage_with_FingerPrint_Transformers.py @@ -1,6 +1,7 @@ # --- # jupyter: # jupytext: +# formats: docs//notebooks//ipynb,docs//notebooks//scripts//py:percent # text_representation: # extension: .py # format_name: percent @@ -82,7 +83,6 @@ # This way we can define multiple different scenarios in `param_grid`, that allow us to rapidly explore different combinations of settings and methodologies. # %% - regressor = Ridge() optimization_pipe = Pipeline( [ diff --git a/docs/notebooks/scripts/10_pipeline_pandas_output.py b/docs/notebooks/scripts/10_pipeline_pandas_output.py index 2e3d9e5..64158b8 100644 --- a/docs/notebooks/scripts/10_pipeline_pandas_output.py +++ b/docs/notebooks/scripts/10_pipeline_pandas_output.py @@ -1,13 +1,14 @@ # --- # jupyter: # jupytext: +# formats: docs//notebooks//ipynb,docs//notebooks//scripts//py:percent # text_representation: # extension: .py # format_name: percent # format_version: '1.3' # jupytext_version: 1.16.6 # kernelspec: -# display_name: scikit-mol +# display_name: Python 3.9.4 ('rdkit') # language: python # name: python3 # --- diff --git a/docs/notebooks/scripts/11_safe_inference.py b/docs/notebooks/scripts/11_safe_inference.py index 45ae4af..fab5502 100644 --- a/docs/notebooks/scripts/11_safe_inference.py +++ b/docs/notebooks/scripts/11_safe_inference.py @@ -1,13 +1,14 @@ # --- # jupyter: # jupytext: +# formats: docs//notebooks//ipynb,docs//notebooks//scripts//py:percent # text_representation: # extension: .py # format_name: percent # format_version: '1.3' # jupytext_version: 1.16.6 # kernelspec: -# display_name: vscode +# display_name: Python 3.9.4 ('rdkit') # language: python # name: python3 # --- diff --git a/docs/notebooks/scripts/12_custom_fingerprint_transformer.py b/docs/notebooks/scripts/12_custom_fingerprint_transformer.py index e128dbd..1ca80c4 100644 --- a/docs/notebooks/scripts/12_custom_fingerprint_transformer.py +++ b/docs/notebooks/scripts/12_custom_fingerprint_transformer.py @@ -1,14 +1,14 @@ # --- # jupyter: # jupytext: -# formats: ipynb,py:percent +# formats: docs//notebooks//ipynb,docs//notebooks//scripts//py:percent # text_representation: # extension: .py # format_name: percent # format_version: '1.3' -# jupytext_version: 1.16.1 +# jupytext_version: 1.16.6 # kernelspec: -# display_name: .venv +# display_name: Python 3.9.4 ('rdkit') # language: python # name: python3 # --- @@ -32,16 +32,20 @@ import numpy as np from rdkit import Chem + class DummyFingerprintTransformer(BaseFpsTransformer): - def __init__(self, fpSize=64, n_jobs=1, safe_inference_mode = False): + def __init__(self, fpSize=64, n_jobs=1, safe_inference_mode=False): self.fpSize = fpSize - super().__init__(n_jobs=n_jobs, safe_inference_mode=safe_inference_mode, name="dummy") + super().__init__( + n_jobs=n_jobs, safe_inference_mode=safe_inference_mode, name="dummy" + ) def _transform_mol(self, mol): return mol.GetNumAtoms() * np.ones(self.fpSize) - + + trans = DummyFingerprintTransformer(n_jobs=4) -mols = [Chem.MolFromSmiles('CC')] * 100 +mols = [Chem.MolFromSmiles("CC")] * 100 trans.transform(mols) # %% [markdown] @@ -55,15 +59,21 @@ def _transform_mol(self, mol): # %% from rdkit.Chem import rdFingerprintGenerator + class UnpickableFingerprintTransformer(BaseFpsTransformer): def __init__(self, fpSize=1024, n_jobs=1, safe_inference_mode=False, **kwargs): self.fpSize = fpSize - super().__init__(n_jobs=n_jobs, safe_inference_mode=safe_inference_mode, **kwargs) - self.fp_gen = rdFingerprintGenerator.GetRDKitFPGenerator(maxPath=2, fpSize=self.fpSize) + super().__init__( + n_jobs=n_jobs, safe_inference_mode=safe_inference_mode, **kwargs + ) + self.fp_gen = rdFingerprintGenerator.GetRDKitFPGenerator( + maxPath=2, fpSize=self.fpSize + ) def _transform_mol(self, mol): return self.fp_gen.GetFingerprintAsNumPy(mol) - + + trans = UnpickableFingerprintTransformer(n_jobs=4, fpSize=512) trans.transform(mols) @@ -76,6 +86,7 @@ class BadTransformer(BaseFpsTransformer): def __init__(self, generator, n_jobs=1): self.generator = generator super().__init__(n_jobs=n_jobs) + def _transform_mol(self, mol): return self.generator.GetFingerprint(mol) @@ -86,7 +97,9 @@ def _transform_mol(self, mol): try: BadTransformer(fp_gen, n_jobs=2).transform(mols) except Exception as e: - print("n_jobs=2 is not fine, because the generator passed as an argument is not picklable") + print( + "n_jobs=2 is not fine, because the generator passed as an argument is not picklable" + ) print(f"Error msg: {e}") @@ -104,13 +117,16 @@ def _transform_mol(self, mol): class NamedTansformer1(UnpickableFingerprintTransformer): pass + class NamedTansformer2(UnpickableFingerprintTransformer): def __init__(self): super().__init__(name="fp_fancy") + class FancyFingerprintTransformer(UnpickableFingerprintTransformer): pass + print(NamedTansformer1().get_feature_names_out()) print(NamedTansformer2().get_feature_names_out()) print(FancyFingerprintTransformer().get_feature_names_out()) diff --git a/docs/notebooks/scripts/13_applicability_domain.py b/docs/notebooks/scripts/13_applicability_domain.py index 7baa492..d6e3ebf 100644 --- a/docs/notebooks/scripts/13_applicability_domain.py +++ b/docs/notebooks/scripts/13_applicability_domain.py @@ -1,27 +1,14 @@ # --- # jupyter: # jupytext: -# cell_metadata_filter: -all -# formats: ipynb,py:percent +# formats: docs//notebooks//ipynb,docs//notebooks//scripts//py:percent # text_representation: # extension: .py # format_name: percent # format_version: '1.3' # jupytext_version: 1.16.6 -# --- - -# %% -# --- -# jupyter: -# jupytext: -# formats: ipynb,py:percent -# text_representation: -# extension: .py -# format_name: percent -# format_version: '1.3' -# jupytext_version: 1.16.1 # kernelspec: -# display_name: Python 3 (ipykernel) +# display_name: Python 3.9.4 ('rdkit') # language: python # name: python3 # --- @@ -70,7 +57,9 @@ y = data.pXC50 X_temp, X_test, y_temp, y_test = train_test_split(X, y, test_size=0.2, random_state=42) -X_train, X_val, y_train, y_val = train_test_split(X_temp, y_temp, test_size=0.25, random_state=42) +X_train, X_val, y_train, y_val = train_test_split( + X_temp, y_temp, test_size=0.25, random_state=42 +) # %% [markdown] # ## Example 1: k-NN Applicability Domain with Binary Morgan Fingerprints @@ -80,10 +69,12 @@ # %% # Create pipeline for binary fingerprints -binary_fp_pipe = Pipeline([ - ('fp', MorganFingerprintTransformer(fpSize=2048, radius=2)), - ('rf', RandomForestRegressor(n_estimators=100, random_state=42)) -]) +binary_fp_pipe = Pipeline( + [ + ("fp", MorganFingerprintTransformer(fpSize=2048, radius=2)), + ("rf", RandomForestRegressor(n_estimators=100, random_state=42)), + ] +) # Train the model binary_fp_pipe.fit(X_train, y_train) @@ -93,14 +84,14 @@ abs_errors = np.abs(y_test - y_pred_test) # Create and fit k-NN AD estimator -knn_ad = KNNApplicabilityDomain(n_neighbors=3, distance_metric='tanimoto') -knn_ad.fit(binary_fp_pipe.named_steps['fp'].transform(X_train)) +knn_ad = KNNApplicabilityDomain(n_neighbors=3, distance_metric="tanimoto") +knn_ad.fit(binary_fp_pipe.named_steps["fp"].transform(X_train)) # Fit threshold using validation set -knn_ad.fit_threshold(binary_fp_pipe.named_steps['fp'].transform(X_val)) +knn_ad.fit_threshold(binary_fp_pipe.named_steps["fp"].transform(X_val)) # Get AD scores for test set -knn_scores = knn_ad.transform(binary_fp_pipe.named_steps['fp'].transform(X_test)) +knn_scores = knn_ad.transform(binary_fp_pipe.named_steps["fp"].transform(X_test)) # %% [markdown] # Let's visualize the relationship between prediction errors and AD scores: @@ -108,15 +99,15 @@ # %% plt.figure(figsize=(10, 6)) plt.scatter(knn_scores, abs_errors, alpha=0.5) -plt.axvline(x=knn_ad.threshold_, color='r', linestyle='--', label='AD Threshold') -plt.xlabel('k-NN AD Score') -plt.ylabel('Absolute Prediction Error') -plt.title('Prediction Errors vs k-NN AD Scores') +plt.axvline(x=knn_ad.threshold_, color="r", linestyle="--", label="AD Threshold") +plt.xlabel("k-NN AD Score") +plt.ylabel("Absolute Prediction Error") +plt.title("Prediction Errors vs k-NN AD Scores") plt.legend() plt.show() # Calculate error statistics -in_domain = knn_ad.predict(binary_fp_pipe.named_steps['fp'].transform(X_test)) +in_domain = knn_ad.predict(binary_fp_pipe.named_steps["fp"].transform(X_test)) errors_in = abs_errors[in_domain == 1] errors_out = abs_errors[in_domain == -1] @@ -132,12 +123,14 @@ # %% # Create pipeline for count-based fingerprints with PCA -count_fp_pipe = Pipeline([ - ('fp', MorganFingerprintTransformer(fpSize=2048, radius=2, useCounts=True)), - ('pca', PCA(n_components=0.9)), # Keep 90% of variance - ('scaler', StandardScaler()), - ('rf', RandomForestRegressor(n_estimators=100, random_state=42)) -]) +count_fp_pipe = Pipeline( + [ + ("fp", MorganFingerprintTransformer(fpSize=2048, radius=2, useCounts=True)), + ("pca", PCA(n_components=0.9)), # Keep 90% of variance + ("scaler", StandardScaler()), + ("rf", RandomForestRegressor(n_estimators=100, random_state=42)), + ] +) # Train the model count_fp_pipe.fit(X_train, y_train) @@ -148,25 +141,25 @@ # Create and fit leverage AD estimator leverage_ad = LeverageApplicabilityDomain() -X_train_transformed = count_fp_pipe.named_steps['scaler'].transform( - count_fp_pipe.named_steps['pca'].transform( - count_fp_pipe.named_steps['fp'].transform(X_train) +X_train_transformed = count_fp_pipe.named_steps["scaler"].transform( + count_fp_pipe.named_steps["pca"].transform( + count_fp_pipe.named_steps["fp"].transform(X_train) ) ) leverage_ad.fit(X_train_transformed) # Fit threshold using validation set -X_val_transformed = count_fp_pipe.named_steps['scaler'].transform( - count_fp_pipe.named_steps['pca'].transform( - count_fp_pipe.named_steps['fp'].transform(X_val) +X_val_transformed = count_fp_pipe.named_steps["scaler"].transform( + count_fp_pipe.named_steps["pca"].transform( + count_fp_pipe.named_steps["fp"].transform(X_val) ) ) leverage_ad.fit_threshold(X_val_transformed) # Get AD scores for test set -X_test_transformed = count_fp_pipe.named_steps['scaler'].transform( - count_fp_pipe.named_steps['pca'].transform( - count_fp_pipe.named_steps['fp'].transform(X_test) +X_test_transformed = count_fp_pipe.named_steps["scaler"].transform( + count_fp_pipe.named_steps["pca"].transform( + count_fp_pipe.named_steps["fp"].transform(X_test) ) ) leverage_scores = leverage_ad.transform(X_test_transformed) @@ -177,10 +170,10 @@ # %% plt.figure(figsize=(10, 6)) plt.scatter(leverage_scores, abs_errors, alpha=0.5) -plt.axvline(x=leverage_ad.threshold_, color='r', linestyle='--', label='AD Threshold') -plt.xlabel('Leverage AD Score') -plt.ylabel('Absolute Prediction Error') -plt.title('Prediction Errors vs Leverage Scores') +plt.axvline(x=leverage_ad.threshold_, color="r", linestyle="--", label="AD Threshold") +plt.xlabel("Leverage AD Score") +plt.ylabel("Absolute Prediction Error") +plt.title("Prediction Errors vs Leverage Scores") plt.legend() plt.show() @@ -201,48 +194,52 @@ # %% # Define famous drugs famous_drugs = { - 'Aspirin': 'CC(=O)OC1=CC=CC=C1C(=O)O', - 'Viagra': 'CCc1nn(C)c2c(=O)[nH]c(nc12)c3cc(ccc3OCC)S(=O)(=O)N4CCN(C)CC4', - 'Heroin': 'CN1CC[C@]23[C@H]4Oc5c(O)ccc(CC1[C@H]2C=C[C@@H]4O3)c5', + "Aspirin": "CC(=O)OC1=CC=CC=C1C(=O)O", + "Viagra": "CCc1nn(C)c2c(=O)[nH]c(nc12)c3cc(ccc3OCC)S(=O)(=O)N4CCN(C)CC4", + "Heroin": "CN1CC[C@]23[C@H]4Oc5c(O)ccc(CC1[C@H]2C=C[C@@H]4O3)c5", } + # Function to process a drug through both AD pipelines def check_drug_applicability(smiles, name): mol = Chem.MolFromSmiles(smiles) - + # k-NN AD - fp_binary = binary_fp_pipe.named_steps['fp'].transform([mol]) + fp_binary = binary_fp_pipe.named_steps["fp"].transform([mol]) knn_score = knn_ad.transform(fp_binary)[0][0] knn_status = "Inside" if knn_ad.predict(fp_binary)[0] == 1 else "Outside" - + # Leverage AD - fp_count = count_fp_pipe.named_steps['fp'].transform([mol]) - fp_pca = count_fp_pipe.named_steps['pca'].transform(fp_count) - fp_scaled = count_fp_pipe.named_steps['scaler'].transform(fp_pca) + fp_count = count_fp_pipe.named_steps["fp"].transform([mol]) + fp_pca = count_fp_pipe.named_steps["pca"].transform(fp_count) + fp_scaled = count_fp_pipe.named_steps["scaler"].transform(fp_pca) leverage_score = leverage_ad.transform(fp_scaled)[0][0] leverage_status = "Inside" if leverage_ad.predict(fp_scaled)[0] == 1 else "Outside" - + return { - 'knn_score': knn_score, - 'knn_status': knn_status, - 'leverage_score': leverage_score, - 'leverage_status': leverage_status + "knn_score": knn_score, + "knn_status": knn_status, + "leverage_score": leverage_score, + "leverage_status": leverage_status, } + # Process each drug results = [] for name, smiles in famous_drugs.items(): result = check_drug_applicability(smiles, name) - results.append({ - 'Drug': name, - 'k-NN Score': result['knn_score'], - 'k-NN Status': result['knn_status'], - 'Leverage Score': result['leverage_score'], - 'Leverage Status': result['leverage_status'] - }) + results.append( + { + "Drug": name, + "k-NN Score": result["knn_score"], + "k-NN Status": result["knn_status"], + "Leverage Score": result["leverage_score"], + "Leverage Status": result["leverage_status"], + } + ) # Display results -pd.DataFrame(results).set_index('Drug') +pd.DataFrame(results).set_index("Drug") # %% [markdown] # Let's visualize where these drugs fall in our AD plots: @@ -251,31 +248,31 @@ def check_drug_applicability(smiles, name): # Plot for k-NN AD plt.figure(figsize=(12, 5)) plt.subplot(1, 2, 1) -plt.scatter(knn_scores, abs_errors, alpha=0.2, label='Test compounds') -plt.axvline(x=knn_ad.threshold_, color='r', linestyle='--', label='AD Threshold') +plt.scatter(knn_scores, abs_errors, alpha=0.2, label="Test compounds") +plt.axvline(x=knn_ad.threshold_, color="r", linestyle="--", label="AD Threshold") for result in results: - plt.axvline(x=result['k-NN Score'], color='g', alpha=0.5, - label=f"{result['Drug']}") + plt.axvline(x=result["k-NN Score"], color="g", alpha=0.5, label=f"{result['Drug']}") -plt.xlabel('k-NN AD Score') -plt.ylabel('Absolute Prediction Error') -plt.title('k-NN AD Scores') -plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left') +plt.xlabel("k-NN AD Score") +plt.ylabel("Absolute Prediction Error") +plt.title("k-NN AD Scores") +plt.legend(bbox_to_anchor=(1.05, 1), loc="upper left") # Plot for Leverage AD plt.subplot(1, 2, 2) -plt.scatter(leverage_scores, abs_errors, alpha=0.2, label='Test compounds') -plt.axvline(x=leverage_ad.threshold_, color='r', linestyle='--', label='AD Threshold') +plt.scatter(leverage_scores, abs_errors, alpha=0.2, label="Test compounds") +plt.axvline(x=leverage_ad.threshold_, color="r", linestyle="--", label="AD Threshold") for result in results: - plt.axvline(x=result['Leverage Score'], color='g', alpha=0.5, - label=f"{result['Drug']}") + plt.axvline( + x=result["Leverage Score"], color="g", alpha=0.5, label=f"{result['Drug']}" + ) -plt.xlabel('Leverage AD Score') -plt.ylabel('Absolute Prediction Error') -plt.title('Leverage AD Scores') -plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left') +plt.xlabel("Leverage AD Score") +plt.ylabel("Absolute Prediction Error") +plt.title("Leverage AD Scores") +plt.legend(bbox_to_anchor=(1.05, 1), loc="upper left") plt.tight_layout() plt.show() diff --git a/pyproject.toml b/pyproject.toml index 84586c9..57d799b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -105,6 +105,5 @@ docs = [ ] -[tool.jupytext.formats] -"docs/notebooks/" = "ipynb" -"docs/notebooks/scripts" = "py:percent" +[tool.jupytext] +formats = "docs//notebooks//ipynb,docs//notebooks//scripts//py:percent" From 8aaaa52df3df08ae0a39d2a2ce60912525641dcd Mon Sep 17 00:00:00 2001 From: Anton Siomchen <41703271+asiomchen@users.noreply.github.com> Date: Thu, 8 May 2025 18:15:30 +0200 Subject: [PATCH 4/7] add more info about the sync --- docs/contributing.md | 7 +- docs/notebooks/01_basic_usage.ipynb | 39 +- .../notebooks/02_descriptor_transformer.ipynb | 28 +- docs/notebooks/03_example_pipeline.ipynb | 43 ++- .../12_custom_fingerprint_transformer.py | 134 ------- docs/notebooks/13_applicability_domain.py | 344 ------------------ .../scripts/02_descriptor_transformer.py | 4 +- docs/notebooks/scripts/03_example_pipeline.py | 4 +- 8 files changed, 67 insertions(+), 536 deletions(-) delete mode 100644 docs/notebooks/12_custom_fingerprint_transformer.py delete mode 100644 docs/notebooks/13_applicability_domain.py diff --git a/docs/contributing.md b/docs/contributing.md index 5095a71..45b04a4 100644 --- a/docs/contributing.md +++ b/docs/contributing.md @@ -94,11 +94,14 @@ Scikit-Learn has a check_estimator that we should strive to get to work, some cl ## Notebooks Another way of contributing is by providing notebooks with examples on how to use the project to build models together with Scikit-Learn and other tools. There are .ipynb files in the `docs/notebooks` and .py files in the `script` subfolder as the first are useful for online rendering in the documentation, whereas the latter is useful for sub version control. -If you want to create new notebook you can create .ipynb file, and then you run `make sync-notebooks` to create the corresponding .py file for the commit. + +If you want to create new notebook you can first create .ipynb file, and then you run `make sync-notebooks` to create the corresponding .py file for the commit. + +If you updated any of the existing py/ipynb files, you can run `make sync-notebooks` to update the outdated file in the pair. The .py files are used for nice diffs, and the .ipynb files are used for rendering in the documentation. `make sync-notebooks` will sync all the notebooks with the .py files in the `scripts` folder. -`make run-notebooks` will sync, run and save the notebooks, expects an ipython kernel with scikit-mol installed called Python3. +`make run-notebooks` will sync, run and save the notebooks, expects an ipython kernel with scikit-mol installed. ## Documentation diff --git a/docs/notebooks/01_basic_usage.ipynb b/docs/notebooks/01_basic_usage.ipynb index 9fade04..78e212b 100644 --- a/docs/notebooks/01_basic_usage.ipynb +++ b/docs/notebooks/01_basic_usage.ipynb @@ -130,7 +130,8 @@ "text/html": [ "
MorganFingerprintTransformer(radius=3)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + "
MorganFingerprintTransformer(radius=3)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" ], "text/plain": [ "MorganFingerprintTransformer(radius=3)" @@ -572,7 +583,7 @@ "data": { "text/plain": [ "{'fpSize': 2048,\n", - " 'parallel': False,\n", + " 'n_jobs': None,\n", " 'radius': 3,\n", " 'safe_inference_mode': False,\n", " 'useBondTypes': True,\n", @@ -690,7 +701,7 @@ " [1, 0, 0, ..., 0, 0, 0],\n", " [0, 0, 0, ..., 0, 0, 1],\n", " [1, 1, 0, ..., 0, 0, 0],\n", - " [1, 1, 0, ..., 0, 0, 0]], dtype=uint8)" + " [1, 1, 0, ..., 0, 0, 0]], shape=(6, 256), dtype=uint8)" ] }, "execution_count": 8, @@ -756,12 +767,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "[[]\n", - " []\n", - " []\n", - " []\n", - " []\n", - " []]\n" + "[[]\n", + " []\n", + " []\n", + " []\n", + " []\n", + " []]\n" ] } ], @@ -775,7 +786,7 @@ "formats": "docs//notebooks//ipynb,docs//notebooks//scripts//py:percent" }, "kernelspec": { - "display_name": "Python 3.9.4 ('rdkit')", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -789,7 +800,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.12.6" } }, "nbformat": 4, diff --git a/docs/notebooks/02_descriptor_transformer.ipynb b/docs/notebooks/02_descriptor_transformer.ipynb index dcdf2e6..2e84a79 100644 --- a/docs/notebooks/02_descriptor_transformer.ipynb +++ b/docs/notebooks/02_descriptor_transformer.ipynb @@ -1,13 +1,5 @@ { "cells": [ - { - "cell_type": "code", - "execution_count": null, - "id": "4796a16e", - "metadata": {}, - "outputs": [], - "source": [] - }, { "cell_type": "markdown", "id": "e3cf34ca", @@ -64,7 +56,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "There are 210 available descriptors\n", + "There are 217 available descriptors\n", "The first five descriptor names: ['MaxAbsEStateIndex', 'MaxEStateIndex', 'MinAbsEStateIndex', 'MinEStateIndex', 'qed']\n" ] } @@ -97,21 +89,9 @@ } }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[10:27:19] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:27:19] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:27:19] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:27:19] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:27:19] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:27:19] DEPRECATION WARNING: please use MorganGenerator\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -217,7 +197,7 @@ "formats": "docs//notebooks//ipynb,docs//notebooks//scripts//py:percent" }, "kernelspec": { - "display_name": "Python 3.9.4 ('rdkit')", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -231,7 +211,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.12.6" } }, "nbformat": 4, diff --git a/docs/notebooks/03_example_pipeline.ipynb b/docs/notebooks/03_example_pipeline.ipynb index dddeb39..605dfd6 100644 --- a/docs/notebooks/03_example_pipeline.ipynb +++ b/docs/notebooks/03_example_pipeline.ipynb @@ -38,7 +38,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "17a9cdd7", "metadata": { "execution": { @@ -49,9 +49,26 @@ }, "lines_to_next_cell": 0 }, - "outputs": [], + "outputs": [ + { + "ename": "FileNotFoundError", + "evalue": "[Errno 2] No such file or directory: '../tests/data/SLC6A4_active_excapedb_subset.csv'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[2], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m csv_file \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m../tests/data/SLC6A4_active_excapedb_subset.csv\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;66;03m# Hmm, maybe better to download directly\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m data \u001b[38;5;241m=\u001b[39m \u001b[43mpd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread_csv\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcsv_file\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/projects/scikit-mol/.venv/lib/python3.12/site-packages/pandas/io/parsers/readers.py:1026\u001b[0m, in \u001b[0;36mread_csv\u001b[0;34m(filepath_or_buffer, sep, delimiter, header, names, index_col, usecols, dtype, engine, converters, true_values, false_values, skipinitialspace, skiprows, skipfooter, nrows, na_values, keep_default_na, na_filter, verbose, skip_blank_lines, parse_dates, infer_datetime_format, keep_date_col, date_parser, date_format, dayfirst, cache_dates, iterator, chunksize, compression, thousands, decimal, lineterminator, quotechar, quoting, doublequote, escapechar, comment, encoding, encoding_errors, dialect, on_bad_lines, delim_whitespace, low_memory, memory_map, float_precision, storage_options, dtype_backend)\u001b[0m\n\u001b[1;32m 1013\u001b[0m kwds_defaults \u001b[38;5;241m=\u001b[39m _refine_defaults_read(\n\u001b[1;32m 1014\u001b[0m dialect,\n\u001b[1;32m 1015\u001b[0m delimiter,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1022\u001b[0m dtype_backend\u001b[38;5;241m=\u001b[39mdtype_backend,\n\u001b[1;32m 1023\u001b[0m )\n\u001b[1;32m 1024\u001b[0m kwds\u001b[38;5;241m.\u001b[39mupdate(kwds_defaults)\n\u001b[0;32m-> 1026\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_read\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilepath_or_buffer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/projects/scikit-mol/.venv/lib/python3.12/site-packages/pandas/io/parsers/readers.py:620\u001b[0m, in \u001b[0;36m_read\u001b[0;34m(filepath_or_buffer, kwds)\u001b[0m\n\u001b[1;32m 617\u001b[0m _validate_names(kwds\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnames\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m))\n\u001b[1;32m 619\u001b[0m \u001b[38;5;66;03m# Create the parser.\u001b[39;00m\n\u001b[0;32m--> 620\u001b[0m parser \u001b[38;5;241m=\u001b[39m \u001b[43mTextFileReader\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilepath_or_buffer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 622\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m chunksize \u001b[38;5;129;01mor\u001b[39;00m iterator:\n\u001b[1;32m 623\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m parser\n", + "File \u001b[0;32m~/projects/scikit-mol/.venv/lib/python3.12/site-packages/pandas/io/parsers/readers.py:1620\u001b[0m, in \u001b[0;36mTextFileReader.__init__\u001b[0;34m(self, f, engine, **kwds)\u001b[0m\n\u001b[1;32m 1617\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptions[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhas_index_names\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m kwds[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhas_index_names\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m 1619\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles: IOHandles \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m-> 1620\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_engine \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_make_engine\u001b[49m\u001b[43m(\u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mengine\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/projects/scikit-mol/.venv/lib/python3.12/site-packages/pandas/io/parsers/readers.py:1880\u001b[0m, in \u001b[0;36mTextFileReader._make_engine\u001b[0;34m(self, f, engine)\u001b[0m\n\u001b[1;32m 1878\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m mode:\n\u001b[1;32m 1879\u001b[0m mode \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m-> 1880\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles \u001b[38;5;241m=\u001b[39m \u001b[43mget_handle\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1881\u001b[0m \u001b[43m \u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1882\u001b[0m \u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1883\u001b[0m \u001b[43m \u001b[49m\u001b[43mencoding\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mencoding\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1884\u001b[0m \u001b[43m \u001b[49m\u001b[43mcompression\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcompression\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1885\u001b[0m \u001b[43m \u001b[49m\u001b[43mmemory_map\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmemory_map\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1886\u001b[0m \u001b[43m \u001b[49m\u001b[43mis_text\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_text\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1887\u001b[0m \u001b[43m \u001b[49m\u001b[43merrors\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mencoding_errors\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstrict\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1888\u001b[0m \u001b[43m \u001b[49m\u001b[43mstorage_options\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstorage_options\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1889\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1890\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 1891\u001b[0m f \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles\u001b[38;5;241m.\u001b[39mhandle\n", + "File \u001b[0;32m~/projects/scikit-mol/.venv/lib/python3.12/site-packages/pandas/io/common.py:873\u001b[0m, in \u001b[0;36mget_handle\u001b[0;34m(path_or_buf, mode, encoding, compression, memory_map, is_text, errors, storage_options)\u001b[0m\n\u001b[1;32m 868\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(handle, \u001b[38;5;28mstr\u001b[39m):\n\u001b[1;32m 869\u001b[0m \u001b[38;5;66;03m# Check whether the filename is to be opened in binary mode.\u001b[39;00m\n\u001b[1;32m 870\u001b[0m \u001b[38;5;66;03m# Binary mode does not support 'encoding' and 'newline'.\u001b[39;00m\n\u001b[1;32m 871\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ioargs\u001b[38;5;241m.\u001b[39mencoding \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m ioargs\u001b[38;5;241m.\u001b[39mmode:\n\u001b[1;32m 872\u001b[0m \u001b[38;5;66;03m# Encoding\u001b[39;00m\n\u001b[0;32m--> 873\u001b[0m handle \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\n\u001b[1;32m 874\u001b[0m \u001b[43m \u001b[49m\u001b[43mhandle\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 875\u001b[0m \u001b[43m \u001b[49m\u001b[43mioargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 876\u001b[0m \u001b[43m \u001b[49m\u001b[43mencoding\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mioargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mencoding\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 877\u001b[0m \u001b[43m \u001b[49m\u001b[43merrors\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43merrors\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 878\u001b[0m \u001b[43m \u001b[49m\u001b[43mnewline\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 879\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 880\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 881\u001b[0m \u001b[38;5;66;03m# Binary mode\u001b[39;00m\n\u001b[1;32m 882\u001b[0m handle \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mopen\u001b[39m(handle, ioargs\u001b[38;5;241m.\u001b[39mmode)\n", + "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '../tests/data/SLC6A4_active_excapedb_subset.csv'" + ] + } + ], "source": [ - "csv_file = \"../tests/data/SLC6A4_active_excapedb_subset.csv\" # Hmm, maybe better to download directly\n", + "csv_file = \"../../tests/data/SLC6A4_active_excapedb_subset.csv\" # Hmm, maybe better to download directly\n", "data = pd.read_csv(csv_file)" ] }, @@ -67,7 +84,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "a3ec0a23", "metadata": { "execution": { @@ -102,7 +119,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "4eb8f0fa", "metadata": { "execution": { @@ -123,7 +140,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "99edec0f", "metadata": { "execution": { @@ -150,7 +167,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "a27d6ff9", "metadata": { "execution": { @@ -187,7 +204,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "634ca919", "metadata": { "execution": { @@ -224,7 +241,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "f4431aab", "metadata": { "execution": { @@ -260,7 +277,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "a908097d", "metadata": { "execution": { @@ -292,7 +309,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "0124653c", "metadata": { "execution": { @@ -328,7 +345,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "63c8ef60", "metadata": { "execution": { @@ -392,7 +409,7 @@ "formats": "docs//notebooks//ipynb,docs//notebooks//scripts//py:percent" }, "kernelspec": { - "display_name": "Python 3.9.4 ('rdkit')", + "display_name": ".venv", "language": "python", "name": "python3" }, diff --git a/docs/notebooks/12_custom_fingerprint_transformer.py b/docs/notebooks/12_custom_fingerprint_transformer.py deleted file mode 100644 index f4ba1b1..0000000 --- a/docs/notebooks/12_custom_fingerprint_transformer.py +++ /dev/null @@ -1,134 +0,0 @@ -# --- -# jupyter: -# jupytext: -# formats: ipynb,py:percent -# text_representation: -# extension: .py -# format_name: percent -# format_version: '1.3' -# jupytext_version: 1.16.6 -# kernelspec: -# display_name: vscode -# language: python -# name: python3 -# --- - -# %% [markdown] -# # Creating custom fingerprint transformers -# -# If the default fingerprint transformers provided by the scikit-mol library are not enough for your needs, you can create your own custom fingerprint transformers. In this notebook, we will show you how to do this. -# -# Note that base classes are partially stable and may change in the future versions of the library. We will try to keep the changes minimal and provide a migration guide if necessary. This notebook is also will be updated accordingly. - -# %% [markdown] -# ## Basics -# -# For now we recommend you to use the `BaseFpsTransformer` class as a base class for your custom fingerprint transformers. This class provides a simple interface to create fingerprint transformers that can be used with the scikit-mol library. -# -# To create your custom fingerprint transformer, you need to create a class that inherits from the `BaseFpsTransformer` class and implement the `_transform_mol` method. This method should take a single RDKit molecule object as input and return a fingerprint as a numpy array. - -# %% -from scikit_mol.fingerprints.baseclasses import BaseFpsTransformer -import numpy as np -from rdkit import Chem - - -class DummyFingerprintTransformer(BaseFpsTransformer): - def __init__(self, fpSize=64, n_jobs=1, safe_inference_mode=False): - self.fpSize = fpSize - super().__init__( - n_jobs=n_jobs, safe_inference_mode=safe_inference_mode, name="dummy" - ) - - def _transform_mol(self, mol): - return mol.GetNumAtoms() * np.ones(self.fpSize) - - -trans = DummyFingerprintTransformer(n_jobs=4) -mols = [Chem.MolFromSmiles("CC")] * 100 -trans.transform(mols) - -# %% [markdown] -# ## Non-pickable objects -# When working with some of the `rdkit` function and classes you will often discover that some of the are unpickable objects. This means that they cannot be serialized and deserialized using the `pickle` module. This is a problem when you want to use the parallelization (controlled by the `n_jobs` parameter). -# -# Any non-pickable object in the transformer attributes should be initialized in the `__init__` method of the transforme from the other *picklable* arguments. -# -# In the example below, we will create a custom fingerprint transformer that uses the Morgan fingerprint with radius **2** and **1024** bits. Used generator is unpickable, but it can be created during the initialization of the transformer from the picklable `maxPath` and `fpSize` arguments. - -# %% -from rdkit.Chem import rdFingerprintGenerator - - -class UnpickableFingerprintTransformer(BaseFpsTransformer): - def __init__(self, fpSize=1024, n_jobs=1, safe_inference_mode=False, **kwargs): - self.fpSize = fpSize - super().__init__( - n_jobs=n_jobs, safe_inference_mode=safe_inference_mode, **kwargs - ) - self.fp_gen = rdFingerprintGenerator.GetRDKitFPGenerator( - maxPath=2, fpSize=self.fpSize - ) - - def _transform_mol(self, mol): - return self.fp_gen.GetFingerprintAsNumPy(mol) - - -trans = UnpickableFingerprintTransformer(n_jobs=4, fpSize=512) -trans.transform(mols) - - -# %% [markdown] -# Non-pickable object should not be present among the `__init__` arguments of the transformer. Doing so will prevent them to be pickled to recreate a transformer instance in the worker processes. If you for some reason need to pass a non-pickable object to the transformer you can do so (**highly discouraged**, please [open the issue](https://github.com/EBjerrum/scikit-mol/issues), maybe we will be able to help you do it better) by using the transformer in the sequential mode (i.e. `n_jobs=1`). - - -# %% -class BadTransformer(BaseFpsTransformer): - def __init__(self, generator, n_jobs=1): - self.generator = generator - super().__init__(n_jobs=n_jobs) - - def _transform_mol(self, mol): - return self.generator.GetFingerprint(mol) - - -fp_gen = rdFingerprintGenerator.GetMorganGenerator(radius=2, fpSize=10) -BadTransformer(fp_gen, n_jobs=1).transform(mols) -print("n_jobs=1 is fine") -try: - BadTransformer(fp_gen, n_jobs=2).transform(mols) -except Exception as e: - print( - "n_jobs=2 is not fine, because the generator passed as an argument is not picklable" - ) - print(f"Error msg: {e}") - - -# %% [markdown] -# ## Fingerprint name -# -# To use the fingerptint in the `pandas` output mode it needes to know the name of the fingerprint and the number of bits (features) in it to generate the columns names. The number of feature is derived from `fpSize` attribute -# -# And the name resolution works as follows (in order of priority): -# - if the fingerprint has a name set during the initialization of the base class, it is used -# - if the name of the class follows the pattern `XFingerprintTransformer`, the name (`fp_X`) is extracted from it -# - as a last resort, the name is set to name of the class - - -# %% -class NamedTansformer1(UnpickableFingerprintTransformer): - pass - - -class NamedTansformer2(UnpickableFingerprintTransformer): - def __init__(self): - super().__init__(name="fp_fancy") - - -class FancyFingerprintTransformer(UnpickableFingerprintTransformer): - pass - - -print(NamedTansformer1().get_feature_names_out()) -print(NamedTansformer2().get_feature_names_out()) -print(FancyFingerprintTransformer().get_feature_names_out()) diff --git a/docs/notebooks/13_applicability_domain.py b/docs/notebooks/13_applicability_domain.py deleted file mode 100644 index 899c023..0000000 --- a/docs/notebooks/13_applicability_domain.py +++ /dev/null @@ -1,344 +0,0 @@ -# --- -# jupyter: -# jupytext: -# cell_metadata_filter: -all -# formats: ipynb,py:percent -# text_representation: -# extension: .py -# format_name: percent -# format_version: '1.3' -# jupytext_version: 1.16.6 -# kernelspec: -# display_name: vscode -# language: python -# name: python3 -# --- - -# %% [markdown] -# # Applicability Domain Estimation -# -# This notebook demonstrates how to use scikit-mol's applicability domain estimators to assess whether new compounds are within the domain of applicability of a trained model. -# -# We'll explore two different approaches: -# 1. Using Morgan binary fingerprints with a k-Nearest Neighbors based applicability domain -# 2. Using count-based Morgan fingerprints with dimensionality reduction and a leverage-based applicability domain -# -# First, let's import the necessary libraries and load our dataset: - -# %% -import numpy as np -import pandas as pd -from rdkit import Chem -from rdkit.Chem import Draw -from rdkit.Chem import PandasTools -import matplotlib.pyplot as plt -from sklearn.model_selection import train_test_split -from sklearn.ensemble import RandomForestRegressor -from sklearn.pipeline import Pipeline -from sklearn.preprocessing import StandardScaler -from sklearn.decomposition import PCA -import pathlib - - -from scikit_mol.fingerprints import MorganFingerprintTransformer -from scikit_mol.applicability import KNNApplicabilityDomain, LeverageApplicabilityDomain - -# %% [markdown] -# ## Load and Prepare Data - -# %% -full_set = True - -if full_set: - csv_file = "SLC6A4_active_excape_export.csv" - if not pathlib.Path(csv_file).exists(): - import urllib.request - - url = "https://ndownloader.figshare.com/files/25747817" - urllib.request.urlretrieve(url, csv_file) -else: - csv_file = "../tests/data/SLC6A4_active_excapedb_subset.csv" - -data = pd.read_csv(csv_file) - -# Could also build a pipeline to convert the smiles to mols using SmilesToMolTransformer -PandasTools.AddMoleculeColumnToFrame(data, smilesCol="SMILES") -print(f"{data.ROMol.isna().sum()} out of {len(data)} SMILES failed in conversion") - -# Split into train/val/test -X = data.ROMol -y = data.pXC50 - -X_temp, X_test, y_temp, y_test = train_test_split(X, y, test_size=0.2, random_state=42) -X_train, X_val, y_train, y_val = train_test_split( - X_temp, y_temp, test_size=0.25, random_state=42 -) - -# %% [markdown] -# ## Example 1: k-NN Applicability Domain with Binary Morgan Fingerprints -# -# In this example, we'll use binary Morgan fingerprints and a k-NN based applicability domain with Tanimoto distance. -# This is particularly suitable for binary fingerprints as the Tanimoto coefficient is a natural similarity measure for them. - -# %% -# Create pipeline for binary fingerprints -binary_fp_pipe = Pipeline( - [ - ("fp", MorganFingerprintTransformer(fpSize=2048, radius=2)), - ("rf", RandomForestRegressor(n_estimators=100, random_state=0xF00D, n_jobs=-1)), - ] -) - -# Train the model -binary_fp_pipe.fit(X_train, y_train) - -# %% - -# Get predictions and errors -y_pred_test = binary_fp_pipe.predict(X_test) -abs_errors = np.abs(y_test - y_pred_test) - - -fig = plt.figure(figsize=(3, 3)) - -plt.scatter(y_test, abs_errors, alpha=0.5) -plt.xlabel("pXC50") -plt.ylabel("Predicted Absolute Error") -plt.title("Predicted pXC50 vs Absolute Error") - - -# %% - -# Create and fit k-NN AD estimator. Distance metrics follow the scikit-learn API, and the custom distance metric tanimoto popular in cheminformatics is available in scikit-mol. -knn_ad = KNNApplicabilityDomain(n_neighbors=3, distance_metric="tanimoto", n_jobs=-1) -knn_ad.fit(binary_fp_pipe.named_steps["fp"].transform(X_train)) - -# Fit threshold using validation set -knn_ad.fit_threshold( - binary_fp_pipe.named_steps["fp"].transform(X_val), target_percentile=95 -) - -# Get AD scores for test set -knn_scores = knn_ad.transform(binary_fp_pipe.named_steps["fp"].transform(X_test)) - -# %% [markdown] -# Let's visualize the relationship between prediction errors and AD scores, and calculate some statistics on compound errors within and outside the domain. - -# %% -plt.figure(figsize=(4, 3)) -plt.scatter(knn_scores, abs_errors, alpha=0.5) -plt.axvline(x=knn_ad.threshold_, color="r", linestyle="--", label="AD Threshold") -plt.xlabel("k-NN AD Score") -plt.ylabel("Absolute Prediction Error") -plt.title("Prediction Errors vs k-NN AD Scores") -plt.legend() -plt.show() - -# Calculate error statistics -in_domain = knn_ad.predict(binary_fp_pipe.named_steps["fp"].transform(X_test)) -errors_in = abs_errors[in_domain == 1] -errors_out = abs_errors[in_domain == -1] - -print(f"95th percentile of errors inside domain: {np.percentile(errors_in, 95):.2f}") -print(f"95th percentile of errors outside domain: {np.percentile(errors_out, 95):.2f}") -print(f"Fraction of samples outside domain: {(in_domain == -1).mean():.2f}") - -# %% [markdown] -# There's some diffence in the errors distribution inside and outside the domain threshold, but maybe not as clear-cut as we could have wished for. The fraction of samples outside the domain in the test-set are close the 5% that corresponds to the threshold estimated from the validation set fractile of 95%. - -# %% [markdown] -# ## Example 2: Leverage-based AD with Count-based Morgan Fingerprints -# -# In this example, we'll use count-based Morgan fingerprints, reduce their dimensionality with PCA, -# and apply a leverage-based applicability domain estimator. - -# %% -# Create pipeline for count-based fingerprints AD estimation with PCA, scaling and leverage -count_fp_pipe = Pipeline( - [ - ("fp", MorganFingerprintTransformer(fpSize=2048, radius=2, useCounts=True)), - ("pca", PCA(n_components=0.9)), # Keep 90% of variance - ("scaler", StandardScaler()), - ("leverage", LeverageApplicabilityDomain()), - ] -) - -# Train the model -count_fp_pipe.fit(X_train, y_train) - -# %% - -X_val_transformed = count_fp_pipe[ - :-1 -].transform( - X_val -) # Index into pipeline to get all the pipeline up to thelast step before the AD estimator -count_fp_pipe.named_steps["leverage"].fit_threshold( - X_val_transformed, target_percentile=95 -) - - -# Get AD scores for test set -X_test_transformed = count_fp_pipe[:-1].transform( - X_test -) # Index into pipeline to get the last step before the AD estimator -leverage_raw_scores = count_fp_pipe.named_steps["leverage"].transform( - X_test_transformed -) - -# %% [markdown] -# As before, let's visualize the relationship between prediction errors and leverage scores and look at the fractiles errors. - -# %% -plt.figure(figsize=(4, 3)) -plt.scatter(leverage_raw_scores, abs_errors, alpha=0.5) -plt.axvline( - x=count_fp_pipe.named_steps["leverage"].threshold_, - color="r", - linestyle="--", - label="AD Threshold", -) -plt.xlabel("Leverage AD Score") -plt.ylabel("Absolute Prediction Error") -plt.title("Prediction Errors vs Leverage Scores") -plt.legend() - - -# Calculate error statistics -in_domain = count_fp_pipe.named_steps["leverage"].predict(X_test_transformed) -errors_in = abs_errors[in_domain == 1] -errors_out = abs_errors[in_domain == -1] - -print(f"95th percentile of errors inside domain: {np.percentile(errors_in, 95):.2f}") -print(f"95th percentile of errors outside domain: {np.percentile(errors_out, 95):.2f}") -print(f"Fraction of samples outside domain: {(in_domain == -1).mean():.2f}") - -# %% [markdown] -# Dissappointingly the error seems larger within the domain, than outside the domain. - -# %% [markdown] -# ## Testing Famous Drugs -# -# Let's test some well-known drugs to see if they fall within our model's applicability domain: - -# %% -# Define famous drugs -famous_drugs = { - "Aspirin": "CC(=O)OC1=CC=CC=C1C(=O)O", - "Viagra": "CCc1nn(C)c2c(=O)[nH]c(nc12)c3cc(ccc3OCC)S(=O)(=O)N4CCN(C)CC4", - "Heroin": "CN1CC[C@]23[C@H]4Oc5c(O)ccc(CC1[C@H]2C=C[C@@H]4O3)c5", -} - - -Draw.MolsToGridImage( - [Chem.MolFromSmiles(drug) for drug in famous_drugs.values()], - molsPerRow=3, - subImgSize=(250, 250), - legends=[f"{name}" for name, smiles in famous_drugs.items()], -) - -# %% - -leverage_ad = count_fp_pipe.named_steps["leverage"] - - -# Function to process a drug through both AD pipelines -def check_drug_applicability(smiles, name): - mol = Chem.MolFromSmiles(smiles) - - # k-NN AD - fp_binary = binary_fp_pipe.named_steps["fp"].transform([mol]) - knn_score = knn_ad.transform(fp_binary)[0][0] - knn_status = "Inside" if knn_ad.predict(fp_binary)[0] == 1 else "Outside" - - # Leverage AD - fp_count = count_fp_pipe.named_steps["fp"].transform([mol]) - fp_pca = count_fp_pipe.named_steps["pca"].transform(fp_count) - fp_scaled = count_fp_pipe.named_steps["scaler"].transform(fp_pca) - leverage_score = leverage_ad.transform(fp_scaled)[0][0] - leverage_status = "Inside" if leverage_ad.predict(fp_scaled)[0] == 1 else "Outside" - - # Get prediction - pred_pIC50 = binary_fp_pipe.predict([mol])[0] - - return { - "knn_score": knn_score, - "knn_status": knn_status, - "leverage_score": leverage_score, - "leverage_status": leverage_status, - "pred_pIC50": pred_pIC50, - } - - -# Process each drug -results = [] -for name, smiles in famous_drugs.items(): - result = check_drug_applicability(smiles, name) - results.append( - { - "Drug": name, - "Predicted pIC50": f"{result['pred_pIC50']:.2f}", - "k-NN Score": result["knn_score"], - "k-NN Status": result["knn_status"], - "Leverage Score": result["leverage_score"], - "Leverage Status": result["leverage_status"], - } - ) - -# Display results -pd.DataFrame(results).set_index("Drug") - -# %% [markdown] -# Let's visualize where these drugs fall in our AD plots: - -# %% -# Plot for k-NN AD -plt.figure(figsize=(12, 5)) -plt.subplot(1, 2, 1) -plt.scatter(knn_scores, abs_errors, alpha=0.2, label="Test compounds") -plt.axvline(x=knn_ad.threshold_, color="r", linestyle="--", label="AD Threshold") - -for result in results: - plt.axvline(x=result["k-NN Score"], color="g", alpha=0.5, label=f"{result['Drug']}") - -plt.xlabel("k-NN AD Score") -plt.ylabel("Absolute Prediction Error") -plt.title("k-NN AD Scores") -# plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left') - -# Plot for Leverage AD -plt.subplot(1, 2, 2) -plt.scatter(leverage_raw_scores, abs_errors, alpha=0.2, label="Test compounds") -plt.axvline(x=leverage_ad.threshold_, color="r", linestyle="--", label="AD Threshold") - -for result in results: - plt.axvline( - x=result["Leverage Score"], color="g", alpha=0.5, label=f"{result['Drug']}" - ) - -plt.xlabel("Leverage AD Score") -plt.ylabel("Absolute Prediction Error") -plt.title("Leverage AD Scores") -plt.legend(bbox_to_anchor=(1.05, 1), loc="upper left") - -plt.tight_layout() -plt.show() - -# %% [markdown] -# ## Conclusions on testing the AD estimators -# -# This notebook demonstrated two different approaches to applicability domain estimation: -# -# 1. The k-NN based approach with binary fingerprints and Tanimoto distance provides a chemical similarity-based assessment -# of whether new compounds are similar enough to the training set. -# -# 2. The leverage-based approach with count-based fingerprints and dimensionality reduction focuses on the statistical -# novelty of compounds in the reduced feature space. -# -# Heroin and Aspirin was predicted to have a low affinity, whereas Viagra was predicted as having a ~9 pXC50 corresponding to nanomolar affinity. As the regression model had only been trained on actives it will have a tendency to always predict things as active, which is hard to believe for compounds so dissimilar to the training set and with our prior knowledge about their primary targets. -# -# The famous drugs we tested showed marked differences between the two AD estimation techniques. -# -# The kNN based method using tanimoto distance showed all test drugs to be distant from the training set and thus outside the applicability domain, whereas the leverage method gave the "green light" for all of them. As the drug have different primary targets than the SLC6A4 serotonin transporter, it seems like the kNN based method in this instance (dataset, featurization, ML-model) is a better way to estimate the AD for given novel compounds. This is consistent with our analysis of the 95 percentile of the absolute errors for two different methods, where kNN had a higher 95% percentile error outside the domain, it was lower for the leverage based method. -# -# diff --git a/docs/notebooks/scripts/02_descriptor_transformer.py b/docs/notebooks/scripts/02_descriptor_transformer.py index ba47c3f..6c1e9d8 100644 --- a/docs/notebooks/scripts/02_descriptor_transformer.py +++ b/docs/notebooks/scripts/02_descriptor_transformer.py @@ -8,13 +8,11 @@ # format_version: '1.3' # jupytext_version: 1.16.6 # kernelspec: -# display_name: Python 3.9.4 ('rdkit') +# display_name: .venv # language: python # name: python3 # --- -# %% - # %% [markdown] # # Desc2DTransformer: RDKit descriptors transformer # diff --git a/docs/notebooks/scripts/03_example_pipeline.py b/docs/notebooks/scripts/03_example_pipeline.py index 267b000..5ea1303 100644 --- a/docs/notebooks/scripts/03_example_pipeline.py +++ b/docs/notebooks/scripts/03_example_pipeline.py @@ -8,7 +8,7 @@ # format_version: '1.3' # jupytext_version: 1.16.6 # kernelspec: -# display_name: Python 3.9.4 ('rdkit') +# display_name: .venv # language: python # name: python3 # --- @@ -31,7 +31,7 @@ import numpy as np # %% -csv_file = "../tests/data/SLC6A4_active_excapedb_subset.csv" # Hmm, maybe better to download directly +csv_file = "../../tests/data/SLC6A4_active_excapedb_subset.csv" # Hmm, maybe better to download directly data = pd.read_csv(csv_file) # %% [markdown] # The dataset is a subset of the SLC6A4 actives from ExcapeDB. They are hand selected to give test set performance despite the small size, and are provided as example data only and should not be used to build serious QSAR models. From 046f22bc4c9c4ff5ae4763c900199051e745bedf Mon Sep 17 00:00:00 2001 From: Anton Siomchen <41703271+asiomchen@users.noreply.github.com> Date: Thu, 8 May 2025 18:27:12 +0200 Subject: [PATCH 5/7] run notebooks --- docs/notebooks/01_basic_usage.ipynb | 94 +- .../notebooks/02_descriptor_transformer.ipynb | 40 +- docs/notebooks/03_example_pipeline.ipynb | 145 +- docs/notebooks/04_standardizer.ipynb | 46 +- docs/notebooks/05_smiles_sanitization.ipynb | 58 +- docs/notebooks/06_hyperparameter_tuning.ipynb | 161 +- .../notebooks/08_external_library_skopt.ipynb | 4 +- ..._Usage_with_FingerPrint_Transformers.ipynb | 2196 ++++++++++++- .../notebooks/10_pipeline_pandas_output.ipynb | 2808 ++++------------- docs/notebooks/11_safe_inference.ipynb | 74 +- .../12_custom_fingerprint_transformer.ipynb | 48 +- docs/notebooks/13_applicability_domain.ipynb | 542 +--- 12 files changed, 3084 insertions(+), 3132 deletions(-) diff --git a/docs/notebooks/01_basic_usage.ipynb b/docs/notebooks/01_basic_usage.ipynb index 78e212b..3968cf3 100644 --- a/docs/notebooks/01_basic_usage.ipynb +++ b/docs/notebooks/01_basic_usage.ipynb @@ -25,10 +25,10 @@ "id": "2c8cad03", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:16.292725Z", - "iopub.status.busy": "2024-11-24T09:27:16.292083Z", - "iopub.status.idle": "2024-11-24T09:27:16.306663Z", - "shell.execute_reply": "2024-11-24T09:27:16.304935Z" + "iopub.execute_input": "2025-05-08T16:22:29.627872Z", + "iopub.status.busy": "2025-05-08T16:22:29.627571Z", + "iopub.status.idle": "2025-05-08T16:22:29.632065Z", + "shell.execute_reply": "2025-05-08T16:22:29.631373Z" } }, "outputs": [], @@ -42,10 +42,10 @@ "id": "8d5b2333", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:16.313611Z", - "iopub.status.busy": "2024-11-24T09:27:16.313028Z", - "iopub.status.idle": "2024-11-24T09:27:16.510254Z", - "shell.execute_reply": "2024-11-24T09:27:16.509620Z" + "iopub.execute_input": "2025-05-08T16:22:29.634712Z", + "iopub.status.busy": "2025-05-08T16:22:29.634423Z", + "iopub.status.idle": "2025-05-08T16:22:29.845389Z", + "shell.execute_reply": "2025-05-08T16:22:29.844169Z" } }, "outputs": [], @@ -78,10 +78,10 @@ "id": "0a625dda", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:16.513123Z", - "iopub.status.busy": "2024-11-24T09:27:16.512856Z", - "iopub.status.idle": "2024-11-24T09:27:17.089043Z", - "shell.execute_reply": "2024-11-24T09:27:17.088357Z" + "iopub.execute_input": "2025-05-08T16:22:29.850211Z", + "iopub.status.busy": "2025-05-08T16:22:29.848822Z", + "iopub.status.idle": "2025-05-08T16:22:30.986417Z", + "shell.execute_reply": "2025-05-08T16:22:30.984810Z" } }, "outputs": [ @@ -118,10 +118,10 @@ "id": "9a801d0f", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:17.091942Z", - "iopub.status.busy": "2024-11-24T09:27:17.091571Z", - "iopub.status.idle": "2024-11-24T09:27:17.098501Z", - "shell.execute_reply": "2024-11-24T09:27:17.097922Z" + "iopub.execute_input": "2025-05-08T16:22:30.991850Z", + "iopub.status.busy": "2025-05-08T16:22:30.990911Z", + "iopub.status.idle": "2025-05-08T16:22:31.011512Z", + "shell.execute_reply": "2025-05-08T16:22:31.010309Z" } }, "outputs": [ @@ -572,10 +572,10 @@ "id": "500dc6f7", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:17.101153Z", - "iopub.status.busy": "2024-11-24T09:27:17.100929Z", - "iopub.status.idle": "2024-11-24T09:27:17.105319Z", - "shell.execute_reply": "2024-11-24T09:27:17.104586Z" + "iopub.execute_input": "2025-05-08T16:22:31.015226Z", + "iopub.status.busy": "2025-05-08T16:22:31.014511Z", + "iopub.status.idle": "2025-05-08T16:22:31.022448Z", + "shell.execute_reply": "2025-05-08T16:22:31.021051Z" } }, "outputs": [ @@ -616,10 +616,10 @@ "id": "3a27b07a", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:17.107710Z", - "iopub.status.busy": "2024-11-24T09:27:17.107495Z", - "iopub.status.idle": "2024-11-24T09:27:17.111268Z", - "shell.execute_reply": "2024-11-24T09:27:17.110754Z" + "iopub.execute_input": "2025-05-08T16:22:31.026293Z", + "iopub.status.busy": "2025-05-08T16:22:31.025546Z", + "iopub.status.idle": "2025-05-08T16:22:31.032975Z", + "shell.execute_reply": "2025-05-08T16:22:31.031700Z" } }, "outputs": [ @@ -652,10 +652,10 @@ "id": "0f141920", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:17.113572Z", - "iopub.status.busy": "2024-11-24T09:27:17.113344Z", - "iopub.status.idle": "2024-11-24T09:27:17.117356Z", - "shell.execute_reply": "2024-11-24T09:27:17.116845Z" + "iopub.execute_input": "2025-05-08T16:22:31.036752Z", + "iopub.status.busy": "2025-05-08T16:22:31.036118Z", + "iopub.status.idle": "2025-05-08T16:22:31.043904Z", + "shell.execute_reply": "2025-05-08T16:22:31.042561Z" } }, "outputs": [ @@ -686,10 +686,10 @@ "id": "481e527f", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:17.119855Z", - "iopub.status.busy": "2024-11-24T09:27:17.119584Z", - "iopub.status.idle": "2024-11-24T09:27:17.124520Z", - "shell.execute_reply": "2024-11-24T09:27:17.124025Z" + "iopub.execute_input": "2025-05-08T16:22:31.047228Z", + "iopub.status.busy": "2025-05-08T16:22:31.046700Z", + "iopub.status.idle": "2025-05-08T16:22:31.054569Z", + "shell.execute_reply": "2025-05-08T16:22:31.053275Z" } }, "outputs": [ @@ -728,10 +728,10 @@ "id": "7773a5a0", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:17.126934Z", - "iopub.status.busy": "2024-11-24T09:27:17.126713Z", - "iopub.status.idle": "2024-11-24T09:27:17.131063Z", - "shell.execute_reply": "2024-11-24T09:27:17.130539Z" + "iopub.execute_input": "2025-05-08T16:22:31.057901Z", + "iopub.status.busy": "2025-05-08T16:22:31.057134Z", + "iopub.status.idle": "2025-05-08T16:22:31.064119Z", + "shell.execute_reply": "2025-05-08T16:22:31.063046Z" } }, "outputs": [ @@ -756,10 +756,10 @@ "id": "fa484453", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:17.133328Z", - "iopub.status.busy": "2024-11-24T09:27:17.133133Z", - "iopub.status.idle": "2024-11-24T09:27:17.137378Z", - "shell.execute_reply": "2024-11-24T09:27:17.136857Z" + "iopub.execute_input": "2025-05-08T16:22:31.067178Z", + "iopub.status.busy": "2025-05-08T16:22:31.066755Z", + "iopub.status.idle": "2025-05-08T16:22:31.074756Z", + "shell.execute_reply": "2025-05-08T16:22:31.073587Z" } }, "outputs": [ @@ -767,12 +767,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "[[]\n", - " []\n", - " []\n", - " []\n", - " []\n", - " []]\n" + "[[]\n", + " []\n", + " []\n", + " []\n", + " []\n", + " []]\n" ] } ], @@ -786,7 +786,7 @@ "formats": "docs//notebooks//ipynb,docs//notebooks//scripts//py:percent" }, "kernelspec": { - "display_name": ".venv", + "display_name": "Python 3.9.4 ('rdkit')", "language": "python", "name": "python3" }, diff --git a/docs/notebooks/02_descriptor_transformer.ipynb b/docs/notebooks/02_descriptor_transformer.ipynb index 2e84a79..f8c69b3 100644 --- a/docs/notebooks/02_descriptor_transformer.ipynb +++ b/docs/notebooks/02_descriptor_transformer.ipynb @@ -16,10 +16,10 @@ "id": "81745b1f", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:18.828147Z", - "iopub.status.busy": "2024-11-24T09:27:18.827339Z", - "iopub.status.idle": "2024-11-24T09:27:19.887178Z", - "shell.execute_reply": "2024-11-24T09:27:19.886482Z" + "iopub.execute_input": "2025-05-08T16:22:32.631647Z", + "iopub.status.busy": "2025-05-08T16:22:32.631311Z", + "iopub.status.idle": "2025-05-08T16:22:34.194489Z", + "shell.execute_reply": "2025-05-08T16:22:34.193202Z" }, "lines_to_next_cell": 0 }, @@ -45,10 +45,10 @@ "id": "dd9a2ad0", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:19.890505Z", - "iopub.status.busy": "2024-11-24T09:27:19.889986Z", - "iopub.status.idle": "2024-11-24T09:27:19.896597Z", - "shell.execute_reply": "2024-11-24T09:27:19.896028Z" + "iopub.execute_input": "2025-05-08T16:22:34.198567Z", + "iopub.status.busy": "2025-05-08T16:22:34.197421Z", + "iopub.status.idle": "2025-05-08T16:22:34.206453Z", + "shell.execute_reply": "2025-05-08T16:22:34.205342Z" } }, "outputs": [ @@ -82,10 +82,10 @@ "id": "4431a910", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:19.899516Z", - "iopub.status.busy": "2024-11-24T09:27:19.899244Z", - "iopub.status.idle": "2024-11-24T09:27:20.125197Z", - "shell.execute_reply": "2024-11-24T09:27:20.123935Z" + "iopub.execute_input": "2025-05-08T16:22:34.210875Z", + "iopub.status.busy": "2025-05-08T16:22:34.210262Z", + "iopub.status.idle": "2025-05-08T16:22:34.353857Z", + "shell.execute_reply": "2025-05-08T16:22:34.352652Z" } }, "outputs": [ @@ -122,10 +122,10 @@ "id": "6caa9a54", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:20.131216Z", - "iopub.status.busy": "2024-11-24T09:27:20.130932Z", - "iopub.status.idle": "2024-11-24T09:27:20.135202Z", - "shell.execute_reply": "2024-11-24T09:27:20.134644Z" + "iopub.execute_input": "2025-05-08T16:22:34.357638Z", + "iopub.status.busy": "2025-05-08T16:22:34.356566Z", + "iopub.status.idle": "2025-05-08T16:22:34.363282Z", + "shell.execute_reply": "2025-05-08T16:22:34.362201Z" } }, "outputs": [ @@ -159,10 +159,10 @@ "id": "78fc5691", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:20.138477Z", - "iopub.status.busy": "2024-11-24T09:27:20.138022Z", - "iopub.status.idle": "2024-11-24T09:27:20.151081Z", - "shell.execute_reply": "2024-11-24T09:27:20.150278Z" + "iopub.execute_input": "2025-05-08T16:22:34.366550Z", + "iopub.status.busy": "2025-05-08T16:22:34.366050Z", + "iopub.status.idle": "2025-05-08T16:22:34.372939Z", + "shell.execute_reply": "2025-05-08T16:22:34.371839Z" } }, "outputs": [ diff --git a/docs/notebooks/03_example_pipeline.ipynb b/docs/notebooks/03_example_pipeline.ipynb index 605dfd6..cacfa7d 100644 --- a/docs/notebooks/03_example_pipeline.ipynb +++ b/docs/notebooks/03_example_pipeline.ipynb @@ -18,10 +18,10 @@ "id": "79139b10", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:21.863626Z", - "iopub.status.busy": "2024-11-24T09:27:21.863272Z", - "iopub.status.idle": "2024-11-24T09:27:22.718519Z", - "shell.execute_reply": "2024-11-24T09:27:22.717789Z" + "iopub.execute_input": "2025-05-08T16:22:35.876773Z", + "iopub.status.busy": "2025-05-08T16:22:35.876261Z", + "iopub.status.idle": "2025-05-08T16:22:36.754601Z", + "shell.execute_reply": "2025-05-08T16:22:36.753459Z" } }, "outputs": [], @@ -38,35 +38,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "17a9cdd7", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:22.722219Z", - "iopub.status.busy": "2024-11-24T09:27:22.721369Z", - "iopub.status.idle": "2024-11-24T09:27:22.727326Z", - "shell.execute_reply": "2024-11-24T09:27:22.726709Z" + "iopub.execute_input": "2025-05-08T16:22:36.758840Z", + "iopub.status.busy": "2025-05-08T16:22:36.758015Z", + "iopub.status.idle": "2025-05-08T16:22:36.767668Z", + "shell.execute_reply": "2025-05-08T16:22:36.766504Z" }, "lines_to_next_cell": 0 }, - "outputs": [ - { - "ename": "FileNotFoundError", - "evalue": "[Errno 2] No such file or directory: '../tests/data/SLC6A4_active_excapedb_subset.csv'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[2], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m csv_file \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m../tests/data/SLC6A4_active_excapedb_subset.csv\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;66;03m# Hmm, maybe better to download directly\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m data \u001b[38;5;241m=\u001b[39m \u001b[43mpd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread_csv\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcsv_file\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/projects/scikit-mol/.venv/lib/python3.12/site-packages/pandas/io/parsers/readers.py:1026\u001b[0m, in \u001b[0;36mread_csv\u001b[0;34m(filepath_or_buffer, sep, delimiter, header, names, index_col, usecols, dtype, engine, converters, true_values, false_values, skipinitialspace, skiprows, skipfooter, nrows, na_values, keep_default_na, na_filter, verbose, skip_blank_lines, parse_dates, infer_datetime_format, keep_date_col, date_parser, date_format, dayfirst, cache_dates, iterator, chunksize, compression, thousands, decimal, lineterminator, quotechar, quoting, doublequote, escapechar, comment, encoding, encoding_errors, dialect, on_bad_lines, delim_whitespace, low_memory, memory_map, float_precision, storage_options, dtype_backend)\u001b[0m\n\u001b[1;32m 1013\u001b[0m kwds_defaults \u001b[38;5;241m=\u001b[39m _refine_defaults_read(\n\u001b[1;32m 1014\u001b[0m dialect,\n\u001b[1;32m 1015\u001b[0m delimiter,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1022\u001b[0m dtype_backend\u001b[38;5;241m=\u001b[39mdtype_backend,\n\u001b[1;32m 1023\u001b[0m )\n\u001b[1;32m 1024\u001b[0m kwds\u001b[38;5;241m.\u001b[39mupdate(kwds_defaults)\n\u001b[0;32m-> 1026\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_read\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilepath_or_buffer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/projects/scikit-mol/.venv/lib/python3.12/site-packages/pandas/io/parsers/readers.py:620\u001b[0m, in \u001b[0;36m_read\u001b[0;34m(filepath_or_buffer, kwds)\u001b[0m\n\u001b[1;32m 617\u001b[0m _validate_names(kwds\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnames\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mNone\u001b[39;00m))\n\u001b[1;32m 619\u001b[0m \u001b[38;5;66;03m# Create the parser.\u001b[39;00m\n\u001b[0;32m--> 620\u001b[0m parser \u001b[38;5;241m=\u001b[39m \u001b[43mTextFileReader\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilepath_or_buffer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 622\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m chunksize \u001b[38;5;129;01mor\u001b[39;00m iterator:\n\u001b[1;32m 623\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m parser\n", - "File \u001b[0;32m~/projects/scikit-mol/.venv/lib/python3.12/site-packages/pandas/io/parsers/readers.py:1620\u001b[0m, in \u001b[0;36mTextFileReader.__init__\u001b[0;34m(self, f, engine, **kwds)\u001b[0m\n\u001b[1;32m 1617\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptions[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhas_index_names\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m kwds[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mhas_index_names\u001b[39m\u001b[38;5;124m\"\u001b[39m]\n\u001b[1;32m 1619\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles: IOHandles \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m-> 1620\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_engine \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_make_engine\u001b[49m\u001b[43m(\u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mengine\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/projects/scikit-mol/.venv/lib/python3.12/site-packages/pandas/io/parsers/readers.py:1880\u001b[0m, in \u001b[0;36mTextFileReader._make_engine\u001b[0;34m(self, f, engine)\u001b[0m\n\u001b[1;32m 1878\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m mode:\n\u001b[1;32m 1879\u001b[0m mode \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m-> 1880\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles \u001b[38;5;241m=\u001b[39m \u001b[43mget_handle\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 1881\u001b[0m \u001b[43m \u001b[49m\u001b[43mf\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1882\u001b[0m \u001b[43m \u001b[49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1883\u001b[0m \u001b[43m \u001b[49m\u001b[43mencoding\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mencoding\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1884\u001b[0m \u001b[43m \u001b[49m\u001b[43mcompression\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcompression\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1885\u001b[0m \u001b[43m \u001b[49m\u001b[43mmemory_map\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mmemory_map\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mFalse\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1886\u001b[0m \u001b[43m \u001b[49m\u001b[43mis_text\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mis_text\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1887\u001b[0m \u001b[43m \u001b[49m\u001b[43merrors\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mencoding_errors\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstrict\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1888\u001b[0m \u001b[43m \u001b[49m\u001b[43mstorage_options\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptions\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mstorage_options\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 1889\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1890\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 1891\u001b[0m f \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mhandles\u001b[38;5;241m.\u001b[39mhandle\n", - "File \u001b[0;32m~/projects/scikit-mol/.venv/lib/python3.12/site-packages/pandas/io/common.py:873\u001b[0m, in \u001b[0;36mget_handle\u001b[0;34m(path_or_buf, mode, encoding, compression, memory_map, is_text, errors, storage_options)\u001b[0m\n\u001b[1;32m 868\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(handle, \u001b[38;5;28mstr\u001b[39m):\n\u001b[1;32m 869\u001b[0m \u001b[38;5;66;03m# Check whether the filename is to be opened in binary mode.\u001b[39;00m\n\u001b[1;32m 870\u001b[0m \u001b[38;5;66;03m# Binary mode does not support 'encoding' and 'newline'.\u001b[39;00m\n\u001b[1;32m 871\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ioargs\u001b[38;5;241m.\u001b[39mencoding \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mb\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m ioargs\u001b[38;5;241m.\u001b[39mmode:\n\u001b[1;32m 872\u001b[0m \u001b[38;5;66;03m# Encoding\u001b[39;00m\n\u001b[0;32m--> 873\u001b[0m handle \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\n\u001b[1;32m 874\u001b[0m \u001b[43m \u001b[49m\u001b[43mhandle\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 875\u001b[0m \u001b[43m \u001b[49m\u001b[43mioargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmode\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 876\u001b[0m \u001b[43m \u001b[49m\u001b[43mencoding\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mioargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mencoding\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 877\u001b[0m \u001b[43m \u001b[49m\u001b[43merrors\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43merrors\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 878\u001b[0m \u001b[43m \u001b[49m\u001b[43mnewline\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m 879\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 880\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 881\u001b[0m \u001b[38;5;66;03m# Binary mode\u001b[39;00m\n\u001b[1;32m 882\u001b[0m handle \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mopen\u001b[39m(handle, ioargs\u001b[38;5;241m.\u001b[39mmode)\n", - "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: '../tests/data/SLC6A4_active_excapedb_subset.csv'" - ] - } - ], + "outputs": [], "source": [ "csv_file = \"../../tests/data/SLC6A4_active_excapedb_subset.csv\" # Hmm, maybe better to download directly\n", "data = pd.read_csv(csv_file)" @@ -84,14 +67,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "a3ec0a23", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:22.729951Z", - "iopub.status.busy": "2024-11-24T09:27:22.729732Z", - "iopub.status.idle": "2024-11-24T09:27:22.769704Z", - "shell.execute_reply": "2024-11-24T09:27:22.768854Z" + "iopub.execute_input": "2025-05-08T16:22:36.770992Z", + "iopub.status.busy": "2025-05-08T16:22:36.770360Z", + "iopub.status.idle": "2025-05-08T16:22:36.828093Z", + "shell.execute_reply": "2025-05-08T16:22:36.826677Z" }, "lines_to_next_cell": 0 }, @@ -119,14 +102,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "4eb8f0fa", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:22.772861Z", - "iopub.status.busy": "2024-11-24T09:27:22.772534Z", - "iopub.status.idle": "2024-11-24T09:27:23.182612Z", - "shell.execute_reply": "2024-11-24T09:27:23.181966Z" + "iopub.execute_input": "2025-05-08T16:22:36.830959Z", + "iopub.status.busy": "2025-05-08T16:22:36.830663Z", + "iopub.status.idle": "2025-05-08T16:22:37.516946Z", + "shell.execute_reply": "2025-05-08T16:22:37.515550Z" } }, "outputs": [], @@ -140,14 +123,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "99edec0f", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:23.185612Z", - "iopub.status.busy": "2024-11-24T09:27:23.185269Z", - "iopub.status.idle": "2024-11-24T09:27:23.190844Z", - "shell.execute_reply": "2024-11-24T09:27:23.190290Z" + "iopub.execute_input": "2025-05-08T16:22:37.521222Z", + "iopub.status.busy": "2025-05-08T16:22:37.520115Z", + "iopub.status.idle": "2025-05-08T16:22:37.527537Z", + "shell.execute_reply": "2025-05-08T16:22:37.526440Z" } }, "outputs": [], @@ -167,14 +150,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "a27d6ff9", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:23.193426Z", - "iopub.status.busy": "2024-11-24T09:27:23.193188Z", - "iopub.status.idle": "2024-11-24T09:27:23.198881Z", - "shell.execute_reply": "2024-11-24T09:27:23.198225Z" + "iopub.execute_input": "2025-05-08T16:22:37.531062Z", + "iopub.status.busy": "2025-05-08T16:22:37.530349Z", + "iopub.status.idle": "2025-05-08T16:22:37.539115Z", + "shell.execute_reply": "2025-05-08T16:22:37.538026Z" } }, "outputs": [ @@ -204,14 +187,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "634ca919", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:23.201230Z", - "iopub.status.busy": "2024-11-24T09:27:23.201013Z", - "iopub.status.idle": "2024-11-24T09:27:23.265644Z", - "shell.execute_reply": "2024-11-24T09:27:23.264698Z" + "iopub.execute_input": "2025-05-08T16:22:37.542129Z", + "iopub.status.busy": "2025-05-08T16:22:37.541844Z", + "iopub.status.idle": "2025-05-08T16:22:37.609556Z", + "shell.execute_reply": "2025-05-08T16:22:37.608271Z" }, "lines_to_next_cell": 0 }, @@ -223,6 +206,18 @@ "Train score is :1.00\n", "Test score is :0.55\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] } ], "source": [ @@ -241,14 +236,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "f4431aab", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:23.269015Z", - "iopub.status.busy": "2024-11-24T09:27:23.268218Z", - "iopub.status.idle": "2024-11-24T09:27:23.280889Z", - "shell.execute_reply": "2024-11-24T09:27:23.279967Z" + "iopub.execute_input": "2025-05-08T16:22:37.613501Z", + "iopub.status.busy": "2025-05-08T16:22:37.613074Z", + "iopub.status.idle": "2025-05-08T16:22:37.625937Z", + "shell.execute_reply": "2025-05-08T16:22:37.624623Z" } }, "outputs": [ @@ -277,14 +272,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "a908097d", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:23.284650Z", - "iopub.status.busy": "2024-11-24T09:27:23.283862Z", - "iopub.status.idle": "2024-11-24T09:27:23.298454Z", - "shell.execute_reply": "2024-11-24T09:27:23.297546Z" + "iopub.execute_input": "2025-05-08T16:22:37.630016Z", + "iopub.status.busy": "2025-05-08T16:22:37.629320Z", + "iopub.status.idle": "2025-05-08T16:22:37.640274Z", + "shell.execute_reply": "2025-05-08T16:22:37.639075Z" } }, "outputs": [ @@ -309,14 +304,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "0124653c", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:23.302185Z", - "iopub.status.busy": "2024-11-24T09:27:23.301318Z", - "iopub.status.idle": "2024-11-24T09:27:23.307070Z", - "shell.execute_reply": "2024-11-24T09:27:23.306539Z" + "iopub.execute_input": "2025-05-08T16:22:37.643282Z", + "iopub.status.busy": "2025-05-08T16:22:37.642781Z", + "iopub.status.idle": "2025-05-08T16:22:37.655561Z", + "shell.execute_reply": "2025-05-08T16:22:37.652513Z" } }, "outputs": [ @@ -345,14 +340,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "63c8ef60", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:23.309849Z", - "iopub.status.busy": "2024-11-24T09:27:23.309649Z", - "iopub.status.idle": "2024-11-24T09:27:23.317613Z", - "shell.execute_reply": "2024-11-24T09:27:23.316837Z" + "iopub.execute_input": "2025-05-08T16:22:37.659747Z", + "iopub.status.busy": "2025-05-08T16:22:37.658755Z", + "iopub.status.idle": "2025-05-08T16:22:37.669836Z", + "shell.execute_reply": "2025-05-08T16:22:37.668406Z" } }, "outputs": [ @@ -364,20 +359,22 @@ " ('pipe',\n", " Pipeline(steps=[('mol_transformer', MorganFingerprintTransformer()),\n", " ('Regressor', Ridge())]))],\n", + " 'transform_input': None,\n", " 'verbose': False,\n", " 'smiles_transformer': SmilesToMolTransformer(),\n", " 'pipe': Pipeline(steps=[('mol_transformer', MorganFingerprintTransformer()),\n", " ('Regressor', Ridge())]),\n", - " 'smiles_transformer__parallel': False,\n", + " 'smiles_transformer__n_jobs': None,\n", " 'smiles_transformer__safe_inference_mode': False,\n", " 'pipe__memory': None,\n", " 'pipe__steps': [('mol_transformer', MorganFingerprintTransformer()),\n", " ('Regressor', Ridge())],\n", + " 'pipe__transform_input': None,\n", " 'pipe__verbose': False,\n", " 'pipe__mol_transformer': MorganFingerprintTransformer(),\n", " 'pipe__Regressor': Ridge(),\n", " 'pipe__mol_transformer__fpSize': 2048,\n", - " 'pipe__mol_transformer__parallel': False,\n", + " 'pipe__mol_transformer__n_jobs': None,\n", " 'pipe__mol_transformer__radius': 2,\n", " 'pipe__mol_transformer__safe_inference_mode': False,\n", " 'pipe__mol_transformer__useBondTypes': True,\n", diff --git a/docs/notebooks/04_standardizer.ipynb b/docs/notebooks/04_standardizer.ipynb index a16eebf..f326ea1 100644 --- a/docs/notebooks/04_standardizer.ipynb +++ b/docs/notebooks/04_standardizer.ipynb @@ -15,10 +15,10 @@ "id": "d40bdabe", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:25.092168Z", - "iopub.status.busy": "2024-11-24T09:27:25.091775Z", - "iopub.status.idle": "2024-11-24T09:27:25.972589Z", - "shell.execute_reply": "2024-11-24T09:27:25.971827Z" + "iopub.execute_input": "2025-05-08T16:22:39.191239Z", + "iopub.status.busy": "2025-05-08T16:22:39.189891Z", + "iopub.status.idle": "2025-05-08T16:22:40.514182Z", + "shell.execute_reply": "2025-05-08T16:22:40.512920Z" } }, "outputs": [], @@ -45,17 +45,17 @@ "id": "5a45dfd5", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:25.975743Z", - "iopub.status.busy": "2024-11-24T09:27:25.975328Z", - "iopub.status.idle": "2024-11-24T09:27:25.984915Z", - "shell.execute_reply": "2024-11-24T09:27:25.984323Z" + "iopub.execute_input": "2025-05-08T16:22:40.518530Z", + "iopub.status.busy": "2025-05-08T16:22:40.517654Z", + "iopub.status.idle": "2025-05-08T16:22:40.537037Z", + "shell.execute_reply": "2025-05-08T16:22:40.535847Z" } }, "outputs": [ { "data": { "text/plain": [ - "array([], dtype=object)" + "array([], dtype=object)" ] }, "metadata": {}, @@ -64,7 +64,7 @@ { "data": { "text/plain": [ - "array([], dtype=object)" + "array([], dtype=object)" ] }, "metadata": {}, @@ -102,10 +102,10 @@ "id": "d13141c6", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:25.987910Z", - "iopub.status.busy": "2024-11-24T09:27:25.987688Z", - "iopub.status.idle": "2024-11-24T09:27:26.003398Z", - "shell.execute_reply": "2024-11-24T09:27:26.002776Z" + "iopub.execute_input": "2025-05-08T16:22:40.540032Z", + "iopub.status.busy": "2025-05-08T16:22:40.539703Z", + "iopub.status.idle": "2025-05-08T16:22:40.560979Z", + "shell.execute_reply": "2025-05-08T16:22:40.560007Z" } }, "outputs": [ @@ -149,10 +149,10 @@ "id": "a376a759", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:26.006132Z", - "iopub.status.busy": "2024-11-24T09:27:26.005882Z", - "iopub.status.idle": "2024-11-24T09:27:26.034347Z", - "shell.execute_reply": "2024-11-24T09:27:26.033821Z" + "iopub.execute_input": "2025-05-08T16:22:40.565099Z", + "iopub.status.busy": "2025-05-08T16:22:40.564746Z", + "iopub.status.idle": "2025-05-08T16:22:40.603278Z", + "shell.execute_reply": "2025-05-08T16:22:40.602109Z" }, "lines_to_next_cell": 2 }, @@ -207,10 +207,10 @@ "id": "50f71bca", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:26.037572Z", - "iopub.status.busy": "2024-11-24T09:27:26.036950Z", - "iopub.status.idle": "2024-11-24T09:27:26.056194Z", - "shell.execute_reply": "2024-11-24T09:27:26.055013Z" + "iopub.execute_input": "2025-05-08T16:22:40.606383Z", + "iopub.status.busy": "2025-05-08T16:22:40.605699Z", + "iopub.status.idle": "2025-05-08T16:22:40.631525Z", + "shell.execute_reply": "2025-05-08T16:22:40.630106Z" } }, "outputs": [ @@ -249,7 +249,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.12.6" } }, "nbformat": 4, diff --git a/docs/notebooks/05_smiles_sanitization.ipynb b/docs/notebooks/05_smiles_sanitization.ipynb index 0b44c7d..d663a1c 100644 --- a/docs/notebooks/05_smiles_sanitization.ipynb +++ b/docs/notebooks/05_smiles_sanitization.ipynb @@ -15,10 +15,10 @@ "id": "612aa974", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:27.545695Z", - "iopub.status.busy": "2024-11-24T09:27:27.545293Z", - "iopub.status.idle": "2024-11-24T09:27:28.079174Z", - "shell.execute_reply": "2024-11-24T09:27:28.078490Z" + "iopub.execute_input": "2025-05-08T16:22:41.856567Z", + "iopub.status.busy": "2025-05-08T16:22:41.856271Z", + "iopub.status.idle": "2025-05-08T16:22:42.443540Z", + "shell.execute_reply": "2025-05-08T16:22:42.442130Z" }, "lines_to_next_cell": 2 }, @@ -27,7 +27,7 @@ "import pandas as pd\n", "from rdkit.Chem import PandasTools\n", "\n", - "csv_file = \"../tests/data/SLC6A4_active_excapedb_subset.csv\" # Hmm, maybe better to download directly\n", + "csv_file = \"../../tests/data/SLC6A4_active_excapedb_subset.csv\" # Hmm, maybe better to download directly\n", "data = pd.read_csv(csv_file)" ] }, @@ -45,10 +45,10 @@ "id": "b09cfd6b", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:28.082222Z", - "iopub.status.busy": "2024-11-24T09:27:28.081921Z", - "iopub.status.idle": "2024-11-24T09:27:28.086003Z", - "shell.execute_reply": "2024-11-24T09:27:28.085450Z" + "iopub.execute_input": "2025-05-08T16:22:42.448114Z", + "iopub.status.busy": "2025-05-08T16:22:42.447423Z", + "iopub.status.idle": "2025-05-08T16:22:42.454532Z", + "shell.execute_reply": "2025-05-08T16:22:42.453410Z" } }, "outputs": [], @@ -62,10 +62,10 @@ "id": "e20fb5cc", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:28.088449Z", - "iopub.status.busy": "2024-11-24T09:27:28.088211Z", - "iopub.status.idle": "2024-11-24T09:27:28.130818Z", - "shell.execute_reply": "2024-11-24T09:27:28.130102Z" + "iopub.execute_input": "2025-05-08T16:22:42.458752Z", + "iopub.status.busy": "2025-05-08T16:22:42.457870Z", + "iopub.status.idle": "2025-05-08T16:22:42.522970Z", + "shell.execute_reply": "2025-05-08T16:22:42.521865Z" }, "lines_to_next_cell": 2 }, @@ -81,7 +81,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "[10:27:28] Explicit valence for atom # 1 N, 4, is greater than permitted\n" + "[18:22:42] Explicit valence for atom # 1 N, 4, is greater than permitted\n" ] } ], @@ -104,10 +104,10 @@ "id": "3dbd50b3", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:28.133745Z", - "iopub.status.busy": "2024-11-24T09:27:28.133507Z", - "iopub.status.idle": "2024-11-24T09:27:28.508377Z", - "shell.execute_reply": "2024-11-24T09:27:28.507130Z" + "iopub.execute_input": "2025-05-08T16:22:42.526969Z", + "iopub.status.busy": "2025-05-08T16:22:42.526369Z", + "iopub.status.idle": "2025-05-08T16:22:43.317088Z", + "shell.execute_reply": "2025-05-08T16:22:43.316227Z" } }, "outputs": [ @@ -122,7 +122,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "[10:27:28] Explicit valence for atom # 1 N, 4, is greater than permitted\n" + "[18:22:43] Explicit valence for atom # 1 N, 4, is greater than permitted\n" ] } ], @@ -150,10 +150,10 @@ "id": "5af5ea3d", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:28.511261Z", - "iopub.status.busy": "2024-11-24T09:27:28.510945Z", - "iopub.status.idle": "2024-11-24T09:27:28.522024Z", - "shell.execute_reply": "2024-11-24T09:27:28.521232Z" + "iopub.execute_input": "2025-05-08T16:22:43.320958Z", + "iopub.status.busy": "2025-05-08T16:22:43.320157Z", + "iopub.status.idle": "2025-05-08T16:22:43.335067Z", + "shell.execute_reply": "2025-05-08T16:22:43.333676Z" } }, "outputs": [ @@ -220,10 +220,10 @@ "id": "84db07cc", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:28.524982Z", - "iopub.status.busy": "2024-11-24T09:27:28.524717Z", - "iopub.status.idle": "2024-11-24T09:27:28.569119Z", - "shell.execute_reply": "2024-11-24T09:27:28.568473Z" + "iopub.execute_input": "2025-05-08T16:22:43.339302Z", + "iopub.status.busy": "2025-05-08T16:22:43.338668Z", + "iopub.status.idle": "2025-05-08T16:22:43.391019Z", + "shell.execute_reply": "2025-05-08T16:22:43.389989Z" } }, "outputs": [ @@ -238,7 +238,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "[10:27:28] Explicit valence for atom # 1 N, 4, is greater than permitted\n" + "[18:22:43] Explicit valence for atom # 1 N, 4, is greater than permitted\n" ] }, { @@ -309,7 +309,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.12.6" } }, "nbformat": 4, diff --git a/docs/notebooks/06_hyperparameter_tuning.ipynb b/docs/notebooks/06_hyperparameter_tuning.ipynb index 89cb8ef..363b5b3 100644 --- a/docs/notebooks/06_hyperparameter_tuning.ipynb +++ b/docs/notebooks/06_hyperparameter_tuning.ipynb @@ -16,10 +16,10 @@ "id": "51aa3d62", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:30.230310Z", - "iopub.status.busy": "2024-11-24T09:27:30.230076Z", - "iopub.status.idle": "2024-11-24T09:27:31.452867Z", - "shell.execute_reply": "2024-11-24T09:27:31.452127Z" + "iopub.execute_input": "2025-05-08T16:22:44.604531Z", + "iopub.status.busy": "2025-05-08T16:22:44.604218Z", + "iopub.status.idle": "2025-05-08T16:22:46.163842Z", + "shell.execute_reply": "2025-05-08T16:22:46.162418Z" } }, "outputs": [], @@ -53,10 +53,10 @@ "id": "adbc1868", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:31.455770Z", - "iopub.status.busy": "2024-11-24T09:27:31.455436Z", - "iopub.status.idle": "2024-11-24T09:27:31.459245Z", - "shell.execute_reply": "2024-11-24T09:27:31.458654Z" + "iopub.execute_input": "2025-05-08T16:22:46.167928Z", + "iopub.status.busy": "2025-05-08T16:22:46.166905Z", + "iopub.status.idle": "2025-05-08T16:22:46.173404Z", + "shell.execute_reply": "2025-05-08T16:22:46.172138Z" } }, "outputs": [], @@ -71,7 +71,7 @@ " url = \"https://ndownloader.figshare.com/files/25747817\"\n", " urllib.request.urlretrieve(url, csv_file)\n", "else:\n", - " csv_file = \"../tests/data/SLC6A4_active_excapedb_subset.csv\"" + " csv_file = \"../../tests/data/SLC6A4_active_excapedb_subset.csv\"" ] }, { @@ -88,10 +88,10 @@ "id": "9a283f12", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:31.461622Z", - "iopub.status.busy": "2024-11-24T09:27:31.461384Z", - "iopub.status.idle": "2024-11-24T09:27:31.500359Z", - "shell.execute_reply": "2024-11-24T09:27:31.499764Z" + "iopub.execute_input": "2025-05-08T16:22:46.177164Z", + "iopub.status.busy": "2025-05-08T16:22:46.176440Z", + "iopub.status.idle": "2025-05-08T16:22:46.233488Z", + "shell.execute_reply": "2025-05-08T16:22:46.232374Z" } }, "outputs": [ @@ -124,10 +124,10 @@ "id": "303b83de", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:31.502982Z", - "iopub.status.busy": "2024-11-24T09:27:31.502779Z", - "iopub.status.idle": "2024-11-24T09:27:31.507447Z", - "shell.execute_reply": "2024-11-24T09:27:31.506962Z" + "iopub.execute_input": "2025-05-08T16:22:46.236917Z", + "iopub.status.busy": "2025-05-08T16:22:46.236251Z", + "iopub.status.idle": "2025-05-08T16:22:46.243264Z", + "shell.execute_reply": "2025-05-08T16:22:46.242175Z" }, "lines_to_next_cell": 2 }, @@ -152,13 +152,22 @@ "id": "1383d0fc", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:31.509953Z", - "iopub.status.busy": "2024-11-24T09:27:31.509731Z", - "iopub.status.idle": "2024-11-24T09:27:31.830576Z", - "shell.execute_reply": "2024-11-24T09:27:31.829874Z" + "iopub.execute_input": "2025-05-08T16:22:46.247777Z", + "iopub.status.busy": "2025-05-08T16:22:46.246787Z", + "iopub.status.idle": "2025-05-08T16:22:46.614634Z", + "shell.execute_reply": "2025-05-08T16:22:46.613399Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + } + ], "source": [ "# Probably the recommended way would be to prestandardize the data if there's no changes to the transformer,\n", "# and then add the standardizer in the inference pipeline.\n", @@ -183,10 +192,10 @@ "id": "51c74711", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:31.833379Z", - "iopub.status.busy": "2024-11-24T09:27:31.833155Z", - "iopub.status.idle": "2024-11-24T09:27:31.836541Z", - "shell.execute_reply": "2024-11-24T09:27:31.835939Z" + "iopub.execute_input": "2025-05-08T16:22:46.618057Z", + "iopub.status.busy": "2025-05-08T16:22:46.617207Z", + "iopub.status.idle": "2025-05-08T16:22:46.622371Z", + "shell.execute_reply": "2025-05-08T16:22:46.621207Z" }, "lines_to_next_cell": 2 }, @@ -212,10 +221,10 @@ "id": "4c6b833f", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:31.838854Z", - "iopub.status.busy": "2024-11-24T09:27:31.838668Z", - "iopub.status.idle": "2024-11-24T09:27:31.841636Z", - "shell.execute_reply": "2024-11-24T09:27:31.841130Z" + "iopub.execute_input": "2025-05-08T16:22:46.625354Z", + "iopub.status.busy": "2025-05-08T16:22:46.625058Z", + "iopub.status.idle": "2025-05-08T16:22:46.629915Z", + "shell.execute_reply": "2025-05-08T16:22:46.628829Z" }, "title": "Now hyperparameter tuning" }, @@ -241,10 +250,10 @@ "id": "0af1003b", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:31.843922Z", - "iopub.status.busy": "2024-11-24T09:27:31.843728Z", - "iopub.status.idle": "2024-11-24T09:27:31.849777Z", - "shell.execute_reply": "2024-11-24T09:27:31.849273Z" + "iopub.execute_input": "2025-05-08T16:22:46.633716Z", + "iopub.status.busy": "2025-05-08T16:22:46.632911Z", + "iopub.status.idle": "2025-05-08T16:22:46.641844Z", + "shell.execute_reply": "2025-05-08T16:22:46.640881Z" }, "title": "Which keys do we have?" }, @@ -252,7 +261,7 @@ { "data": { "text/plain": [ - "dict_keys(['memory', 'steps', 'verbose', 'morganfingerprinttransformer', 'ridge', 'morganfingerprinttransformer__fpSize', 'morganfingerprinttransformer__parallel', 'morganfingerprinttransformer__radius', 'morganfingerprinttransformer__safe_inference_mode', 'morganfingerprinttransformer__useBondTypes', 'morganfingerprinttransformer__useChirality', 'morganfingerprinttransformer__useCounts', 'morganfingerprinttransformer__useFeatures', 'ridge__alpha', 'ridge__copy_X', 'ridge__fit_intercept', 'ridge__max_iter', 'ridge__positive', 'ridge__random_state', 'ridge__solver', 'ridge__tol'])" + "dict_keys(['memory', 'steps', 'transform_input', 'verbose', 'morganfingerprinttransformer', 'ridge', 'morganfingerprinttransformer__fpSize', 'morganfingerprinttransformer__n_jobs', 'morganfingerprinttransformer__radius', 'morganfingerprinttransformer__safe_inference_mode', 'morganfingerprinttransformer__useBondTypes', 'morganfingerprinttransformer__useChirality', 'morganfingerprinttransformer__useCounts', 'morganfingerprinttransformer__useFeatures', 'ridge__alpha', 'ridge__copy_X', 'ridge__fit_intercept', 'ridge__max_iter', 'ridge__positive', 'ridge__random_state', 'ridge__solver', 'ridge__tol'])" ] }, "execution_count": 8, @@ -278,10 +287,10 @@ "id": "c2d541b3", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:31.852166Z", - "iopub.status.busy": "2024-11-24T09:27:31.851946Z", - "iopub.status.idle": "2024-11-24T09:27:31.856126Z", - "shell.execute_reply": "2024-11-24T09:27:31.855622Z" + "iopub.execute_input": "2025-05-08T16:22:46.645249Z", + "iopub.status.busy": "2025-05-08T16:22:46.644964Z", + "iopub.status.idle": "2025-05-08T16:22:46.651276Z", + "shell.execute_reply": "2025-05-08T16:22:46.650210Z" } }, "outputs": [], @@ -311,10 +320,10 @@ "id": "f2c91783", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:31.858429Z", - "iopub.status.busy": "2024-11-24T09:27:31.858216Z", - "iopub.status.idle": "2024-11-24T09:27:31.862461Z", - "shell.execute_reply": "2024-11-24T09:27:31.861795Z" + "iopub.execute_input": "2025-05-08T16:22:46.655212Z", + "iopub.status.busy": "2025-05-08T16:22:46.654913Z", + "iopub.status.idle": "2025-05-08T16:22:46.662196Z", + "shell.execute_reply": "2025-05-08T16:22:46.661226Z" }, "title": "From https://scikit-learn.org/stable/auto_examples/model_selection/plot_randomized_search.html#sphx-glr-auto-examples-model-selection-plot-randomized-search-py" }, @@ -350,10 +359,10 @@ "id": "79a70a0f", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:31.864936Z", - "iopub.status.busy": "2024-11-24T09:27:31.864708Z", - "iopub.status.idle": "2024-11-24T09:27:36.221386Z", - "shell.execute_reply": "2024-11-24T09:27:36.220369Z" + "iopub.execute_input": "2025-05-08T16:22:46.665390Z", + "iopub.status.busy": "2025-05-08T16:22:46.665100Z", + "iopub.status.idle": "2025-05-08T16:22:49.120359Z", + "shell.execute_reply": "2025-05-08T16:22:49.119269Z" } }, "outputs": [ @@ -361,7 +370,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Runtime: 4.35 for 25 iterations)\n" + "Runtime: 2.45 for 25 iterations)\n" ] } ], @@ -383,10 +392,10 @@ "id": "b6160cb3", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:36.224876Z", - "iopub.status.busy": "2024-11-24T09:27:36.224667Z", - "iopub.status.idle": "2024-11-24T09:27:36.232647Z", - "shell.execute_reply": "2024-11-24T09:27:36.231571Z" + "iopub.execute_input": "2025-05-08T16:22:49.124324Z", + "iopub.status.busy": "2025-05-08T16:22:49.123579Z", + "iopub.status.idle": "2025-05-08T16:22:49.130023Z", + "shell.execute_reply": "2025-05-08T16:22:49.128965Z" }, "lines_to_next_cell": 0 }, @@ -396,16 +405,16 @@ "output_type": "stream", "text": [ "Model with rank: 1\n", - "Mean validation score: 0.563 (std: 0.115)\n", - "Parameters: {'morganfingerprinttransformer__fpSize': 1024, 'morganfingerprinttransformer__radius': 2, 'morganfingerprinttransformer__useCounts': False, 'morganfingerprinttransformer__useFeatures': False, 'ridge__alpha': 6.855244257973563}\n", + "Mean validation score: 0.459 (std: 0.117)\n", + "Parameters: {'morganfingerprinttransformer__fpSize': 1024, 'morganfingerprinttransformer__radius': 3, 'morganfingerprinttransformer__useCounts': False, 'morganfingerprinttransformer__useFeatures': True, 'ridge__alpha': np.float64(11.211371939288233)}\n", "\n", "Model with rank: 2\n", - "Mean validation score: 0.527 (std: 0.086)\n", - "Parameters: {'morganfingerprinttransformer__fpSize': 512, 'morganfingerprinttransformer__radius': 2, 'morganfingerprinttransformer__useCounts': False, 'morganfingerprinttransformer__useFeatures': False, 'ridge__alpha': 13.611425709525077}\n", + "Mean validation score: 0.427 (std: 0.130)\n", + "Parameters: {'morganfingerprinttransformer__fpSize': 512, 'morganfingerprinttransformer__radius': 2, 'morganfingerprinttransformer__useCounts': True, 'morganfingerprinttransformer__useFeatures': False, 'ridge__alpha': np.float64(22.96332964984786)}\n", "\n", "Model with rank: 3\n", - "Mean validation score: 0.466 (std: 0.149)\n", - "Parameters: {'morganfingerprinttransformer__fpSize': 2048, 'morganfingerprinttransformer__radius': 4, 'morganfingerprinttransformer__useCounts': False, 'morganfingerprinttransformer__useFeatures': True, 'ridge__alpha': 1.383163758398022}\n", + "Mean validation score: 0.426 (std: 0.166)\n", + "Parameters: {'morganfingerprinttransformer__fpSize': 4096, 'morganfingerprinttransformer__radius': 2, 'morganfingerprinttransformer__useCounts': True, 'morganfingerprinttransformer__useFeatures': False, 'ridge__alpha': np.float64(23.874114087368742)}\n", "\n" ] } @@ -436,10 +445,10 @@ "id": "4daaf106", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:36.236805Z", - "iopub.status.busy": "2024-11-24T09:27:36.235794Z", - "iopub.status.idle": "2024-11-24T09:27:36.394539Z", - "shell.execute_reply": "2024-11-24T09:27:36.393590Z" + "iopub.execute_input": "2025-05-08T16:22:49.133255Z", + "iopub.status.busy": "2025-05-08T16:22:49.132589Z", + "iopub.status.idle": "2025-05-08T16:22:49.294436Z", + "shell.execute_reply": "2025-05-08T16:22:49.293304Z" } }, "outputs": [ @@ -447,8 +456,18 @@ "name": "stdout", "output_type": "stream", "text": [ - "No Standardization 0.6389\n", - "With Standardization 0.6389\n" + "No Standardization 0.4921\n", + "With Standardization 0.4921\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" ] } ], @@ -482,10 +501,10 @@ "id": "92105568", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:36.397490Z", - "iopub.status.busy": "2024-11-24T09:27:36.397082Z", - "iopub.status.idle": "2024-11-24T09:27:36.411965Z", - "shell.execute_reply": "2024-11-24T09:27:36.411400Z" + "iopub.execute_input": "2025-05-08T16:22:49.297625Z", + "iopub.status.busy": "2025-05-08T16:22:49.297285Z", + "iopub.status.idle": "2025-05-08T16:22:49.318086Z", + "shell.execute_reply": "2025-05-08T16:22:49.316957Z" } }, "outputs": [ @@ -493,8 +512,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Predictions with no standardization: [5.89126045 5.97721234 5.97721234 6.03427056 6.03951076]\n", - "Predictions with standardization: [5.89126045 5.89126045 5.89126045 5.89126045 5.89126045]\n" + "Predictions with no standardization: [6.36710496 6.49711427 6.49711427 6.28330625 6.72697401]\n", + "Predictions with standardization: [6.36710496 6.36710496 6.36710496 6.36710496 6.36710496]\n" ] } ], @@ -551,7 +570,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.12.6" } }, "nbformat": 4, diff --git a/docs/notebooks/08_external_library_skopt.ipynb b/docs/notebooks/08_external_library_skopt.ipynb index c984020..7fbf8d5 100644 --- a/docs/notebooks/08_external_library_skopt.ipynb +++ b/docs/notebooks/08_external_library_skopt.ipynb @@ -855,7 +855,7 @@ "formats": "docs//notebooks//ipynb,docs//notebooks//scripts//py:percent" }, "kernelspec": { - "display_name": "vscode", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -869,7 +869,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.12.6" } }, "nbformat": 4, diff --git a/docs/notebooks/09_Combinatorial_Method_Usage_with_FingerPrint_Transformers.ipynb b/docs/notebooks/09_Combinatorial_Method_Usage_with_FingerPrint_Transformers.ipynb index 839f120..69156e1 100644 --- a/docs/notebooks/09_Combinatorial_Method_Usage_with_FingerPrint_Transformers.ipynb +++ b/docs/notebooks/09_Combinatorial_Method_Usage_with_FingerPrint_Transformers.ipynb @@ -27,10 +27,10 @@ "id": "b705b5c9", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:55.508365Z", - "iopub.status.busy": "2024-11-24T09:27:55.507967Z", - "iopub.status.idle": "2024-11-24T09:27:56.807362Z", - "shell.execute_reply": "2024-11-24T09:27:56.806654Z" + "iopub.execute_input": "2025-05-08T16:22:50.685069Z", + "iopub.status.busy": "2025-05-08T16:22:50.684787Z", + "iopub.status.idle": "2025-05-08T16:22:52.211375Z", + "shell.execute_reply": "2025-05-08T16:22:52.210158Z" }, "lines_to_next_cell": 2 }, @@ -70,10 +70,10 @@ "id": "34b2618a", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:56.810246Z", - "iopub.status.busy": "2024-11-24T09:27:56.809941Z", - "iopub.status.idle": "2024-11-24T09:27:56.851202Z", - "shell.execute_reply": "2024-11-24T09:27:56.850568Z" + "iopub.execute_input": "2025-05-08T16:22:52.215818Z", + "iopub.status.busy": "2025-05-08T16:22:52.214649Z", + "iopub.status.idle": "2025-05-08T16:22:52.271743Z", + "shell.execute_reply": "2025-05-08T16:22:52.270511Z" } }, "outputs": [ @@ -97,7 +97,7 @@ " url = \"https://ndownloader.figshare.com/files/25747817\"\n", " urllib.request.urlretrieve(url, csv_file)\n", "else:\n", - " csv_file = \"../tests/data/SLC6A4_active_excapedb_subset.csv\"\n", + " csv_file = \"../../tests/data/SLC6A4_active_excapedb_subset.csv\"\n", "\n", "# Parse Database\n", "data = pd.read_csv(csv_file)\n", @@ -125,10 +125,10 @@ "id": "e06042cc", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:56.854051Z", - "iopub.status.busy": "2024-11-24T09:27:56.853508Z", - "iopub.status.idle": "2024-11-24T09:27:56.863947Z", - "shell.execute_reply": "2024-11-24T09:27:56.863371Z" + "iopub.execute_input": "2025-05-08T16:22:52.275673Z", + "iopub.status.busy": "2025-05-08T16:22:52.274777Z", + "iopub.status.idle": "2025-05-08T16:22:52.289345Z", + "shell.execute_reply": "2025-05-08T16:22:52.288093Z" } }, "outputs": [ @@ -203,18 +203,2034 @@ "id": "f1cf66df", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:27:56.866817Z", - "iopub.status.busy": "2024-11-24T09:27:56.866251Z", - "iopub.status.idle": "2024-11-24T09:28:28.265183Z", - "shell.execute_reply": "2024-11-24T09:28:28.264595Z" + "iopub.execute_input": "2025-05-08T16:22:52.293059Z", + "iopub.status.busy": "2025-05-08T16:22:52.292608Z", + "iopub.status.idle": "2025-05-08T16:23:24.403914Z", + "shell.execute_reply": "2025-05-08T16:23:24.402481Z" } }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "Runtime: 31.39\n" + "Runtime: 32.10\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n" ] } ], @@ -251,10 +2267,10 @@ "id": "f80006f8", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:28:28.268630Z", - "iopub.status.busy": "2024-11-24T09:28:28.268131Z", - "iopub.status.idle": "2024-11-24T09:28:28.320208Z", - "shell.execute_reply": "2024-11-24T09:28:28.319598Z" + "iopub.execute_input": "2025-05-08T16:23:24.408236Z", + "iopub.status.busy": "2025-05-08T16:23:24.407494Z", + "iopub.status.idle": "2025-05-08T16:23:24.478389Z", + "shell.execute_reply": "2025-05-08T16:23:24.477178Z" } }, "outputs": [ @@ -300,10 +2316,10 @@ " \n", " \n", " 0\n", - " 0.011822\n", - " 0.001013\n", - " 0.003596\n", - " 0.001311\n", + " 0.011185\n", + " 0.003272\n", + " 0.003625\n", + " 0.000579\n", " MorganFingerprintTransformer()\n", " 256.0\n", " 0.100\n", @@ -319,10 +2335,10 @@ " \n", " \n", " 1\n", - " 0.010119\n", - " 0.000152\n", - " 0.002832\n", - " 0.000070\n", + " 0.009765\n", + " 0.000383\n", + " 0.003377\n", + " 0.000101\n", " MorganFingerprintTransformer()\n", " 256.0\n", " 0.325\n", @@ -338,10 +2354,10 @@ " \n", " \n", " 2\n", - " 0.010302\n", - " 0.000429\n", - " 0.003310\n", - " 0.000967\n", + " 0.009901\n", + " 0.000303\n", + " 0.003631\n", + " 0.000097\n", " MorganFingerprintTransformer()\n", " 256.0\n", " 0.550\n", @@ -357,10 +2373,10 @@ " \n", " \n", " 3\n", - " 0.010192\n", - " 0.000159\n", - " 0.002859\n", - " 0.000089\n", + " 0.010876\n", + " 0.000710\n", + " 0.003938\n", + " 0.000378\n", " MorganFingerprintTransformer()\n", " 256.0\n", " 0.775\n", @@ -376,10 +2392,10 @@ " \n", " \n", " 4\n", - " 0.010103\n", - " 0.000126\n", - " 0.002868\n", - " 0.000119\n", + " 0.010237\n", + " 0.000522\n", + " 0.003698\n", + " 0.000063\n", " MorganFingerprintTransformer()\n", " 256.0\n", " 1.000\n", @@ -414,10 +2430,10 @@ " \n", " \n", " 60\n", - " 0.100754\n", - " 0.006501\n", - " 0.025367\n", - " 0.001743\n", + " 0.101976\n", + " 0.002168\n", + " 0.026431\n", + " 0.002031\n", " MACCSKeysFingerprintTransformer()\n", " NaN\n", " 0.100\n", @@ -433,10 +2449,10 @@ " \n", " \n", " 61\n", - " 0.118554\n", - " 0.022440\n", - " 0.036584\n", - " 0.023911\n", + " 0.101812\n", + " 0.003023\n", + " 0.026544\n", + " 0.001390\n", " MACCSKeysFingerprintTransformer()\n", " NaN\n", " 0.325\n", @@ -452,10 +2468,10 @@ " \n", " \n", " 62\n", - " 0.097552\n", - " 0.001638\n", - " 0.025571\n", - " 0.001753\n", + " 0.102681\n", + " 0.001273\n", + " 0.026926\n", + " 0.001608\n", " MACCSKeysFingerprintTransformer()\n", " NaN\n", " 0.550\n", @@ -471,10 +2487,10 @@ " \n", " \n", " 63\n", - " 0.098300\n", - " 0.001744\n", - " 0.025552\n", - " 0.001695\n", + " 0.100703\n", + " 0.004015\n", + " 0.026171\n", + " 0.001515\n", " MACCSKeysFingerprintTransformer()\n", " NaN\n", " 0.775\n", @@ -490,10 +2506,10 @@ " \n", " \n", " 64\n", - " 0.098103\n", - " 0.001473\n", - " 0.025320\n", - " 0.001673\n", + " 0.101780\n", + " 0.001939\n", + " 0.027233\n", + " 0.001860\n", " MACCSKeysFingerprintTransformer()\n", " NaN\n", " 1.000\n", @@ -514,17 +2530,17 @@ ], "text/plain": [ " mean_fit_time std_fit_time mean_score_time std_score_time \\\n", - "0 0.011822 0.001013 0.003596 0.001311 \n", - "1 0.010119 0.000152 0.002832 0.000070 \n", - "2 0.010302 0.000429 0.003310 0.000967 \n", - "3 0.010192 0.000159 0.002859 0.000089 \n", - "4 0.010103 0.000126 0.002868 0.000119 \n", + "0 0.011185 0.003272 0.003625 0.000579 \n", + "1 0.009765 0.000383 0.003377 0.000101 \n", + "2 0.009901 0.000303 0.003631 0.000097 \n", + "3 0.010876 0.000710 0.003938 0.000378 \n", + "4 0.010237 0.000522 0.003698 0.000063 \n", ".. ... ... ... ... \n", - "60 0.100754 0.006501 0.025367 0.001743 \n", - "61 0.118554 0.022440 0.036584 0.023911 \n", - "62 0.097552 0.001638 0.025571 0.001753 \n", - "63 0.098300 0.001744 0.025552 0.001695 \n", - "64 0.098103 0.001473 0.025320 0.001673 \n", + "60 0.101976 0.002168 0.026431 0.002031 \n", + "61 0.101812 0.003023 0.026544 0.001390 \n", + "62 0.102681 0.001273 0.026926 0.001608 \n", + "63 0.100703 0.004015 0.026171 0.001515 \n", + "64 0.101780 0.001939 0.027233 0.001860 \n", "\n", " param_fp_transformer param_fp_transformer__fpSize \\\n", "0 MorganFingerprintTransformer() 256.0 \n", @@ -610,17 +2626,17 @@ "id": "a6041579", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:28:28.324000Z", - "iopub.status.busy": "2024-11-24T09:28:28.323259Z", - "iopub.status.idle": "2024-11-24T09:28:28.574471Z", - "shell.execute_reply": "2024-11-24T09:28:28.573892Z" + "iopub.execute_input": "2025-05-08T16:23:24.481751Z", + "iopub.status.busy": "2025-05-08T16:23:24.481189Z", + "iopub.status.idle": "2025-05-08T16:23:24.710744Z", + "shell.execute_reply": "2025-05-08T16:23:24.709653Z" }, "lines_to_next_cell": 2 }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABJQAAAMbCAYAAAAb68/GAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAA1K9JREFUeJzs3Xl4DXfj/vH7ZI8lhEjsQe211a52tZXaHlqKWloe2qq2WlVaa32ri6ruWrW1pbaiaFGCqn2niqp9jS2SEJKQzO8Pv8wjssgkkTlH36/rysU5M3POfZY5mXNn5jMOwzAMAQAAAAAAAGnkZncAAAAAAAAAuBYKJQAAAAAAAFhCoQQAAAAAAABLKJQAAAAAAABgCYUSAAAAAAAALKFQAgAAAAAAgCUUSgAAAAAAALCEQgkAAAAAAACWUCgBAAAAAADAEgolAAAsWLt2rRwOhxwOR6bfdsLtrl27NtNv+16uX7+u4cOHq1y5cvL19TWz7N69+77c3/18HpHYqFGj5HA41KhRI7ujII2mTZumOnXqyM/Pz1xPJk6caHcsAAASoVACABslfNFL7idbtmwqVaqUevbsqY0bN9odNZFRo0Zp1KhROn78eIZu587HW65cuXvOv23btkTL9OrVK0P3j//p3Lmzxo4dq4MHD8rhcCgoKEhBQUHy9PRM0/KNGjVK8b185w+lxoNl+vTpGjVqVLpK0DtLxfT8ZPTzx1l99NFHevbZZ7V582bduHFDgYGBCgoKUvbs2e2O9sBI6+dVcj/83gGA//GwOwAA4LagoCDz//Hx8QoLC9Phw4d1+PBhfffddxo5cqRGjRplX8A7jB49WtLtjfJixYplym0ePHhQmzZtUp06dVKcZ+rUqZlyX0js4MGDWrp0qSRpzpw5euqpp9J9W56ensqTJ0+K0xOmZcuWTWXKlEn3/SDtAgICVKZMGRUtWjTTb3v69On6/fffJclyWejl5ZXoc+9OYWFhunnzZqrvJ3d3d0v35yo+/PBDSdLAgQM1fvz4NJe6SLs8efIk+96LjY3VlStXJEn+/v7y8vJKMk+uXLnuez4AcBUUSgDgJEJDQxNdjouL0+bNm/Xyyy9rx44dGj16tJo3b65HH33UpoT3T7FixXT8+HHzMI/kREdHa/bs2XI4HCpatKhOnDiRxSkfXH/++ackKW/evBkqkyTp0UcfTdPeKjVr1tTBgwczdF9ImwEDBmjAgAF2x0ji0UcfTfK5l6BRo0b6/fff0/x+elBcvHhR58+flyT17duXMuk+WbBgQbLXr127Vo0bNzbnYY9KAEgdh7wBgJNyd3dX3bp1tWjRIvO6n3/+2b5A91GPHj3kcDg0Z84cXb9+Pdl5FixYoPDwcDVs2DDT9orCbQnPeY4cOWxOAvy73fn5x/oIAHB2FEoA4OQKFy6svHnzSpKuXbuW4nxXr17Ve++9pzp16ihPnjzy9vZWkSJF1KVLF23atCnF5a5cuaIRI0aoatWq8vPzk5eXl/Lnz69KlSqpf//+CgkJMeft1atXokGUGzdunGhsifQWPcWLF1fDhg0VGRmpn376Kdl5Eg536927d5puc9euXerRo4eCg4Pl4+Mjf39/Pfroo5o4caJiYmJSXfbgwYPq1q2b8ufPLx8fH5UoUUIvvfSSuefAvaT3tcio6OhoTZw4UY8++qj8/f3l4+Oj4OBg9ejRI9nBtRPG8EoYE+TEiRNZNlZIaoNyT58+PdH7aceOHXrqqadUoEABeXt7q0SJEho0aJB5aEpK1q1bpzZt2iggIEC+vr4qU6aM3nrrLV27di3JfSTn4sWLevvtt/XII48oV65c5nvhueee019//ZWmx7Vr1y5169ZNhQsXlqenZ6I9HooVKyaHw6Hp06fr6tWrGjp0qMqUKSNfX18FBASoffv22rJlS4r57hzE/cKFCxo0aJBKly6tbNmyJXpeUxuUO2GdTnit58+fr0aNGilPnjzKli2bqlSpok8++UTx8fGJlkt4/hIOdxs9enSWjXFk5TkODQ3VZ599pnbt2qlcuXLKlSuXfH19VbJkSfXp0yfF11FK/3Nzpzlz5ujxxx83xyPLnTu3SpUqpbZt2+qLL75QdHR0osd05/uxePHiqX62rl27Vk8++aQKFSokb29vBQQE6LHHHtO0adMUFxeXbJ673ws//fSTmjdvrsDAQLm5uZmHVd/92KdPn646deooV65c8vf3V9OmTbVu3Trzdm/duqXPPvtM1apVk5+fn3LlyqVWrVpp586dKT430u3Du2fOnKlWrVopKChIXl5eypcvn5o3b64ff/xRhmEku9yd6861a9c0YsQIVaxYUTlz5rwv773ly5fL4XDIw8NDZ8+eTXXe+vXrJ/n8vPs9u337dnXq1EkFChSQj4+PSpYsqcGDBys8PDzV246NjdWXX36pxo0bKyAgwPx93a5dOy1btiyjDxMArDMAALYZOXKkIclI7eP49OnT5jyffPJJsvPs2rXLKFy4sDmfu7u7kTNnTvOyw+Ew3n333STLnTp1yihatKg5n5ubm+Hv72+4u7ub1zVs2NCcf+DAgUZQUJA5zd/f3wgKCjJ/qlevbunxJ9zOtGnTjBkzZhiSjMaNGyeZ7/jx44bD4TBy5sxpREVFGQ0bNjQkGT179kz2didMmGA4HA7z9nPlymV4enqalytVqmScPXs22WWXLVtmeHt7m/PmyJHD8PHxMSQZBQoUMKZOnZrqa5be1+LO52PNmjVpev7udPr0aaNChQrmbXh6ehq5cuVK9Np++umniZb58MMPjaCgIMPPz8+c587Xc+DAgWm+/4TX5M73S2rWrFmT4vM4bdo0Q5IRHBxszJw503ztcuXKZbi5uZnLPfzww8bVq1eTvf1PP/00yXvAy8vLkGSUK1fO+Pjjj837SM7KlSuN3LlzJ3o+s2fPbl728vIyZsyYkerjmj9/vpndz8/P8PHxSfT8BAcHG5KMCRMmGGXKlDFvN+H1SHhNpkyZkmzGhHkmT55srpc+Pj7m+y1BwudMcq9Nz549zXXpxRdfNO/zzscuyejRo0ei5WbPnm0EBQWZjy979uyJ3jtBQUHGyZMnk82dFqm9n6w8xwmPT5Lh4eFh5MmTx/Dw8DCv8/b2NubPn59shvQ+Nwl69+6daL4cOXIY2bJlS3TdsWPHDMMwjA0bNhhBQUFGQECAOS0gICDFz9ZXX3010WdK7ty5E31uN2nSxIiMjEyS6c73wqBBg8zlEz73R44cmeSxJ/zfw8Mj0WeZh4eHsWTJEiM6Otpo3ry5+f69cz3Jli2bsX379mSfn8uXLxsNGjRI9Hzc+ZklyWjbtq0RExOTZNmEdWf8+PFG6dKlzftOeG0Snler7nxv3fk5HB8fbxQvXtyQZLzzzjspLn/gwAFz+Q0bNiR7u4sWLTI/i/z8/Mz/J3wepZT9+PHjxsMPP5zodb/7+erfv3+6HjcApBeFEgDYKLVC6datW8bGjRuNGjVqGJKMwMBA48qVK0nmO3v2rBEYGGhIMv7zn/8Y27dvN2JjYw3DMIzz588bw4cPN79ALVy4MNGyzz33nCHJKFasmLFq1Srj1q1b5n0fP37c+Oqrr4whQ4Ykuc+MFB/J3c60adOMqKgoI2fOnIbD4TCOHj2aaL5Ro0YZkow+ffoYhmGkWigtWbLEvN127dqZtxUTE2N899135heiRx991Hy8CU6dOmV+ma9UqZKxZcsWwzAMIy4uzli2bJlRuHDhRF8m75aR1+LO58Pq83rr1i2jVq1a5heyH374wfwSduTIEeOJJ54wv4D8+uuvSZa/s8BJr/tRKGXLls3w9vY2+vTpY5YTUVFRxueff26WCMOHD0+y/IYNG8ziqVmzZsbff/9tGIZh3Lx505g3b56RJ08ew9/fP8XHvHfvXsPX19eQZPTt29fYv3+/+V45ceKE8cILL5hfqLdt25bi48qRI4fRqlUr48CBA+b0Q4cOmf9P+FKcK1cuw9/f35g7d65x8+ZNwzAMY//+/eZz6uHhYezYsSNJzjvvp0yZMkZISIgRFxdnGIZhPmbDSFuh5O/vb3h5eRkTJkwwIiIiDMMwjEuXLhl9+vQx7yckJCTJ8gkZE4qIzJLWQulez/E777xjfPjhh8aff/5pPrdxcXHGvn37jG7dupll2JkzZ5LcT0aemz/++MMsoN5//33j8uXL5rRLly4ZK1asMHr27Jnkfo8dO5akbLrbZ599Zs7z3//+1zh37pxhGIZx7do14+OPPzY/Yzp37pxk2YT3Qo4cOQxJxpAhQ4wLFy4YhmEY0dHRxvHjxxM99ty5cxu+vr7G119/bVy/ft0wDMM4ePCgUa1aNfN3x4ABA4w8efIYc+fONWJjY434+Hhj+/btxkMPPWRIMurWrZskx61bt8zXuEqVKsaSJUuMqKgo83HMmDHD/Cx95ZVXkiyfsO7kyJHDyJ8/v7Fw4ULzs/bUqVPmbVmVUqFkGIbx3nvvmY85Pj4+2eUTSroKFSqkeLu5cuUyGjVqZOzfv98wjNufS3PmzDE/k2rUqJHkd9O1a9eMsmXLGpKMRo0aGWvXrjWio6MNwzCM8PBwY8KECeZrOnHixHQ9dgBIDwolALDRnYXSnX/Zz5cvn/nXZj8/P6Nbt27mhv7dnn32WUOS0bVr1xTvZ8KECYYko3LlyomuL1eunCHJmDVrlqXc96NQMgzD/II2YsQIc574+HijWLFiif7im1qhlPCY6tevn2Sj3DAMY/Hixeb9zps3L9G0559/3pBk5M2b1zh//nySZf/8889EezrdLSOvxZ3Ph9Xndfbs2eayK1asSDL95s2bZuF09xcdw8jcQsnT0zPJnioJP6VLlzbnT0uhlNJrbBj/++JWsmTJJNMee+wxQ5JRvnx580vXnVavXp1oj4C7NWnSxJBkDB06NMXHO3DgQLO0vNOdj6tmzZrJvgcTJHwplmSsWrUqyfTr168bpUqVMiQZrVq1SjI9YVk/Pz/j1KlTKd5PWgqlO9fDuyWUBwmF7p3sLpTu9RzfS+vWrQ0p+b1OMvLcvP/++4Yko3nz5pby3KtQun79upEnTx5DkvH0008nexuffvqpeRt37x105++cQYMGpZjjzsf+ww8/JJl++PBhc7ok448//kgyT0hIiDn97vfnd999Z0gyypYta4SHhyebYfv27YbD4TC8vLySfB4nrDvu7u7Gzp07U3wcVqVWKF24cMHcm2j58uVJlo2Ojjb3MLt7b9A7b7d06dJmOXenlStXmvPMnTs30bQxY8aY60NCcXa3BQsWGNLtPdsSylMAuN8YQwkAnMT58+fNn4sXL5pjYFy/fl0RERHJjt8THR2tWbNmSZKGDBmS4m336NFDkrRnz55Et5M7d25J0rlz5zLrYWTIs88+K0maMWOGOXbGmjVrdPz4cZUpU+aeZ7jbu3evDhw4IEl6++23kz2teJs2bVSzZk1J0o8//mhebxiG5syZI0nq37+/AgMDkyxboUIFderUKdn7zuhrkREJuevUqaPmzZsnme7h4aGRI0dKkvbt22ee1e1+uHnzZqL38t0/Vr399tvJXt+uXTtJ0uHDhxMNZBwWFqbVq1dLkgYPHixvb+8kyzZu3Fj169dP9naPHz+u1atXy8PDQ6+//nqKuRJex1WrVqU4Xs3gwYPTdGr7unXr6rHHHktyva+vrwYPHizp9hguERERyS7/zDPPqHDhwve8n9QUKVJEPXv2THZa27ZtJd1ev5xNWp/jlLRu3VqStH79+hTnSc9zk/DZeudneWZYuXKlwsLCJMkc7+huL7zwggoUKCBJ5mfS3dzc3FL9nEpQtGhRde3aNcn1Dz30kEqWLCnp9phB9erVSzJPw4YNzfXv7udnypQpkqTnn39euXLlSva+q1WrpocfflixsbFas2ZNsvO0bNlSjzzyyD0fR2bIly+fOnbsKEn65ptvkkxfuHChLl26JF9fXz3zzDMp3s7gwYPl6+ub5PqmTZuav+Nmz56daFrC8zVo0KAUz/zXvn17+fn56dKlS9qxY0faHhQAZBCFEgA4CeP2XqPmz40bN7Rr1y717NlTS5cuVYMGDRKd8U26PVhxwqCuzZs3V/78+ZP9efjhh81lTpw4Yf7/iSeekCS9+eab+u9//6vly5crMjLy/j/YFNSpU0dly5bViRMnzMHArQzGvX37dkm3C5SGDRumOF+zZs0SzS9Jx44dM7+oNWnSJMVlU5qW0dciIxIeR9OmTVOcp3HjxuYX7zsfd2Zr2LBhkvdyws+9Bpy9W548ecwvrXcrWLCg+f87B+fetWuXWUam9h5I6XTgGzZskHR7sODy5cun+Dq2bNlSkhQVFaXLly8ne1t169ZN+cHdIS3vt/j4+BQHOE7r/aSmRo0ayQ6QLv3vuU5YP5xJWh77nj179MILL6hSpUry8/OTm5ubOUDyCy+8IEk6ffp0isun57l57LHH5OPjo127dql+/fqaMmWKjh07ltaHlaKEdbdIkSIqXbp0svO4u7ub75uU1vWSJUsmW5rfrXr16ik+9qCgIEm3n5+UcgQEBEhKvI7GxcVp8+bNkm6XYimtY/nz59fff/8tKeXPysx471vRv39/SdKSJUuSFOSTJ0+WJD311FNmoZictKzvd75uZ86cMR//c889l+JzVaBAAfPEHZn1uwUA7sXD7gAAgOT5+PioSpUq+vbbbxUWFqaFCxeqV69eOnnypPz8/CQp0dlm0rr3x517cwwePFh79uzR3LlzNXnyZE2ePFkOh0MPP/ywWrZsqT59+qhMmTKZ+8DuoXfv3hoyZIimTZummjVrasGCBXJ3dzf3CEnNhQsXJEkBAQHJ7pmSIGFvjoT57/5/oUKF7rns3TL6WmREQvbUcvv4+CggIEDnz59P9FidWc6cOVOc5uHxv02Ymzdvmv+/ePGi+f87S6e7pfRcJbyO8fHxGX4d0/KFPbUsd09L6XVL6/2kJi3P9Z3Ps7O412P//PPP9fLLL5tnYnM4HMqVK5f5+XDjxg1FRkYqKioqxdtIz3Pz0EMP6dtvv1X//v21adMm8+yO+fLlU+PGjdW1a1e1bds2xbImJWlZ16XkP+PulNb3TFoeu9XnJywszDzT5r3O1Jggo+tYZmnQoIHKly+v/fv3a9q0aXrzzTcl3d5TMmEvqn79+qV6G2lZ3+983e783XLp0qU05cys3y0AcC/soQQALqBv376SpIiICP3666/m9XceSnHjxo0U9wy58+fOPTM8PT01Z84c7d69WyNGjFCTJk2ULVs27du3T+PHj9fDDz+sjz76KMsep3T78B13d3ctXLhQkyZN0o0bN9SyZUvzEA5nldHXApnP6pd16X+vY1BQUJpeQ8Mwkj2lu6QMHYplRVbdjzNK7bEfOHBAr7zyiuLj4/Xkk09q69atio6O1pUrVxQaGqrQ0FBNmDBBklI8PX1GdOvWTSdOnNCkSZPUuXNnFSlSRBcvXtTcuXPVvn17NWzY0LY9Qu18z9z5Wbls2bI0rWMpHd5nx+NI2Evp22+/Nd83Cf+vUKGC6tSpk6n3d+fzdeDAgTQ9X7169crUDACQEgolAHABwcHB5v/vPGwif/785v8zsot75cqVNXr0aIWEhCg8PFyrVq1SgwYNFBcXZ+7FlFUKFCigli1b6saNGxo+fLiktB3uJv3vr9WXLl0y/wKenITDW+786/ad/z9z5kyKy6Y0LbNei/RIyJ7aYTvR0dHmoVlZ/Vf9rJQvXz7z/3f+Zf9u93odL126lOpeK5kpre+3B/l1ux/mz5+vuLg4lStXTrNnz1aNGjXk5eWVaJ7Q0ND7miFPnjzq16+fZs+erZMnT+rw4cN688035XA49Mcff6RYlKQkLev6ndOd8T2TN29ec88lVzw0q0ePHsqWLZuOHDmi1atX6+bNm5o+fbqke++dJKVtfb/zdbPzdwsA3AuFEgC4gDu/PGTPnt38/51fkJYsWZIp9+Xh4aHHHntMv/zyi7y9vWUYhlatWpVonoQ9P+7HX/Wl/w3OHRsbq4CAAHPg23upXr26JOnWrVv6/fffU5wv4fHcOfZH8eLFlSdPHklKcQBYSeaAz3e7H69FWiU87oRxp5Kzdu1a3bp1S1LKY548CB555BHz/bl27doU50tpWsKYLHFxcVq2bFlmx0tWau+3hGlubm5ZNviwFW5utzcl79dnQUacOnVK0u3CPCHn3e7+bLvfHnroIY0bN84c6HrlypWWlk9Y10+fPq1Dhw4lO09cXJz5vnHGdd3T09M8MUJWf1Zmhly5cunpp5+WdHtw7oTxlHx9fdW9e/d7Lp+W9T3hdZakYsWKmYfCueLzBeDBRqEEAC7gzjP13LmhmT17dvOLyfvvv6+TJ0+mejt3Dxyb2l483t7e5uEEd38ZSxjDyeogy2nVpk0bDR48WK+99pomTpyY4llt7lapUiWVL19ekjR27Nhkz67066+/asuWLZJkfimQbpdkTz31lCRp0qRJyY5VsX//fs2fPz/Z+87oa5ERXbp0kSRt2rRJv/32W5Lpt27d0pgxYyTdPlNdhQoVMu2+nU2ePHnUuHFjSdJHH32k2NjYJPOsW7dOf/zxR7LLlypVyjwU8a233krxzGoJMuN1XL9+fbIFV3R0tHnIaYsWLVId6Ncu9/uzICMSzh72559/Jlt4LVu2LNXSMSNS+2yVZJ7lK6WiKyXNmjVT3rx5JaV8lrevv/7a3Dvvzs84Z/Lf//5X0u3P4zsP406OMw4Gn3DY26JFi/TBBx9Iuvdg3AnGjx9vnsDhTmvWrDFPCtC5c+dE0xIOe58yZYp27dqV6u074/MF4MFFoQQATiw0NFRvv/22ZsyYIUmqXbt2kvEZ3n33XRUsWFCXLl1SnTp19P333+vq1avm9IsXL+qnn35Shw4dkny5CA4O1tChQ7V58+ZEX4AOHz6sbt266fr163Jzc1OLFi0SLZdQSMycOfO+DP7p6empDz74QOPHj1e3bt0sLfv+++9Lkv744w916tTJPETw5s2bmjlzpvkcPProo2rfvn2iZYcOHaqcOXPq0qVLatasmXmmHcMw9Ntvv+nxxx9XtmzZUrzvjLwWGdGxY0fVqlVL0u0vNbNmzTIHwT127Jg6duxoDgqc8OXnQTZ69Gg5HA7t27dPbdu21T///CPpdrG2YMECdezYUf7+/iku/9lnnylHjhw6dOiQateurZ9//jnRF8AzZ87o+++/12OPPZamU6/fS65cudSxY0fNnz/f3Ivs4MGDat26tQ4ePCh3d3ezEHQ2CZ8Fv/76a6qH8tgh4Ux8f/31l1588UXzi3ZUVJS+/vprderUySxnMtuAAQP01FNP6aeffko0wPK1a9c0adIkfffdd5Kk1q1bW7pdX19fs0j68ccf1b9/f3Pw+OvXr+vTTz/VK6+8Iul2KVGtWrWMP5j7oHv37mratKkMw1CHDh00duzYRIeoRkVFac2aNXrxxRdVokQJG5Mmr3r16qpWrZpiY2PNP1Ck5XA3STp37pxat25tnsHu1q1bmj9/vjp16iRJqlq1qv7zn/8kWua1115TxYoVFR0drcaNG+vzzz9PdHbJ8PBwLVu2TD169FD9+vUz4yECQNoYAADbjBw50pBkSDKCgoIS/eTKlcucJsmoWLGicebMmWRvZ//+/Ubp0qXNed3c3Iw8efIY2bNnT3QbTZs2TbTcndPc3NwMf39/w8fHx7zO4XAYH3/8cZL7+/777815PD09jUKFChnBwcFG3bp1LT3+hNuYNm2apeUaNmxoSDJ69uyZ7PQJEyYYDofDvP3cuXMbXl5eaXouly5danh7e5vz5syZ0/D19TUkGQUKFDCmTp1qTktOel+LO5+PNWvWWHo+DMMwTp8+bTz88MPmbXh5eRm5c+dOlOOTTz5Jdtlp06YZkozg4GDL95sg4TVp2LBhmuZfs2ZNis9jWvIcO3bMXP7YsWNJpn/88ceJnu/cuXObr2uFChXM6WXKlEn29tevX2/kz5/fXN7d3d3Imzev+V5I+OnTp0+aH9fdgoODDUnGhAkTjDJlyhiSDG9v70TrvsPhML755ptkl0/r+yXhcya516Znz56prkuGkfrrcejQIfMzw83NzQgKCjKCg4ON4OBg49SpU6nmSk1q7ycrz3GXLl2SvA/c3d0NSUa1atWMzz77LMXHlpHnJmHZhJ8cOXIkWh8lGfXq1TOuXbuWaLl7va8TvPrqq4neI/7+/oaHh4d5XePGjY3IyMgky6X2XrD62BNeo5EjR6Y4T8J7PLnP+IiICOOJJ55I9Jz4+fkZuXPnTvT57eHhYel2M+LO99a91qtvv/3WnLdChQppvt1FixYZnp6ehiQjV65ciX7fFC1a1Dh69Giyt3HmzBmjdu3aiV733LlzG35+fomew5IlS6b34QOAZeyhBABO4vz584l+rl+/rvz586tFixaaPHmytm/fnuJp0MuVK6e9e/fq66+/VvPmzRUQEKDIyEgZhqGSJUvqySef1DfffKO5c+cmWu63337T0KFDVb9+fRUpUkQ3btyQJJUsWVK9e/fWtm3bzL9236l79+76/vvvVa9ePWXLlk3nzp3TiRMn7jlQbFZ59dVXtX37dnXv3l1FihTR9evX5evrq9q1a+vjjz/Wtm3bUnwuW7durZ07d6pLly4KDAxUbGysgoKCNGDAAO3atUvFixdP9b7T+1pkVKFChbR9+3ZNmDBBtWvXlq+vr65fv64iRYromWee0Y4dOzRw4MBMvU9n9sorr2jt2rVq1aqV/P39FR0drWLFiuntt9/W5s2bzUOgUjpEpW7dujp06JDGjx+vBg0aKHfu3AoPD5e7u7vKlSun7t27a+bMmZo4cWKGs/r7+2vr1q168803VbRoUcXExChPnjxq06aNNmzYYB7u4oxKlSqlNWvWqG3btsqXL58uX76sEydO6MSJE+beVnZKeI0qVaokb29vxcXFqWLFiho3bpw2bNigHDly3Jf7HT58uD799FN16NBBZcuWlYeHh65du6bAwEA1a9ZMU6dO1dq1axONiWfFhAkTtHr1anXs2FFBQUG6du2acubMqcaNG2vq1KlauXKlcubMmcmPKnP5+flpyZIl+vXXX9W5c2fzvX/9+nUVKlRIzZs317hx48w9eZxNp06dzPHa0rp3kiS1a9dOGzduVMeOHeXj4yPDMFS8eHG99tpr2r17d4q/YwoWLKj169frxx9/VNu2bVWgQAFdv35dsbGxKlasmNq0aaOJEydq3bp1mfL4ACAtHEbCFhUAAMC/RLdu3TRr1iw9++yzmjJlii0ZihUrphMnTmjatGmc5htwMT/99JM6deokX19fnT17NtXxk9auXWuO7cZXLwAPEvZQAgAA/yqHDh3SggULJP1vnB0AsOKzzz6TdHvgc2ccMB8AsgKFEgAAeOCMGDFCn3/+uU6ePKn4+HhJtwf6nTNnjho3bqzo6GiVLVs2ycDsAHAv33zzjX7//Xe5ublp0KBBdscBANt42B0AAAAgs+3du1c///yzXnrpJXl6eipnzpwKDw83y6VChQpp3rx58vT0tDkpAFewefNmdenSRREREQoPD5ckvfDCC3r44YftDQYANqJQAgAAD5xXX31VBQsW1MaNG3Xu3DmFhYUpZ86cKl26tJ544gkNGDBAefLksTsmABcRHR2tEydOyN3dXSVKlFDPnj01bNgwu2MBgK0YlBsAAAAAAACWMIYSAAAAAAAALOGQt3SIj4/X2bNnlTNnTjkcDrvjAAAAAAAAZArDMHT16lUVLFhQbm4p74dEoZQOZ8+eVZEiReyOAQAAAAAAcF+cOnVKhQsXTnE6hVI65MyZU9LtJ9fPz8/mNAAAAAAAAJkjMjJSRYoUMbuPlFAopUPCYW5+fn4USgAAAAAA4IFzryF+GJQbAAAAAAAAllAoAQAAAAAAwBIKJQAAAAAAAFhCoQQAAAAAAABLKJQAAAAAAABgCYUSAAAAAAAALKFQAgAAAAAAgCUUSgAAAAAAALCEQgkAAAAAAACWUCgBAAAAAADAEgolAAAAAAAAWEKhBAAAAAAAAEsolAAAAAAAAGAJhRIAAAAAAAAsoVACAAAAAACAJRRKAAAAAAD8S0VFRcnhcMjhcCgqKsruOHAhFEoAAAAAAACwhEIJAAAAAAAAllAoAQAAAAAAwBIKJQAAAAAAAFhCoQQAAAAAAABLKJQAAAAAAABgCYUSAAAAAAAALKFQAgAAAAAAgCUUSgAAAAAAALCEQgkAAAAAAACWUCgBAAAAAADAEgolAAAAAAAAWEKhBAAAAAAAAEsolAAAAAAAAGAJhRIAAAAAAAAsoVACAAAAAACAJRRKAAAAAAAAsIRCCQAAAAAAAJZQKAEAAAAAAMASCiUAAAAAAABYQqEEAAAAAAAASyiUAAAAAAAAYAmFEgAAAAAAACyhUAIAAAAAAIAlFEoAAAAAAACwhEIJAAAAAAAAllAoAQAAAAAAwBIKJQAAAAAAAFhCoQQAAAAAAABLKJQAAAAAAABgCYUSAAAAAAAALKFQAgAAAAAAgCUUSgAAAAAAALCEQgkAAAAAAACWUCgBAAAAAADAEgolAAAAAAAAWEKhBAAAAAAAAEsolAAAAAAAAGAJhRIAAAAAAAAsoVACAAAAAACAJRRKAAAAAAAAsIRCCQAAAAAAAJZQKAEAAAAAAMCSB6JQ+uKLL1SsWDH5+PioVq1a2rp1a6rzh4eH68UXX1SBAgXk7e2t0qVL69dff82itAAAAAAAAK7Nw+4AGTVnzhwNGjRIkyZNUq1atTRx4kS1aNFCf//9twIDA5PMHxsbq2bNmikwMFDz589XoUKFdOLECeXOnTvrwwMAAAAAALggh2EYht0hMqJWrVqqUaOGPv/8c0lSfHy8ihQpopdeeklvvvlmkvknTZqkDz/8UAcPHpSnp2e67jMyMlK5cuVSRESE/Pz8MpQfAAAAAAC7REVFKUeOHJKka9euKXv27DYngt3S2nm49B5KsbGx2rFjh4YOHWpe5+bmpqZNm2rTpk3JLrN48WLVqVNHL774on7++Wfly5dPXbt21ZAhQ+Tu7p7sMjExMYqJiTEvR0ZGZu4DAQAAAACkS7E3f7E7gkuLj402/19u+HK5efnYmMb1HX+vtd0RsoxLj6F06dIlxcXFKSgoKNH1QUFBCg0NTXaZo0ePav78+YqLi9Ovv/6q4cOH66OPPtLYsWNTvJ9x48YpV65c5k+RIkUy9XEAAAAAAAC4EpculNIjPj5egYGB+uabb1StWjV17txZb731liZNmpTiMkOHDlVERIT5c+rUqSxMDAAAAAAA4Fxc+pC3gIAAubu76/z584muP3/+vPLnz5/sMgUKFJCnp2eiw9vKlSun0NBQxcbGysvLK8ky3t7e8vb2ztzwAAAAAAAALsql91Dy8vJStWrVFBISYl4XHx+vkJAQ1alTJ9ll6tatq8OHDys+Pt687tChQypQoECyZRIAAAAAAAASc+lCSZIGDRqkyZMna8aMGTpw4ICef/55RUVFqXfv3pKkHj16JBq0+/nnn1dYWJhefvllHTp0SL/88oveffddvfjii3Y9BAAAAAAAAJfi0oe8SVLnzp118eJFjRgxQqGhoapSpYqWL19uDtR98uRJubn9rzcrUqSIVqxYoVdffVWVKlVSoUKF9PLLL2vIkCF2PQQAAAAAAACX4vKFkiQNGDBAAwYMSHba2rVrk1xXp04dbd68+T6nAgAAAAAAeDC5/CFvAAAAAAAAyFoUSgAAAAAAALCEQgkAAAAAAACWUCgBAAAAAADAEgolAAAAAAAAWEKhBAAAAAAAAEsolAAAAAAAAGAJhRIAAAAAAAAsoVACAAAAAACAJRRKAAAAAAAAsIRCCQAAAAAAAJZQKAEAAAAAAMASCiUAAAAAAABYQqEEAAAAAAAASyiUAAAAAAAAYAmFEgAAAAAAACyhUAIAAAAAAIAlFEoAAAAAAACwhEIJAAAAAAAAllAoAQAAAAAAwBIKJQAAAAAAAFhCoQQAAAAAAABLKJQAAAAAAABgCYUSAAAAAAAALKFQAgAAAAAAgCUUSgAAAAAAALCEQgkAAAAAAACWUCgBAAAAAADAEgolAAAAAAAAWEKhBAAAAAAAAEsolAAAAAAAAGAJhRIAAAAAAAAsoVACAAAAAACAJRRKAAAAAAAAsIRCCQAAAAAAAJZQKAEAAAAAAMASCiUAAAAAAABYQqEEAAAAAAAASyiUAAAAAAAAYImH3QEAAAAAAIA93Lx8FDxkqd0x4ILYQwkAAAAAAACWUCgBAAAAAADAEgolAAAAAAAAWEKhBAAAAAAAAEsolAAAAAAAAGAJhRIAAAAAAAAsoVACAAAAAACAJRRKAAAAAAAAsIRCCQAAAAAAAJZQKAEAAAAAAMASCiUAAAAAAABYQqEEAAAAAAAASyiUAAAAAAAAYAmFEgAAAIAHRlRUlBwOhxwOh6KiouyOAwAPLAolAAAAAAAAWEKhBAAAAAAAAEsolAAAAAAAAGAJhRIAAAAAAAAseSAKpS+++ELFihWTj4+PatWqpa1bt6ZpudmzZ8vhcKh9+/b3NyAAAAAAAMADxOULpTlz5mjQoEEaOXKkdu7cqcqVK6tFixa6cOFCqssdP35cr7/+uurXr59FSQEAAAAAAB4MLl8oTZgwQX379lXv3r1Vvnx5TZo0SdmyZdPUqVNTXCYuLk7dunXT6NGjVaJEiSxMCwAAAAAA4PpculCKjY3Vjh071LRpU/M6Nzc3NW3aVJs2bUpxuTFjxigwMFDPPfdcmu4nJiZGkZGRiX4AAAAAAAD+rVy6ULp06ZLi4uIUFBSU6PqgoCCFhoYmu8z69es1ZcoUTZ48Oc33M27cOOXKlcv8KVKkSIZyAwAAAAAAuDKXLpSsunr1qp555hlNnjxZAQEBaV5u6NChioiIMH9OnTp1H1MCAAAAAAA4Nw+7A2REQECA3N3ddf78+UTXnz9/Xvnz508y/5EjR3T8+HG1adPGvC4+Pl6S5OHhob///lsPPfRQkuW8vb3l7e2dyekBAABSFxUVpRw5ckiSrl27puzZs9ucCAAA4LYM7aG0cOFCPfXUU6pUqZJKlixpXn/w4EF98MEHOnPmTIYDpsbLy0vVqlVTSEiIeV18fLxCQkJUp06dJPOXLVtWf/75p3bv3m3+tG3bVo0bN9bu3bs5lA0AAAAAACAN0rWHUnx8vJ5++mnNnz9fkuTr66sbN26Y0/39/fXWW28pLi5OQ4cOzZykKRg0aJB69uyp6tWrq2bNmpo4caKioqLUu3dvSVKPHj1UqFAhjRs3Tj4+PqpQoUKi5XPnzi1JSa4HAAAAAABA8tK1h9LHH3+sefPmqV+/frpy5Ypef/31RNODgoJUv359/fLLL5kSMjWdO3fW+PHjNWLECFWpUkW7d+/W8uXLzYG6T548qXPnzt33HACAe4uKipLD4ZDD4VBUVJTdcQAAAACkU7r2UJo+fbpq1KihL7/8UpLkcDiSzFOyZMksKZQkacCAARowYECy09auXZvqstOnT8/8QAAAAAAAAA+wdO2hdPjwYdWvXz/VefLmzavLly+nKxQAAAAAAACcV7oKJV9fX0VERKQ6z4kTJ8zxiQAAAAAAAPDgSFeh9Mgjj2jFihWKjo5OdnpYWJiWL1+u2rVrZygcAAAAAAAAnE+6CqWBAwfq9OnT6tixo06fPp1o2pEjR9ShQwdFRERo4MCBmRISAAAAAAAAziNdg3K3a9dOQ4YM0fvvv6/g4GBlz55dkhQYGKjLly/LMAwNHz5cTZo0ydSwAAAAAAAAsF+69lCSpHHjxmnFihV64oknlC1bNrm7uys+Pl4tW7bUsmXLNHr06MzMCQAAAAAAACeRrj2UTp48KS8vLzVr1kzNmjXL7EwAAAAAAABwYunaQ6l48eIaNmxYZmcBAAAAAACAC0hXoeTv76+8efNmdhYAAAAAAAC4gHQVSvXr19eWLVsyOwsAAAAAAABcQLoKpXHjxmnv3r0aM2aMbt26ldmZAAAAAAAA4MTSNSj3Bx98oIoVK2r06NH6+uuvVblyZQUFBcnhcCSaz+FwaMqUKZkSFAAAAAAAAM4hXYXS9OnTzf+fO3dO586dS3Y+CiUAAAAAAIAHT7oKpWPHjmV2DgAAAAAAALiIdBVKwcHBmZ0DAAAAAAAALiJdg3IDAAAAAADg3ytDhdLMmTPVrFkz5cuXT97e3sqXL5+aN2+uWbNmZVY+AAAAAAAAOJl0HfIWFxenp556SosWLZJhGPLx8VHBggV1/vx5rVq1SiEhIfrpp580b948ubmxExQAAAAAAMCDJF1tz6effqqFCxeqbt262rBhg65fv65jx47p+vXr2rhxo+rVq6dFixbps88+y+y8AAAAAAAAsFm6CqUZM2aodOnSCgkJUZ06dRJNq127tlatWqXSpUtr2rRpmRISAAAAAAAAziNdhdKhQ4fUtm1beXp6Jjvd09NTbdq00aFDhzIUDgAAAAAAAM4nXWMoeXl5KSoqKtV5oqKi5OXlla5QAAAAwL9VsTd/sTuCS4uPjTb/X274crl5+diYxvUdf6+13REAOKl07aH0yCOPaO7cuTp79myy08+dO6e5c+eqatWqGQoHAAAAAAAA55OuQmnQoEG6fPmyqlevro8++kjbt2/XqVOntH37do0fP17VqlVTWFiYBg0alNl5AQAAAAAAYLN0HfLWpk0bjR8/Xm+++abeeOONRNMMw5CHh4fGjx+vJ554IlNCAgAAAAAAwHmkq1CSbu+l1L59e82cOVO7d+9WZGSk/Pz89Mgjj6hr164qUaJEZuYEAAAAAACAk0h3oSRJJUqU0PDhwzMrCwAAAAAAAFxAusZQAgAAAAAAwL9Xugqljz76SAEBASme5e3s2bPKly+fPv300wyFAwAAAAAAgPNJV6E0b948Va5cWQULFkx2esGCBVWlShXNnj07Q+EAAAAAAADgfNJVKP3zzz96+OGHU53n4Ycf1j///JOuUAAAAAAAAHBe6SqUbty4oezZs6c6j4+Pj65du5auUAAAAAAAAHBe6SqUihYtqo0bN6Y6z6ZNm1S4cOF0hQIAAAAAAIDzSleh1Lp1a61fv15Tp05Ndvq3336r9evXq02bNhkKBwAAAAAAAOfjkZ6F3nzzTf3444/q27evfvjhBzVr1kyFChXSmTNn9Ntvv2ndunUqWLCghg4dmtl5AQAAAAAAYLN0FUr58uXTmjVr1L17d61du1Zr166Vw+GQYRiSpBo1amjmzJnKly9fpoYFAACupdibv9gdwaXFx0ab/y83fLncvHxsTOP6jr/X2u4IAAA8MNJVKElSmTJltG3bNm3btk1bt25VRESEcufOrZo1a6p69eqZmREAAAAAAABOJN2FUoIaNWqoRo0amZEFAAAAAAAALiDDhdKdjh8/rpUrV8rHx0cdOnRQjhw5MvPmAQAAAAAA4ATSdZa3d999V8WLF9eVK1fM69auXasKFSqof//+6tWrl6pWraqwsLBMCwoAAAAAAADnkK5CadGiRSpWrJj8/f3N64YMGaL4+HiNHj1azz//vA4fPqyJEydmVk4AAAAAAAA4iXQd8nb8+HE9+eST5uWzZ89q27Zteu211/T2229Lkv7++28tXLhQY8aMyZykAOAEOGNVxnDGqszFGasAAABgl3TtoRQZGancuXObl9etWyeHw6E2bdqY11WtWlUnT57McEAAAAAAAAA4l3QVSkFBQTpx4oR5eeXKlfL29latWrXM66Kjo+VwODKeEAAAAAAAAE4lXYe81ahRQz///LOWLl0qHx8fzZkzR40bN5a3t7c5z7Fjx1SwYMFMCwoAAAAAAADnkK49lIYNG6Zbt26pXbt2atGihaKjozVs2DBzekxMjNatW5dojyUAAAAAAAA8GNK1h1LVqlW1efNmff/995Kkp556SjVr1jSn79q1S40bN1bXrl0zJyUAAAAAAACcRroKJUmqXLmyKleunOy02rVra+HChekOBQAAAAAAAOeVrkPeAAAAAAAA8O9FoQQAAAAAAABLKJQAAAAAAABgCYUSAAAAAAAALKFQAgAAAAAAgCUUSgAAAAAAALCEQgkAAAAAAACWeGRk4dDQUO3YsUPh4eGKi4tLdp4ePXpk5C4AAAAAAADgZNJVKEVHR6tv376aPXu24uPjk53HMAw5HA4KJQAAAAAAgAdMugqlN998UzNnzlTp0qX19NNPq3DhwvLwyNDOThnyxRdf6MMPP1RoaKgqV66szz77TDVr1kx23smTJ+u7777Tvn37JEnVqlXTu+++m+L8AAAAAAAASCxdLdDcuXNVvnx57dixQ97e3pmdyZI5c+Zo0KBBmjRpkmrVqqWJEyeqRYsW+vvvvxUYGJhk/rVr1+rpp5/Wo48+Kh8fH73//vtq3ry5/vrrLxUqVMiGRwAAAAAgs7h5+Sh4yFK7YwDAAy9dg3KHh4erZcuWtpdJkjRhwgT17dtXvXv3Vvny5TVp0iRly5ZNU6dOTXb+mTNn6oUXXlCVKlVUtmxZffvtt4qPj1dISEgWJwcAAAAAAHBN6SqUypQpo/Pnz2d2FstiY2O1Y8cONW3a1LzOzc1NTZs21aZNm9J0G9evX9fNmzeVJ0+e+xUTAAAAAADggZKuQmnw4MH6+eefdfjw4czOY8mlS5cUFxenoKCgRNcHBQUpNDQ0TbcxZMgQFSxYMFEpdbeYmBhFRkYm+gEAAAAAAPi3StcYSoULF1aLFi1Us2ZNvfLKK6patar8/PySnbdBgwYZCng/vffee5o9e7bWrl0rHx+fFOcbN26cRo8enYXJAAAAAAAAnFe6CqVGjRrJ4XDIMAyNGjVKDocjxXnj4uLSHe5eAgIC5O7unuTwu/Pnzyt//vypLjt+/Hi99957WrVqlSpVqpTqvEOHDtWgQYPMy5GRkSpSpEj6gwMAAAAAALiwdBVKI0aMSLVEyipeXl6qVq2aQkJC1L59e0kyB9geMGBAist98MEH+r//+z+tWLFC1atXv+f9eHt7O8UA5AAAAAAAAM4gXYXSqFGjMjlG+g0aNEg9e/ZU9erVVbNmTU2cOFFRUVHq3bu3JKlHjx4qVKiQxo0bJ0l6//33NWLECM2aNUvFihUzx1rKkSOHcuTIYdvjAAAAAAAAcBXpKpScSefOnXXx4kWNGDFCoaGhqlKlipYvX24O1H3y5Em5uf1v7PGvvvpKsbGx6tSpU6LbGTlypFMVZQAAAAAAAM7K5QslSRowYECKh7itXbs20eXjx4/f/0AAAAAAAAAPMLd7z5K8U6dOqV+/fnrooYfk6+srd3f3JD8eHg9EXwUAAAAAAIA7pKvxOXr0qGrVqqUrV67o4YcfVkxMjIKDg+Xj46OjR4/q5s2bqly5snLnzp3JcQEAAAAAAGC3dO2hNHr0aEVERCgkJER79uyRJPXu3VsHDhzQ8ePH1bZtW0VFRWn+/PmZGhYAAAAAAAD2S1ehtGrVKrVq1UoNGzY0rzMMQ5JUoEABzZkzR5I0bNiwTIgIAAAAAAAAZ5KuQunSpUsqW7asednDw0PXr183L3t7e6tZs2ZaunRpxhMCAAAAAADAqaSrUAoICFBUVFSiy3efPc3Dw0Ph4eEZyQYAAAAAAAAnlK5BuUuVKqUjR46Yl2vWrKkVK1bo6NGjKlGihC5evKj58+froYceyrSgAAAA/zZuXj4KHsIe3wAAwPmkaw+lxx9/XGvWrDH3QHrllVd09epVVapUSTVq1FDp0qUVGhqql156KTOzAgAAAAAAwAmkq1B6/vnntXbtWrm7u0uSGjVqpNmzZys4OFj79u1TUFCQPv30U/Xt2zdTwwIAAAAAAMB+6Trkzc/PT7Vq1Up03ZNPPqknn3wyU0IBAAAAAADAeaVrDyUAAAAAAAD8e2WoUFq4cKGeeuopVapUSSVLljSvP3jwoD744AOdOXMmwwEBAAAAAADgXNJ1yFt8fLyefvppzZ8/X5Lk6+urGzdumNP9/f311ltvKS4uTkOHDs2cpICTiYqKUo4cOSRJ165dU/bs2W1OBAAAAABA1kjXHkoff/yx5s2bp379+unKlSt6/fXXE00PCgpS/fr19csvv2RKSAAAAAAAADiPdBVK06dPV40aNfTll1/Kz89PDocjyTwlS5bUsWPHMhwQAAAAAAAAziVdhdLhw4dVv379VOfJmzevLl++nK5QAAAAAAAAcF7pGkPJ19dXERERqc5z4sQJ5c6dOz03DwB4QLl5+Sh4yFK7YwAAAADIoHTtofTII49oxYoVio6OTnZ6WFiYli9frtq1a2coHAAAAAAAAJxPugqlgQMH6vTp0+rYsaNOnz6daNqRI0fUoUMHRUREaODAgZkSEgAAAAAAAM4jXYe8tWvXTkOGDNH777+v4OBg83TpgYGBunz5sgzD0PDhw9WkSZNMDQsAAAAAAAD7pWsPJUkaN26cVqxYoSeeeELZsmWTu7u74uPj1bJlSy1btkyjR4/OzJwAAAAAAABwEunaQylBs2bN1KxZs8zKAgAAAAAAABeQ7j2UAAAAAAAA8O+UoT2U4uLidPr0aZ09e1Y3b95Mdp4GDRpk5C4AAAAAAADgZNJVKMXHx+vdd9/VJ598orCwsFTnjYuLS1cwAAAAAAAAOKd0FUpDhw7Vhx9+qMDAQPXu3VsFChSQh0eGdnYCAAAAAACAi0hXCzRjxgyVKVNG27ZtU44cOTI7EwAAAAAAAJxYugblvnbtmlq3bk2ZBAAAAAAA8C+UrkKpUqVKOnv2bGZnAQAAAAAAgAtIV6H01ltvadGiRdq5c2dm5wEAAAAAAICTS9cYSq1bt9b06dP1+OOPq23btqpcubL8/PySnbdHjx4ZCggAAAAAAADnkq5CKSYmRkuWLNGlS5c0ZcoUSZLD4Ug0j2EYcjgcFEoAAAAAAAAPmHQVSoMGDdLMmTNVqVIlderUSQUKFJCHR7puCgAAAAAAAC4mXS3QvHnzVK1aNW3atIkiCQAAAAAA4F8mXYNyR0dHq3HjxpRJAAAAAAAA/0LpKpSqVaumw4cPZ3YWAAAAAAAAuIB0FUrvvvuuli9frqVLl2Z2HgAAAAAAADi5dB2ztnLlSjVq1Ejt2rVTkyZNVLlyZfn5+SWZz+FwaPjw4RkOCQAAAAAAAOeRrkJp1KhR5v9DQkIUEhKS7HwUSgAAAAAAAA+edBVKa9asyewcAAAAAAAAcBHpKpQaNmyY2TkAAAAAAADgItI1KDcAAAAAAAD+vSiUAAAAAAAAYAmFEgAAAAAAACyhUAIAAAAAAIAlFEoAAAAAAACwhEIJAAAAAAAAllAoAQAAAAAAwBIKJQAAAAAAAFhCoQQAAAAAAABLKJQAAAAAAABgCYUSAAAAAAAALKFQAgAAAAAAgCUUSgAAAAAAALCEQgkAAAAAAACWUCgBAAAAAADAEgolAAAAAAAAWEKhBAAAAAAAAEseiELpiy++ULFixeTj46NatWpp69atqc4/b948lS1bVj4+PqpYsaJ+/fXXLEoKAAAAAADg+ly+UJozZ44GDRqkkSNHaufOnapcubJatGihCxcuJDv/xo0b9fTTT+u5557Trl271L59e7Vv31779u3L4uQAAAAAAACuyeULpQkTJqhv377q3bu3ypcvr0mTJilbtmyaOnVqsvN/8sknatmypQYPHqxy5crpnXfeUdWqVfX5559ncXIAAAAAAADX5NKFUmxsrHbs2KGmTZua17m5ualp06batGlTssts2rQp0fyS1KJFixTnBwAAAAAAQGIedgfIiEuXLikuLk5BQUGJrg8KCtLBgweTXSY0NDTZ+UNDQ1O8n5iYGMXExJiXIyMjM5AaAAAAAADAtbl0oZRVxo0bp9GjR9sdI9MVe/MXuyO4tPjYaPP/5YYvl5uXj41pXN/x91rbHSFNXCUn4CxYZwDrWG8Aa1hnAHu49CFvAQEBcnd31/nz5xNdf/78eeXPnz/ZZfLnz29pfkkaOnSoIiIizJ9Tp05lPDwAAAAAAICLculCycvLS9WqVVNISIh5XXx8vEJCQlSnTp1kl6lTp06i+SVp5cqVKc4vSd7e3vLz80v0AwAAAAAA8G/l8oe8DRo0SD179lT16tVVs2ZNTZw4UVFRUerdu7ckqUePHipUqJDGjRsnSXr55ZfVsGFDffTRR2rdurVmz56t7du365tvvrHzYQAAAAAAALgMly+UOnfurIsXL2rEiBEKDQ1VlSpVtHz5cnPg7ZMnT8rN7X87Yj366KOaNWuW3n77bQ0bNkylSpXSokWLVKFCBbseAgAAAAAAgEtxGIZh2B3C1URGRipXrlyKiIhw6cPfGJQ7Y+Jjo3Xq406SpCKvzmdQ7gxiMEUAAAAAsF9aOw+XHkMJAAAAAAAAWY9CCQAAAAAAAJZQKAEAAAAAAMASCiUAAAAAAABYQqEEAAAAAAAASyiUAAAAAAAAYAmFEgAAAAAAACyhUAIAAAAAAIAlFEoAAAAAAACwhEIJAAAAAAAAllAoAQAAAAAAwBIKJQAAAAAAAFhCoQQAAAAAAABLKJQAAAAAAABgCYUSAAAAAAAALKFQAgAAAAAAgCUOwzAMu0O4msjISOXKlUsRERHy8/OzOw5sEhUVpRw5ckiSrl27puzZs9ucCAAAAACAjElr58EeSgAAAAAAALCEQgkAAAAAAACWUCgBAAAAAADAEgolAAAAAAAAWEKhBAAAAAAAAEsolAAAAAAAAGAJhRIAAAAAAAAsoVACAAAAAACAJRRKAAAAAAAAsIRCCQAAAAAAAJZQKAEAAAAAAMASCiUAAAAAAABYQqEEAAAAAAAASyiUAAAAAAAAYAmFEgAAAAAAACyhUAIAAAAAAIAlFEoAAAAAAACwhEIJAAAAAAAAllAoAQAAAAAAwBIKJQAAAAAAAFhCoQQAAAAAAABLKJQAAAAAAABgCYUSAAAAAAAALKFQAgAAAAAAgCUUSgAAAAAAALCEQgkAAAAAAACWUCgBAAAAAADAEgolAAAAAAAAWEKhBAAAAAAAAEsolAAAAAAAAGAJhRIAAAAAAAAsoVACAAAAAACAJRRKAAAAAAAAsIRCCQAAAAAAAJZQKAEAAAAAAMASCiUAAAAAAABYQqEEAAAAAAAASyiUAAAAAAAAYAmFEgAAAAAAACyhUAIAAAAAAIAlFEoAAAAAAACwxKULpbCwMHXr1k1+fn7KnTu3nnvuOV27di3V+V966SWVKVNGvr6+Klq0qAYOHKiIiIgsTA0AAAAAAODaXLpQ6tatm/766y+tXLlSS5cu1bp16/Tf//43xfnPnj2rs2fPavz48dq3b5+mT5+u5cuX67nnnsvC1AAAAAAAAK7NYRiGYXeI9Dhw4IDKly+vbdu2qXr16pKk5cuXq1WrVjp9+rQKFiyYptuZN2+eunfvrqioKHl4eKRpmcjISOXKlUsRERHy8/NL92OAa4uKilKOHDkkSdeuXVP27NltTgQAAAAAQMaktfNw2T2UNm3apNy5c5tlkiQ1bdpUbm5u2rJlS5pvJ+EJSmuZBAAAAAAA8G/nsi1KaGioAgMDE13n4eGhPHnyKDQ0NE23cenSJb3zzjupHiYnSTExMYqJiTEvR0ZGWg8MAAAAAADwgHC6PZTefPNNORyOVH8OHjyY4fuJjIxU69atVb58eY0aNSrVeceNG6dcuXKZP0WKFMnw/QMAAAAAALgqp9tD6bXXXlOvXr1SnadEiRLKnz+/Lly4kOj6W7duKSwsTPnz5091+atXr6ply5bKmTOnFi5cKE9Pz1TnHzp0qAYNGmRejoyMpFQCAAAAAAD/Wk5XKOXLl0/58uW753x16tRReHi4duzYoWrVqkmSVq9erfj4eNWqVSvF5SIjI9WiRQt5e3tr8eLF8vHxued9eXt7y9vbO+0PAgAAAAAA4AHmdIe8pVW5cuXUsmVL9e3bV1u3btWGDRs0YMAAdenSxTzD25kzZ1S2bFlt3bpV0u0yqXnz5oqKitKUKVMUGRmp0NBQhYaGKi4uzs6HAwAAAAAA4DKcbg8lK2bOnKkBAwbosccek5ubmzp27KhPP/3UnH7z5k39/fffun79uiRp586d5hngSpYsmei2jh07pmLFimVZdgAAAAAAAFflMAzDsDuEq4mMjFSuXLkUEREhPz8/u+PAJlFRUcqRI4ck6dq1a8qePbvNiQAAAAAAyJi0dh4ue8gbAAAAAAAA7EGhBAAAAAAAAEsolAAAAAAAAGAJhRIAAAAAAAAsoVACAAAAAACAJRRKAAAAAAAAsIRCCQAAAAAAAJZQKAEAAAAAAMASCiUAAAAAAABYQqEEAAAAAAAASyiUAAAAAAAAYAmFEgAAAAAAACyhUAIAAAAAAIAlFEoAAAAAAACwhEIJAAAAAAAAllAoAQAAAAAAwBIKJQAAAAAAAFhCoQQAAAAAAABLKJQAAAAAAABgCYUSAAAAAAAALPGwOwDgqrJnzy7DMOyOAQAAAABAlmMPJQAAAAAAAFhCoQQAAAAAAABLKJQAAAAAAABgCYUSAAAAAAAALKFQAgAAAAAAgCUUSgAAAAAAALCEQgkAAAAAAACWUCgBAAAAAADAEgolAAAAAAAAWEKhBAAAAAAAAEsolAAAAAAAAGAJhRIAAAAAAAAsoVACAAAAAACAJRRKAAAAAAAAsIRCCQAAAAAAAJZ42B3AFRmGIUmKjIy0OQkAAAAAAEDmSeg6ErqPlFAopcPVq1clSUWKFLE5CQAAAAAAQOa7evWqcuXKleJ0h3GvyglJxMfH6+zZs8qZM6ccDofdcWCjyMhIFSlSRKdOnZKfn5/dcQCXwHoDWMM6A1jHegNYwzqDOxmGoatXr6pgwYJyc0t5pCT2UEoHNzc3FS5c2O4YcCJ+fn588AIWsd4A1rDOANax3gDWsM4gQWp7JiVgUG4AAAAAAABYQqEEAAAAAAAASyiUgAzw9vbWyJEj5e3tbXcUwGWw3gDWsM4A1rHeANawziA9GJQbAAAAAAAAlrCHEgAAAAAAACyhUAIAAAAAAIAlFEoAAAAAAACwhEIJAAAAAAAAllAoAQAAAAAAwBIKJQAAAAAAAFjiYXcAAAAAJC8iIkLZsmWTp6en3VEAp3Xjxg1t3bpVp0+f1qVLl5QtWzbly5dPFStW1EMPPWR3PAB4YFEoAel04sSJJBsuZcuWlY+Pj93RAAAu6Nq1a5o3b55CQkK0YcMGnT17Vrdu3ZIk5cyZUxUrVlSjRo3Url07Va9e3ea0gL1u3Lih2bNna/r06dq8ebO5rhiGIYfDYc5XoEABdejQQf/9739VsWJFu+ICTun69evauHGjNmzYkGwh27BhQ5UsWdLumHBiDsMwDLtDAK5izZo1mj59ukJCQnTu3Lkk0z09PVW9enV16NBBvXr1Ut68eW1ICTiXo0ePavXq1alurDRo0EBeXl52RwVscerUKY0dO1Y//vijrl27Jkny9/dXUFCQ8uTJoxs3bigsLEynT59WXFycHA6HqlSpokGDBqlbt242pweyVmxsrCZOnKj33ntP4eHhypYtm6pVq6bq1asnWWf+/vtvbdmyRceOHZPD4VCTJk00fvx4Va5c2e6HAdhq06ZNmjRpkubPn6/o6GilVAk4HA6VK1dO/fv3V48ePeTn55fFSeHsKJSANJg7d65GjhypQ4cOyTAMFSlSJMUNl127dikmJkbe3t7q3r27xowZowIFCtj9EIAsZRiGZs+erUmTJmn9+vXmdclxOBzy9/dXr1699OKLL6p48eJZGRWw1ZtvvqlPP/1UcXFxevzxx/XUU0+pTp06ya4H169f144dO/Tbb79p1qxZOnbsmKpWrarJkyfrkUcesSE9kPWKFSumM2fOqF27durevbtat259z0NCjx49qu+//14zZszQyZMnNXnyZPXu3TuLEgPO46+//tLgwYO1YsUKubu7q1GjRqpTp06K32s2b96s1atX6+TJk8qbN6+GDx+uF154QR4eHOiE2yiUgHuoXbu2tm7dqqpVq6p79+568sknVahQoRTnv3nzptatW6cffvhBCxYsUHx8vL777jt16NAhC1MD9lm+fLneeOMN7du3TwEBAWrfvn2qGytbtmzRb7/9po0bN8rT01MvvPCChg8fLn9/f7sfCnDf5c6dWwMHDtQrr7yiPHnyWFp21apVGjNmjJo2baoRI0bcp4SAc3nmmWc0YsQIlSpVyvKycXFxmj59utzc3CiU8K/k4eGh4OBgvfrqq+rSpYsCAgLStNzvv/+uyZMna86cORo1apTeeuut+5wUroJCCbiHBg0aaNSoUWrSpInlZcPDw/XRRx8pICBAL7/88n1IBzgfNzc31atXT2+88YZatmyZ5r9inThxQpMnT9bnn3+uQYMG8QUZ/wpXrlzJcHmaGbcBAHjwTZkyRT179kz3Hkb//POPTp8+rcaNG2dyMrgqCiUAQKYKCQnRY489lu7lw8PDdezYMQ7hAQAAAJwYhRIAAAAAAAAscbM7AAAAwL/V7NmzM7T8qVOntGHDhkxKAzi/li1batu2belaNioqSu+9956++OKLTE4FuIaoqCinuA08OCiUgHvo37+/zpw5k+7lZ8+erZkzZ2ZiIsC5nTx5MsO3kZF1DnAl3bt3V6VKlTRjxgxdu3Ytzctt375d/fr1U6lSpbRmzZr7mBBwLhcvXlTt2rXVuHFjTZs2TREREfdcZvPmzRowYICCg4P1zjvvKCgoKAuSAs6nePHi+vDDD9NVCm3atEktW7bUhAkT7kMyuCoOeQPuoVChQgoLC1OXLl3Uo0ePNA1Cd/bsWc2aNUtTp07V33//ra+//lp9+vTJgrSA/by9vdWnTx+9/vrryZ76PCU3b97U/PnzNXbsWHXu3JlBufGvsGvXLg0aNEi///67smXLppYtW6pWrVqqVq2agoKClDt3bkVHRyc6K+LKlSv1zz//yM/PT0OHDtXLL78sb29vux8KkGVmzJih0aNH6/jx43Jzc1OZMmVSXGe2b9+uq1evyt3dXV26dNHYsWNVtGhRux8CYItXXnlFX331lby8vPSf//xHnTp1Uu3atZUvX74k8966dUt79uzRypUrNXPmTO3fv1/ly5fXtGnTVL16dRvSwxlRKAH3cOPGDX3wwQf66KOPFBUVpTx58qhmzZqpbuwfOHBA8fHxqlevnj788EPVqlXL7ocBZJmJEydq7NixunLliurVq2durFSpUkWenp6J5j19+rT5BXn+/Pm6cuWKWrRooU8//VQlS5a06REAWW/16tX66quvtHjxYt28eVMOhyPZ+QzDUIkSJdSvXz/16dOHs7vhX8swDP3666+aNm2a1q5dq7CwsCTzuLm5qVKlSurQoYP69OmjAgUK2JAUcC7//POP3nnnHc2bN0+xsbGSbv8B/e7vNceOHVNMTIwMw1D58uU1aNAg9erVS25uHOSE/6FQAtLo6tWr+u677zRt2jTt3r1b8fHxkmRu9CesSnny5FG7du3Uv39/1ahRw7a8gJ3Cw8M1YcIETZkyRefOnZPD4ZCbm5ty586daGMlOjpa0u31qEWLFnrttdfUpEkTm9MD9gkPD9fvv/+ujRs36vTp07p8+bJ8fX2VL18+VaxYUQ0bNlSlSpXsjgk4nQMHDiRZZx5++GHlypXL7miAUwoLC9OsWbMUEhKijRs36uLFi+Y0T09PVahQQQ0bNlSHDh1Uv359G5PCmVEoAekQHh6uTZs2JbuxX7FiRbvjAU4jLi5Oy5YtMzdWUvqC3K5dOwUHB9sdFwAA4F/p5s2b5jYaRSzSikIJAADASYwZM0bFixfXM888Y3cUwCWUKFFCjz/+OGduA9Lh5MmT8vLyUv78+e2OAhfFAZCARU2aNNHw4cPtjgG4jHXr1mn37t12xwBcwtixY/Xnn3/aHQNwGZcuXZKfn5/dMQCXVLx4cQ0bNszuGHBhFEqARVu2bFFcXJzdMQCX0bhxY33zzTd2xwBcQtGiRRUeHm53DMBlVKpUSYcOHbI7BuCS/P39lTdvXrtjwIVRKAEWlS1bVidOnLA7BuAyAgMD5ePjY3cMwCV06dJFy5cvV0REhN1RAJcwZMgQLVmyRGvWrLE7CuBy6tevry1bttgdAy6MMZQAi6ZPn64BAwZo69atKl++vN1xAKfXo0cP7du3Tzt27EjxVOgAbouJiVHHjh117tw5jRkzRjVq1FBgYKDdsQCn9d1332nu3LlasWKF2rdvrxo1aigoKCjZ3zc9evSwISHgvA4ePKjatWtr0KBBGjZsmDw8POyOBBdDoQRYtG7dOn3wwQdat26d+vXrl+qGS4MGDWxICDiXs2fPqk6dOmrevLnef/995cmTx+5IgNNyd3eXJBmGkWoB63A4dOvWrayKBTgtNzc3ORwO3f2V5s71J2F9YsgCILFnn31W//zzjzZu3Kj8+fOrcuXKyX6vcTgcmjJlik0p4cwolACL7t5wSW2Dnw0X4PZA9pcvX9a+ffvk5eWl4sWLp7ixEhISYlNKwDk0atQozXvycYgPIM2YMSPN8/bs2fM+JgFcj5tb2kbAoZBFSiiUAItGjRqV5o39kSNH3uc0gPNjYwUAAMD5WBkXNjg4+D4mgauiUAIAAAAAAIAlnOUNAADAycTGxurXX3/VhAkT9M4775jXR0dH68KFC4qPj7cxHeB8Fi5cqKeeekqVKlVSyZIlzesPHjyoDz74QGfOnLExHeAawsLCdOrUKbtjwIVQKAHptGvXLr3xxhtq27atmjZtal5/4sQJzZ07V2FhYTamA5zTtWvXtHPnTv3xxx92RwGc1uLFi1W0aFG1adNGr7/+ukaNGmVO27t3rwoUKKDZs2fbFxBwIvHx8ercubM6deqkn376SUePHtWxY8fM6f7+/nrrrbf03Xff2ZgScF4RERF6+eWXFRQUpHz58ql48eLmtC1btqhVq1basWOHjQnhzCiUgHR44403VL16dY0fP15Lly5NNDCqYRjq2rWrvv/+exsTAs7l+PHjateunfz9/VWjRg01btzYnLZhwwaVL19ea9eutS8g4CQ2bNigTp06ydvbW5988om6du2aaHrNmjVVsmRJ/fTTTzYlBJzLxx9/rHnz5qlfv366cuWKXn/99UTTg4KCVL9+ff3yyy82JQScV1hYmGrVqqXPPvtMRYoUUbly5RKdMbFSpUrasGGDZs6caWNKODMKJcCiadOmafz48XriiSe0d+9eDR06NNH0YsWKqWbNmlq8eLFNCQHncvLkSdWuXVu//vqr2rVrpzp16iTaWKlVq5YuXbqkH3/80caUgHN45513lDt3bu3YsUMDBgxQqVKlksxTvXp17dmzx4Z0gPOZPn26atSooS+//FJ+fn7JnjilZMmSifZaAnDbqFGjdOjQIc2ePVvbt2/Xk08+mWi6r6+vGjZsqNWrV9uUEM6OQgmw6Msvv1S5cuX0008/qUKFCvLy8koyT9myZfXPP//YkA5wPiNHjtSVK1f0+++/a/78+WrWrFmi6R4eHqpfv742bNhgU0LAeWzZskXt2rVTQEBAivMUKVJEoaGhWZgKcF6HDx9W/fr1U50nb968unz5chYlAlzH4sWL9cQTT+ipp55KcZ5ixYrp9OnTWZgKroRCCbBo//79atasmTw8PFKcJygoSBcuXMjCVIDzWrFihTp06KBHH300xXmCg4MZMBWQFBMTIz8/v1TnCQ8Pl5sbm3CAdHsPioiIiFTnOXHihHLnzp01gQAXcu7cOZUvXz7Veby9vRUVFZVFieBq2BoBLPLw8FBsbGyq85w9e1Y5cuTIokSAcwsLC1OxYsVSnccwDMXExGRNIMCJlShRQtu2bUt1nk2bNqls2bJZlAhwbo888ohWrFih6OjoZKeHhYVp+fLlql27dhYnA5xf3rx573lWt4MHD6pAgQJZlAiuhkIJsKhixYpavXq14uLikp1+/fp1rVq1StWqVcviZIBzCgoKuuchoH/++aeKFi2aRYkA59WxY0dt2LBB06ZNS3b6+PHjtW/fPnXu3DmLkwHOaeDAgTp9+rQ6duyY5LCcI0eOqEOHDoqIiNDAgQNtSgg4rwYNGujnn39O8ZC2/fv3a/ny5YnOaA3ciUIJsOjZZ5/VoUOH1L9//yR7VERGRqpXr14KDQ1V3759bUoIOJdmzZpp6dKl2rt3b7LT//jjD61evVqtWrXK4mSA8xk8eLDKlSunPn36qFmzZgoJCZF0++yi9evX15AhQ1SlShUNGDDA5qSAc2jXrp2GDBmiZcuWKTg4WB999JEkKTAwUKVLl9Yff/yht99+W02aNLE5KeB83nrrLcXFxalu3bqaOXOmLl26JEk6cOCApkyZoiZNmsjb21uDBw+2OSmclcO481Q7ANKka9eumj17tnLkyKHcuXPrzJkzqlatmg4cOKCoqCj16tVLU6dOtTsm4BSOHz+uKlWqSLr9ZfngwYOaNWuWli5dqo0bN2rChAnKnj279uzZwy7VgKQrV65owIABmjt3bqK9YR0Oh5566il9+eWX8vf3tzEh4HxWrlypzz//XFu2bFFYWJj8/PxUq1YtDRw4UC1atLA7HuC0Fi9erGeeeUbXrl2TdHsYAofDIcMwlDNnTv3444/80Q8polAC0mny5Mn6/PPPtW/fPvMU6OXKldPAgQPVr18/m9MBzmXLli3q0qWLTpw4YW6kJPxbtGhRzZ8/X9WrV7c7JuBULl++rG3btplfjmvUqKGgoCC7YwEAHjBhYWGaMWNGkkK2d+/eqZ51FKBQAjLoxo0bunLlivz8/BiIG0jFrVu3tGTJkiQbK+3atZOXl5fd8QAAAABYQKEEAAAAwKXFxcXp9OnTOnv2rG7evJnsPA0aNMjiVADwYPOwOwDgyuLj43X+/PkUN1w4axUAwKpjx47pk08+0Z49e1L8cuxwOHTkyBEb0gHOJT4+Xu+++64++eQThYWFpTpvSmfoBf7tdu/efc/fOcOHD7chGZwdhRKQDj/88IPGjx+v/fv3p7hx4nA4dOvWrSxOBjgnwzD0888/33NjZcqUKTakA5zH8uXL1b59e8XGxsrT01OBgYHy8Ei6ucYO5sBtQ4cO1YcffqjAwED17t1bBQoUSHadAZDUhQsX1LVrV61Zs0ZSyr9bKJSQEg55AywaP368hgwZIk9PT9WrVy/VDZdp06ZlcTrA+Rw+fFhPPPGE/vnnn1S/BDscDv56jH+9ypUr6/Dhw5o+fbo6duwoNzc3uyMBTi1//vzy9/fXtm3bGMsSsOjJJ5/UTz/9pFatWqlLly6pfq9p2LBhFqeDK6BQAiwKDg6WYRjauHGjChcubHccwOm1aNFCK1eu1PPPP6+nn3461Y2V4ODgLE4HOBdfX191795dkydPtjsK4BJy5Mih/v37a/z48XZHAVxOwhlEQ0JC7I4CF8X+oIBFFy9eVL9+/SiTgDT6448/1LZtW33xxRd2RwGcXv78+eXj42N3DMBlVKpUSWfPnrU7BuCSPD09Va1aNbtjwIWxHzVgUenSpXXlyhW7YwAuI2fOnCpZsqTdMQCX0LVrVy1btkzR0dF2RwFcwltvvaVFixZp586ddkcBXE79+vW1e/duu2PAhXHIG2DRjBkz9Morr2j37t0cngOkQffu3XX06FFt3LjR7iiA07t586Y6dOigq1ev6t1331XlypUZFwa4h7lz5+qll15S27ZtVblyZfn5+SU7X48ePbI4GeDcDhw4oLp162rMmDEaMGCA3XHggiiUgHT48MMPNXHiRL3wwgupbrg0aNAgi5MBzufcuXOqU6eOnnzySb3zzjsczgPcw2+//aYuXbooIiIixXk4kyhwW0xMjPr06aNZs2aZJ35wOByJ5jEMgxM/ACn466+/VL9+fQUEBKhSpUrJfq/hTLxICYUSkA7Dhw/Xxx9/rBs3bqQ6HxsuwG1///236tSpo7i4OJUqVSrFjRUGhcS/3Zw5c9StWzfFx8erRIkSqQ5in3CaZ+Df7MUXX9RXX32lSpUqqVOnTqmuMz179szidIBzO3bsmJo3b64jR46kOh+FLFJCoQRYNGLECP3f//2f8uXLpyeeeCLVDZeRI0dmcTrA+ezatUvNmjVTWFhYqvOxsQJIDz/8sEJDQ7V8+XLVqFHD7jiA0wsMDFRwcLA2bdqU4vYYgOQ98cQT+vXXXzkTL9KNT13AoqlTp6p06dLatm0b41oAafDKK68oPDxc77//vrmx4u7ubncswCkdO3ZMvXv3pkwC0ig6OlqNGzemTALSYd26dWrTpg1n4kW68ckLWHTlyhV16dKFMglIox07dqhz584aPHiw3VEAp1ekSBH21AMsqFatmg4fPmx3DMAleXt7q3Tp0nbHgAtzszsA4GoqVqyoc+fO2R0DcBl+fn4KCgqyOwbgEvr27aslS5bc8xBRALe9++67Wr58uZYuXWp3FMDlNGvWjLPwIkMYQwmwaMmSJerSpYv++OMPVa1a1e44gNN7/vnntWnTJu3cuVNubvwdA0jN8ePH9eqrr+rgwYN6++23Uz2TaNGiRbM4HeB8xowZo82bN2vFihVq0qRJiuuMw+HQ8OHDbUgIOK+zZ8+qXr166tixI2fiRbpQKAEWfffdd1qwYIGWL1+uZ555JtWN/R49emRxOsD5REZGqlmzZipRooTGjx+vQoUK2R0JcFpubm5yOBzmac5T4nA4dOvWrSxMBjintP6hghM/AEk1adJEV65c0d69e5UjRw7OxAvLKJQAi+7c2E9w90Z/whcBNlwAqUSJEoqNjTUPFfX3909xY+Vep60FHnS9evVKtUi607Rp0+5zGsD5/f7772met2HDhvcxCeB6KGSRUQzKDVjEBjxgTXx8vDw9PRMdnpPc3zL4+wYgTZ8+3e4IgEtxOBzy8/NTlSpV7I4CuJz4+Hi7I8DFsYcSYNHJkyfl5eWl/Pnz2x0FAPCAKVGihFq1aqXPP//c7iiAS3B3d1e/fv305Zdf2h0FcDljxoxR8eLF9cwzz9gdBS6K0VEBi4oXL6633nrL7hiAy3j22Wf18ccf2x0DcAmXLl1Szpw57Y4BuIzAwEAGEgbSaezYsfrzzz/tjgEXRqEEWOTv7688efLYHQNwGbNmzdKFCxfsjgG4hEqVKunQoUN2xwBcRrNmzbR27VoOmwbSoWjRogoPD7c7BlwYhRJgUf369bVlyxa7YwAu46GHHjIH5AaQuiFDhmjJkiVas2aN3VEAl/Dee+/p8uXL+u9//6uwsDC74wAupUuXLlq+fLkiIiLsjgIXxRhKgEUHDx5U7dq1NWjQIA0bNkweHoxtD6Tmo48+0nvvvafdu3erUKFCdscBnNp3332nuXPnasWKFWrfvr1q1KihoKCgZM/81qNHDxsSAs6lSZMmunz5svbt2ycvLy8VL1482XWG054DScXExKhjx446d+6cxowZoxo1aigwMNDuWHAhFEqARc8++6z++ecfbdy4Ufnz51flypVT3HCZMmWKTSkB53H8+HENGDBAf/75p954441UvyDfeSY44N/Izc1NDocjyeE7d64vhmFwCmfg/+O050D6ubu7S/rf75WUOBwO3bp1K6tiwYVQKAEWseECWHPnF2Q2VoDUzZgxI83z9uzZ8z4mAQA86Bo1apTqttmdOBQbyaFQAiw6ceJEmucNDg6+j0kA19CrV680b6xMmzbtPqcBAAAAkBkolAAAAAA8EKKiohQZGSk/Pz9lz57d7jgA8EBjNGEAAAAnc/z4cc2cOVO7d+82vxxXqVJF3bp1U7FixeyOBziV2NhYffjhh5o+fbqOHj1qXl+iRAn17t1br7/+ury8vGxMCDi/M2fOJPmdw8lUcC/soQSk08yZMzV9+vREH7yPPPKIevXqpa5du9odD3BKGzZsSLKxUrduXbtjAU7lk08+0RtvvKFbt24lGZzb09NTH3zwgV5++WWb0gHO5caNG3rssce0ZcsWubu7q0SJEipQoIBCQ0N15MgRxcXFqVatWgoJCZGvr6/dcQGnc/jwYT3//PNavXp1kmmPPfaYvvzyS5UsWdKGZHAFFEqARXFxcXrqqae0aNEiGYYhHx8fBQUF6fz584qOjpbD4VD79u01b968NA/gDTzoNm7cqN69e+vw4cOSEp9NpFSpUpo2bZrq1KljZ0TAKSxdulRt27ZVQECAXn31VTVu3Nj8crxmzRpNmDBBly9f1uLFi9W6dWu74wK2GzVqlMaMGaPOnTvrgw8+UJEiRcxpp0+f1htvvKHZs2dr5MiRGjlypI1JAedz6tQp1ahRQxcuXFDZsmXVoEED83fOunXrdODAAQUFBWnr1q2J1i0gAYUSYNHHH3+s1157TfXq1dP777+f6Evw5s2bNWTIEK1fv14TJkzgL8iApL/++ku1atXS9evX1axZsyRfkH/77TflyJFDmzdvVvny5e2OC9iqSZMm2rt3r3bv3q3ChQsnmX7q1Ck98sgjqly5skJCQmxICDiXcuXKKXv27Nq+fXuK89SoUUPXrl3TgQMHsjAZ4Pz69OmjqVOn6ssvv1S/fv2SnETl66+/1vPPP6/nnntOkydPtiklnBmFEmBRlSpVFB0drT///FOenp5Jpt+8eVOVKlWSt7e3du/enfUBASfTuXNnLVy4UIsXL1bLli2TTF++fLnatm2r//znP5o9e7YNCQHnkTt3bnXr1k1ffPFFivO88MILmjVrlsLDw7MuGOCkfH199eqrr+rdd99NcZ6hQ4dq4sSJunHjRhYmA5xfkSJFVLVqVf38888pztOuXTvt2LFDp0+fzsJkcBUcjwNYdOjQIbVt2zbZMkm6Pb5FmzZtdOjQoSxOBjintWvXqlOnTsmWSZLUsmVLderUSWvWrMniZIDziY2NveeZqXLkyKHY2NgsSgQ4t2zZsunixYupznPx4kVly5YtixIBruPChQuqUKFCqvNUqFDhnusY/r0olACLvLy8FBUVleo8UVFRnE0E+P8iIiJUvHjxVOcpXry4IiIisigR4LxKly6tJUuW6NatW8lOv3XrlpYuXarSpUtncTLAOdWuXVuzZ8/WX3/9lez0/fv3a86cOYzTByQjX7582r9/f6rz7N+/X/ny5cuiRHA1FEqARY888ojmzp2rs2fPJjv93Llzmjt3rqpWrZrFyQDnVLBgQW3evDnVebZs2aKCBQtmUSLAefXo0UN///23WrRooR07diSatn37dj3++OP6+++/1bNnT5sSAs5l2LBhio6OVo0aNfTSSy9p/vz5+uOPPzR//nwNGDBANWrUUExMjIYOHWp3VMDptGjRQosXL9aUKVOSnT516lQtWbIkxb3MAcZQAixasmSJ2rVrp/z58+u1115Tw4YNzbO8rV27VhMmTND58+f1888/64knnrA7LmC7V155RZ999pmGDRumt956Sz4+Pua06OhojRs3TmPHjtXAgQP18ccf25gUsF9cXJw6duyoxYsXy+FwKFu2bAoMDNSFCxd0/fp1GYahdu3a6aeffuJMosD/N2/ePPXt21eRkZGJBhU2DEO5cuXS5MmT1alTJxsTAs7p5MmTql69ui5fvqzy5csn+l6zbt06/fXXXwoICND27ds5yxuSRaEEpMOECRP05ptvKi4uLtH1hmHIw8ND77//vl599VWb0gHO5fLly6pVq5aOHTumvHnzqmbNmubGyrZt23Tx4kWVKFFCW7duVZ48eeyOCziF7777TjNmzNDu3bsVGRkpPz8/PfLII+rZs6eeeeYZu+MBTufq1av6+eeftWvXrkTrTLt27ZQzZ0674wFO69ChQ+rfv7/Wrl2bZFrjxo311VdfcZg1UkShBKTT0aNHNXPmzCQb+127dlWJEiXsjgc4lUuXLumNN97Q7NmzFR0dbV7v4+Ojp59+Wu+//74CAgJsTAjYY+/evcqfP78CAwPtjgK4hEGDBqlly5Zq3ry5pNt7WOTOnVt+fn42JwNc26lTpxJ9r6lSpQp7JeGeKJSAe/j0009Vu3Zt1axZ0+4ogMu7efOmDh48aG6slC1bNsUzJgL/Bu7u7ho5cqRGjBghSWrSpIl69eqlHj162JwMcE5ubm4aNWqUuc7cvQ4BSFnVqlXVv39//fe//5V0e2/YKlWqqFKlSjYng6vi4HvgHl555RUtX77cvOzu7q533nnHxkSAc8uTJ48++OAD8/KYMWO0bt06SZKnp6cqVqyounXrqmLFipRJ+Ndzd3dPdPj02rVrdfz4cfsCAU4uR44cun79unmZv40Dabd7926Fhoaal3v16qVFixbZFwguz8PuAICz8/X1VUxMjHnZMAw2XoBUREREJDqsbdSoURo1apQaNGhgYyrAORUuXFi7d++2OwbgMkqVKqUFCxaoQ4cOKlCggCQpPDxcJ0+evOeyRYsWvd/xAKcWEBCgS5cu2R0DDxAKJeAeihcvrhUrVmjgwIEKCgqSpERnEAGQWFBQkE6fPm13DMAltGnTRp999pnKlStnfjmePn16soOj3snhcCgkJCQLEgLO5fXXX1f37t316KOPmtd98skn+uSTT1JdzuFw6NatW/c7HuDUKleurO+//16FChUyf+fs3r1b33333T2X5VBsJIcxlIB7+PTTT/XKK6+YJZJhGGkqlNhwwb9Vhw4dtHz5cvXq1UsFChTQqFGj1KhRIzVq1CjV5RwOh4YPH541IQEncfXqVQ0ePFi//PKLzp49Kylth/A4HI4kZxoF/i02b96sX375RWfOnNH06dNVuXJlValS5Z7LTZs27f6HA5zYjh071KpVK128eFEOhyNN32sS5uF3DpJDoQSkwezZs82N/TVr1ig4OFjFihW753Jr1qy5/+EAJ3P48GG1a9dOBw4ckCRzg+Ve2FgBkg44DCB1rDOANVevXtXWrVt15swZ9erVS+3bt1e7du3uuVzPnj2zIB1cDYUSYBEbLsC9xcfH69ixYzpz5owaNWqkXr16pWlDpGHDhlmQDnBevXv3VocOHdS2bVu7owAu4ffff1exYsUUHBxsdxTA5fC9BhlFoQRYNGPGDFWpUkWVK1e2OwrgEooXL65XX31VAwcOtDsKAOBfIjIyUlu2bJGPj4/q1avH+JcAcB9QKAGZxDAMHT58WD4+PipSpIjdcQAALujPP//Utm3b1KlTJ/n5+UmSbty4oUGDBmnx4sXy9fXV66+/rv79+9ucFHAOkydP1g8//KBFixbJ399fkrRnzx49/vjjOn/+vCSpTp06+u2335QtWzY7owJOKT4+Xm5ubomu27Rpk5YuXSofHx/17t1bhQsXtikdnJ3bvWcBcKcFCxaoR48eunLlinnd8ePHValSJZUtW1bFihVTly5dGAsG+P+uXr2qo0eP6ubNm4munzNnjrp166bnnntOO3futCkd4FzGjh2r4cOHK2fOnOZ1w4YN09dff62rV6/q1KlTevHFF7Vy5UobUwLO4/vvv1dMTIxZJknSa6+9pgsXLqh3795q1aqVNm3apK+++srGlIBzevXVV5UtWzaFh4eb182fP1/169fXuHHjNHLkSFWtWpWz9yJF7KEEWNSsWTOdP39ee/fuNa/r0KGDfv75ZzVp0kSXL1/W3r17NWnSJPXt29fGpIBzeP755/XDDz/o/Pnz5l+Hv/rqKw0YMMAcrNvX11c7duxQ2bJl7YwK2K548eKqW7eufvjhB0nSrVu3FBAQoLJly2rt2rUKCwtT1apVVb16dS1dutTmtID98ufPr3bt2unrr7+WJF2+fFmBgYHq27evJk2aJEmqXbu2YmNj+eMFcJcqVaqoYMGC+vXXX83rypcvr/Pnz+uTTz5RaGiohg4dqhdffFETJ060LyicFnsoARbt379fNWvWNC9fvXpVv/zyizp37qxVq1Zp69atKleunKZOnWpjSsB5/P7772ratGmiQw3ee+89FSpUSOvWrdPcuXNlGIY+/PBDG1MCzuHixYuJDpvetm2bIiMj1b9/f/n4+KhgwYJq166d9uzZY2NKwHmEh4crX7585uU//vhDkvSf//zHvK5evXo6fvx4VkcDnN6pU6dUqlQp8/KxY8d08OBBDRw4UN27d9frr7+uVq1aafny5TamhDOjUAIsCgsLU/78+c3L69ev161bt/T0009Lkjw9PdWsWTMdOXLEroiAUzl37pyKFy9uXj5w4IBOnTqlgQMHql69eurUqZPatm2rdevW2ZgScA4eHh6KiYkxL69du1YOh0ONGzc2r8ubN68uXbpkRzzA6eTNm1fnzp0zL4eEhMjd3V1169Y1rzMMI8lh1wCkqKgoZc+e3bz8+++/y+Fw6PHHHzevK1++PIe8IUUUSoBFfn5+unz5snl5zZo1cnNzU/369c3rPD09FRUVZUc8wOnExMTIy8vLvJywsdK8eXPzuhIlSujMmTN2xAOcSrFixbRmzRrz8rx581S8ePFEp0Q/c+aM8ubNa0c8wOlUqlRJP//8s/bt26fDhw9r1qxZqlu3bqIvycePH1eBAgVsTAk4p4IFC+rvv/82Ly9fvlw5cuRQtWrVzOsiIyPl7e1tRzy4AAolwKKyZctqyZIlunz5ssLDwzVr1ixVq1Yt0WCQJ06cUFBQkI0pAedRuHDhRGOOLV26VHny5FGlSpXM6y5fvqwcOXLYEQ9wKs8884z27NmjWrVqqUGDBtqzZ4+6du2aaJ69e/cmOkQB+Dd74403dOXKFVWuXFllypRReHi4Bg0aZE6Pj4/X+vXrE31BBnBbw4YN9csvv+jzzz/Xt99+qwULFqhFixZyd3c35zly5AhneUOKPOwOALiagQMH6sknn1ThwoXNPZHGjh2baJ7NmzeratWqNiUEnMvjjz+uL774Qq+//rp8fHy0fPly9ejRI9E8hw4dUtGiRW1KCDiPAQMGaOvWrZo/f74Mw1CrVq00bNgwc/pff/2lPXv2aPTo0TamBJxH48aNtXjxYk2bNk2S1KVLF7Vp08acvmHDBhUsWDDRmEoAbnvrrbe0aNEivfzyyzIMQ9mzZ9eoUaPM6VevXtW6devUq1cv2zLCuXGWNyAdvvrqK02ZMkXS7Q2X119/3Zz2+++/q3379nrvvffUr18/uyICTiM0NFSPPvqoOSBqgQIFtGXLFvOvXRcuXFDhwoU1YMAATZgwwcakgPOIjIyUw+FQzpw5E11/6dIlnTlzRsWKFVOuXLlsSgcAeFCcO3dOP/30kySpTZs2iQ6x3rlzp77//nt17dpVNWrUsCsinBiFEgDgvrtx44ZCQkIkSQ0aNJCfn585bf/+/Vq5cqVatGihsmXL2hURAAAAgAUUSgAAAE4oKipK4eHhiouLS3Y6h4kC/7N161Zt27YtxXXG4XBo+PDhNiQDgAcXhRKQTqGhodqxY0eqG/t3jxMDAMC9TJkyRR999FGiM+/czeFw6NatW1mYCnBOYWFhat++vTZs2KDUvtY4HI4Ut9eAf7OLFy9q2rRp9yxkE/Y0B+7EoNyARdHR0erbt69mz56t+Pj4ZOcxDEMOh4NCCfj/9u/fr88///yeGytHjhyxIR3gPL766iu9+OKL8vDwUIMGDVS4cGF5eLC5BqRk0KBBWr9+vRo1aqSePXuyzgAW7N27V02aNNGVK1fuWcgCyWEPJcCiV155RZ9++qlKly6tp59+OtUNl549e2ZxOsD5/P7772rZsqViYmLk4eGhoKCgFNeZY8eOZXE6wLmUKVNGV65c0fr161W6dGm74wBOLyAgQCVLltSmTZv40gtY1KxZM4WEhOjtt9/Wc889p8KFC8vd3d3uWHAh1PeARXPnzlX58uW1Y8cOeXt72x0HcHpvvvmmbt26pW+//VY9e/ZkQwVIxYkTJ9SnTx/KJCCNbty4oQYNGlAmAemwadMmtW/fXmPGjLE7ClyUm90BAFcTHh6uli1bUiYBabRnzx516dJFzz77LGUScA8FChRgnBfAgipVquj48eN2xwBckpeXlx566CG7Y8CFUSgBFpUpU0bnz5+3OwbgMrJnz67AwEC7YwAuoWfPnlq2bJmioqLsjgK4hJEjR2rx4sXavHmz3VEAl9OwYUNt377d7hhwYYyhBFg0a9Ys9e/fXzt37lTJkiXtjgM4vZ49e+rAgQPaunWr3VEAp3fr1i09/fTTOnPmjN577z1VrVpVOXLksDsW4LS+++47/fzzz1q6dKm6deumqlWrys/PL9l5OVkKkNiRI0dUu3ZtDRkyRK+//rrdceCCKJQAi9atW6fPPvtMISEheuWVV1LdcGnQoEEWpwOcz4ULF1SvXj21bNlS7733nrJly2Z3JMBpJRwWmnC20JQ4HA7dunUrq2IBTsvNzU0OhyPRGaruXncS1icOJwUSe/bZZ3Xs2DGtW7dOxYsXV5UqVZL9XuNwODRlyhQbEsLZUSgBFt294ZLaBj8bLoDUpEkThYeHa8+ePcqePbtKly6d4sZKSEiIDQkB59GoUaM0Dy68Zs2a+5wGcH4zZsxI87ycfRdIzM0tbSPgUMgiJRRKgEWjRo1K88b+yJEj73MawPmxsQIAAOB8Tpw4keZ5g4OD72MSuCoKJQAAAAAAAFjiYXcAAAAAAMiouLg4Xbp0STExMclOL1q0aBYnAoAHG4USAACAE4mLi9PcuXO1atUqnT17Ntkvx4w5BvzPjh07NGzYMK1bt06xsbHJzsNA9kDKoqOjtW3bthR/50icJRHJo1AC0uHUqVMaO3asubGf3MYLGy5AYqdPn9aaNWtS/YI8fPhwG5IBziMqKkrNmzfX5s2bzTNT3X32qnudAQ74N9m9e7fq168vDw8PNW/eXEuWLFHlypWVP39+7dy5UxcvXlSjRo0Y/wVIwRdffKHhw4crIiIi2ekJv3MolJAcCiXAoqNHj6pWrVq6cuWKHn74YcXExCg4OFg+Pj46evSobt68qcqVKyt37tx2RwWcxuDBg/XJJ58kGnT7zi/FCf+nUMK/3dixY7Vp0yaNGTNGL7zwggICAjRq1Cj169dP69at07Bhw1S1alXNnDnT7qiAU3jnnXckSVu2bFG5cuXk5uamDh06aMSIEbpx44Zee+01zZ8/X1OnTrU5KeB8FixYoJdeekkVK1bU8OHD9dprr6l9+/aqVauW1q1bp2XLlqljx4564okn7I4KJ5W2U+8AMI0ePVoREREKCQnRnj17JEm9e/fWgQMHdPz4cbVt21ZRUVGaP3++zUkB5zB58mR99NFHaty4sebPny/DMNSzZ0/9+OOP6t+/vzw8PPTkk09q9erVdkcFbLdgwQLVrl1bb7/9tvLkyWNeHxQUpCeffFJr1qzRqlWr9OGHH9qYEnAe69evV9u2bVWuXDnzuoS9+nx9ffX555+rYMGCGjZsmF0RAac1ceJEBQYGatOmTXr11VclSVWqVNGQIUP0yy+/6IcfftCiRYvYww8polACLFq1apVatWqlhg0bmtclbLgUKFBAc+bMkSQ2XID/75tvvlGxYsW0bNkydejQQZJUrFgxde7cWV988YV+++03LVy4UBcvXrQ5KWC/kydPqnbt2uZlNze3RIeIFi5cWK1bt9aMGTPsiAc4nYiICJUoUcK87OnpqWvXrpmX3dzc1KhRI8YcA5Kxd+9etW3bVtmyZTOvu3Nv8q5du6pJkyYaM2aMHfHgAiiUAIsuXbqksmXLmpc9PDx0/fp187K3t7eaNWumpUuX2hEPcDoHDx5Uy5Yt5eb2v185d44v1rBhQ7Vu3Vrjx4+3Ix7gVLJnz55oXcmVK5fOnTuXaJ78+fPr5MmTWR0NcEqBgYG6cuWKeTl//vz6559/Es0THR2daFsNwG03b95Uvnz5zMu+vr4KDw9PNE/lypW1c+fOLE4GV0GhBFgUEBCgqKioRJePHz+eaB4PD48kH8bAv9mdY4plz55dly9fTjS9TJky+uuvv7I4FeB8goODE5VFFSpU0OrVq829lAzDUEhIiAoUKGBXRMCplC9fXn///bd5uW7duvrtt9+0adMmSdKBAwc0d+7cRH8MBHBbwYIFE/3RIjg4WLt27Uo0z4kTJ+ThwdDLSB6FEmBRqVKldOTIEfNyzZo1tWLFCh09elSSdPHiRc2fP18PPfSQXREBp1KoUCGdPn3avPzQQw9py5YtiebZt2+fsmfPntXRAKfz2GOPac2aNeZefD179tTJkydVp04dDR48WPXq1dPu3bvVsWNHm5MCzqF169Zat26d+aV4yJAhMgxD9erVU758+VSxYkWFh4czFAGQjBo1aiTa+6hly5basGGDxo0bp7/++ktff/21FixYoBo1atiYEs7MYdx5LloA9/T+++9r1KhROnfunHLnzq21a9fqsccek6+vr8qVK6fDhw8rMjJSkyZNUt++fe2OC9juueee0x9//KFDhw5JkkaOHKmxY8eqT58+atu2rdavX68PPvhAHTt21Ny5c21OC9jrn3/+0YIFC9SjRw9zL6SXXnpJX375pTleX8eOHTVjxoxEY14A/1Y3b95UWFiY/P395eXlJUnauHGj/u///k9Hjx5VcHCwXnrpJbVu3drmpIDzWbhwoYYN+3/t3XdUFGf7PvBrFkQsgBUUkGZsGAWNYkEBsfsaYotioYhRk2gSNVETY8ESW1ATNeobpYg1ahJbFA0EBbGj2MBGEQtFQUBREJb9/eGX/Uko7vrKzqxcn3NyTmbm3nOuPxzm2XufeZ5ZOHz4MKysrPDw4UN06NBB+UOgQqGAkZERIiIi0KZNG5HTkhSxoUSkppycHMTFxcHW1hYGBgYAgN27d8PX17fEwGXSpEkiJyWShmPHjmHZsmXYsGEDLC0t8fTpUzg7O+PixYsQBAEKhQJWVlYIDw/nLiJE5Xj48KHyGdOoUSOx4xAR0Tvq8ePH2LRpk/KZ4+HhATMzM7FjkUSxoURERBpXUFCAffv2IT4+HpaWlvjwww/5yhsRgAULFsDa2hoeHh5iRyHSCjY2Nujfvz9++eUXsaMQaZ3k5GTo6enxhwp6Y1xdi0hNrq6ucHR0xMKFC8WOQqQVIiIiYGhoCHt7e+W5atWqYdiwYeKFIpKoRYsWYcqUKWLHINIajx49gqGhodgxiLSStbU1vLy8EBAQIHYU0lJclJtITWfOnIFcLhc7BpHW6NGjB3799VexYxBpBQsLC+4SSqSGtm3bKtfoIyL11K1bF/Xr1xc7BmkxNpSI1NSyZUvcuXNH7BhEWsPY2Bj6+vpixyDSCu7u7ggJCUF2drbYUYi0wsyZM3HgwAGEh4eLHYVI63Tv3r3UzrtE6uAaSkRqCgoKwuTJk3H27FnY2tqKHYdI8jw9PXH16lVER0dDEASx4xBJWn5+PoYOHYqUlBQsWLAAHTt2hLGxsdixiCQrODgYu3btwpEjRzBo0CB07NgRJiYmZT5vPD09RUhIJF3Xr19H586dMW3aNMyaNQu6ulwRh9TDhhKRmiIiIrB8+XJERERg4sSJFQ5cnJycREhIJC0PHjxAly5d0KdPHyxbtgz16tUTOxKRpAQHB8Pe3h5t27aFjo4OgJdbNVfUgBUEAYWFhZqKSCQprq6uGDt2LDw8PCCTyZQ7hr7q1fun+H7ikgVEJfn4+ODWrVs4efIkGjVqBDs7uzK/1wiCAH9/f5FSkpSxoUSkAh8fHwwaNAhubm6lBi4VDfg5cKGqKjk5GXXq1IGhoSFcXV2RkZGBq1evQk9PD9bW1uUOVsLCwkRKTCQemUyG+fPnY86cOXBxcVF5Jh9f8aGqSiaTwdfXF3PnzkVQUJDK94yXl1clJyOSPh0dHfj6+mLOnDmQyVRbAYcNWSoP57QRqSAoKAhWVlZwc3PD3Llz+doO0WtYW1srByvHjh1Tns/Pz8f169dx/fr1Up/hfUVVWfGPFK/eL0T0et7e3mJHINIqCoVC+cxJTEwUOQ1pOzaUiNTk6+srdgQiyXt1sFJUVCRyGiIiIiL6N0tLS7EjkJbjLm9ERERERERERKQWzlAiIiIiEllMTAyCg4PV+gx3rKKqLCgoSK1XRLlOH9H/x2UG6G3hotxEKpDJZLC3t4e9vb3Kn+FuCFSVyWQyTJkyBVOmTFHrcxYWFpUTiEjCijd7UBV3rKKqTtWFhF/Fe4boJXWfOQB3FqXysaFEpAIOXIjUw8EKkepkMhlcXFzg7Oys1ufmzZtXSYmIpK34R4uvvvpKrc9xvRiil/ePkZER6tSpo9bnuIA3lYWvvBGpyNvbm9vNEqnBwsICVlZWYscg0gouLi6YO3eu2DGItEadOnXYICJ6Q1OnTuUzh94KNpSIVGRlZaX2r8dEVdnYsWM5WCEiIiIiekdxlzciIiIiIiIiIlILG0pERERERERERKQWNpSIiIiIROTl5aXWLqJEVV14eLhyXcuIiAgkJydXWH/37l1ERERoIhoRUZXChhKRCgIDA/HRRx8BAJKTk5GTk1Nh/ZMnT147uCF6l1laWqq9ewhRVRUYGAg3NzcAgI2NDVavXl1h/S+//AIbGxtNRCOSJGdnZ+WC3D169EBQUFCF9cHBwejRo4cGkhFJX1FRkXKNywULFry22RoZGYkFCxZoIhppITaUiFTg5eUFOzs7AIC1tTV+/vnnCutXr14Na2trTUQjkqTExER8+eWXAAAfHx/s37+/wvqDBw/Cx8dHE9GIJC0pKQlZWVkV1mRlZeHOnTuaCUQkcQqF4rU1RUVFEARBA2mItIuvry+OHTtWYU1ERATmz5+vmUCkddhQIlKTQqF47eBFlcENUVURFBSEmJiYCmsuXbqEzZs3ayYQkZbLzs5G9erVxY5BpDVu3boFIyMjsWMQaaUXL15AR0dH7BgkUbpiByB6F927dw8GBgZixyDSGnl5edDV5SOJqqZ/v26QlJRU5isIcrkcd+/exbZt29C8eXNNxSOSnH/PaN27dy+SkpJK1RXfMxEREejfv7+G0hFpl4pm77148QKRkZEwNjbWYCLSJhy9E6ng3+8Nlzc1tHjgsnPnTnTu3FkDyYi0Q3mDFYVCgbt37+Lw4cMwNTXVcCoiaXBxcVHeI4IgYPPmzeXO2FMoFBAEAUuXLtVkRCJJeXXNJEEQEBMTU+5MWEEQ0LFjR6xatUoz4Ygk7t9r8K1atQqBgYGl6uRyOR49eoS8vDyMHz9eU/FIywgKvptD9Foy2f9/O1QQhNe+0mZqaoo///wTHTt2rOxoRJIkk8mUX5CLvwBXRKFQYObMmViyZIkm4hFJiq+vr/LZsmDBAjg7O8PFxaVUnY6ODurVq4cePXqgVatWmg9KJBHFa4gpFArY2NhgypQp+Oqrr0rV6ejooG7duqhVq5amIxJJlpWVlXJclpycDENDwzI3Uil+5ri6umLOnDm8j6hMbCgRqeD48eMAXg5cXF1d4e3trdyu9lXFf3hbtmxZoglFVNW8OuMiIiICFhYWsLKyKlX36mBl/PjxfEefqrwePXpg7Nix8PT0FDsKkVbYvHkz2rVrh7Zt24odhUjryGQy+Pr6Knd9I1IXG0pEapo/fz569OgBJycnsaMQaQUOVoiIiIik586dO6hTpw4Xrac3xoYSERERkQTl5uYiKysLcrm8zOsWFhYaTkQkXWfPnsW5c+fKvWcEQcCcOXNESEZE9O5iQ4noDaWmpiI6OrrCwT5fWSAiInX5+/tjxYoVuHHjRrk1giCgsLBQg6mIpCkzMxODBg1CVFRUhWtcCoJQ7niNqCp7+PAhAgMDX9uQDQsLEyEdSR13eSNSU/FOBzt37kRRUVGZNcWLELOhRPRSbGws1q5d+9rBSnx8vAjpiKRj/fr1mDRpEnR1deHk5ARzc3Po6nK4RlSeadOm4cSJE3BxcYGXlxfvGSI1XL58Ga6urnj8+PFrG7JEZeEMJSI1TZkyBatXr0bz5s0xcuTICgcuZS3cTVTVHD9+HP369UN+fj50dXVhYmJS7j2TmJio4XRE0tKiRQs8fvwYJ06cQPPmzcWOQyR5DRo0wHvvvYdTp07xSy+Rmnr37o2wsDDMnj0b48aNg7m5OTdIIbWwfU+kpl27dsHW1hbR0dGoXr262HGIJO/bb79FYWEhNm3aBC8vLw5UiCpw584dfPLJJ2wmEano+fPncHJyYjOJ6A2cOnUKgwYNwoIFC8SOQlqK+5oTqSkrKwv9+vVjM4lIRZcuXYK7uzt8fHzYTCJ6jcaNG3OdFyI12NvbIykpSewYRFpJT08PTZs2FTsGaTE2lIjU1KJFC6SlpYkdg0hr1KpVC8bGxmLHINIKXl5eOHz4MHJzc8WOQqQV5s2bh/379+P06dNiRyHSOs7Ozjh//rzYMUiLcQ0lIjVt374dn376KS5cuID33ntP7DhEkufl5YW4uDicPXtW7ChEkldYWIiRI0fi/v37WLp0Kdq3b4/atWuLHYtIsoKDg7Fv3z4cPHgQo0ePRvv27WFoaFhmLTdLISopPj4enTt3xsyZM/HNN9+IHYe0EBtKRGqKiIjAmjVrEBYWhilTplQ4cHFyctJwOiLpSU9PR7du3dCvXz8sXboUNWvWFDsSkWQVvxZavFtoeQRBQGFhoaZiEUmWTCaDIAgldqj6971TfD/xdVKiknx8fJCYmIiIiAhYW1vD3t6+zO81giDA399fhIQkdWwoEanp3wOXigb8HLgQAa6ursjKysKlS5dQq1YtNG/evNzBSlhYmAgJiaTDxcVF5cWFw8PDKzkNkfRt3rxZ5VruvktUkkym2go4bMhSedhQIlKTr6+vyoP9efPmVXIaIunjYIWIiIhIeu7cuaNyraWlZSUmIW3FhhIREREREREREamFu7wREREREREREZFadMUOQERERFRV+fj4QBAELF68GCYmJvDx8VHpc1wglaoqmUwGmUyG2NhYNG/eXLm25etwIXuil5sLAYCDgwP09fWVx6rgZkNUFr7yRvQaNjY2EAQBoaGhsLa2ho2NjUqfEwQB8fHxlZyOSHqCg4MBAIMHD4aBgYHyWBXc0pmqmuIvw3Fxccovx6rgmmNUVRUvXL9lyxaYm5tzIXsiNZT1zFH1/uEzh8rCGUpEr1FUVFTiD+2/j8vDXi1VVd7e3hAEAZ07d4aBgYHyuCLFWzqzoURVTWJiIgDAzMysxDERle3YsWMVHhNR+ebOnQtBENCgQYMSx0RvijOUiIjorQoKCoIgCBgyZAgMDAyUx6rgls5ERKSOiIgIGBoawt7eXuwoRERVDhtKRGpKTk6Gnp4eGjVqJHYUIiJ6x9jY2KB///745ZdfxI5CpBV0dHQwceJErFu3TuwoRFpnwYIFsLa2hoeHh9hRSEtxlzciNVlbW2PWrFlixyDSGj4+Pli1apXYMYi0wqNHj2BoaCh2DCKtYWxsDH19fbFjEGmlRYsW4cqVK2LHIC3GhhKRmurWrYv69euLHYNIa2zfvh3p6elixyDSCm3btsXNmzfFjkGkNXr37o1jx45x7UqiN2BhYYGsrCyxY5AWY0OJSE3du3fHmTNnxI5BpDWaNm2KlJQUsWMQaYWZM2fiwIED3I2KSEVLly5FRkYGJkyYgMzMTLHjEGkVd3d3hISEIDs7W+wopKW4hhKRmq5fv47OnTtj2rRpmDVrFnR1uVkiUUVWrFiBpUuXIiYmRrmTFRGVLTg4GLt27cKRI0cwaNAgdOzYESYmJmUubM9dEYkAV1dXZGRk4OrVq9DT04O1tXWZ94wgCAgLCxMpJZE05efnY+jQoUhJScGCBQvQsWNHGBsbix2LtAgbSkRq8vHxwa1bt3Dy5Ek0atQIdnZ25Q5c/P39RUpJJB1JSUmYPHkyrly5ghkzZlT4BdnCwkKEhETSIZPJIAhCqdd3Xr1fFAoFBEGAXC7XdDwiyZHJVHvhgvcMUWk6OjoA/v9zpTyCIKCwsFBTsUiLsKFEpCYOXIjU8+oXZA5WiCq2efNmlWu9vLwqMQkREb3rXFxcKhybvYqvYlNZ2FAiUtOdO3dUrrW0tKzEJETawdvbW+XBSmBgYCWnISIiIiKit4ENJSIiIiIieickJCQgOzsbRkZGsLGxETsOEdE7jasJE/2PCgsL8eTJExgYGHCBbiIieisuXLiAzZs34+LFi8ovx+3bt4enpyfat28vdjwiScnOzsbcuXMRHByMnJwc5XlDQ0N4eXlh/vz5MDIyEjEhkfRdvHixxDOnXbt2aNeundixSOI4Q4noDcjlcqxevRpBQUG4du2acm2Y1q1bY+zYsZg8eTKbS0T/kp+fj0OHDpUarAwYMADVq1cXOx6RZEyfPh2rVq1CUVFRqWsymQzTpk3D8uXLRUhGJD3p6eno3r07bt26hTp16sDe3h4mJiZIS0tDTEwMsrKy0KxZM0RGRnL3KqIynDt3DuPHj8eVK1cAlFygu02bNti0aRM6dOggZkSSMDaUiNT09OlT9O3bF6dPn4ZMJkOTJk2UA5e7d++iqKgIXbp0wZEjR1CrVi2x4xJJwv79+zFhwgQ8fPiwxO5VgiDA2NgYv/76Kz788EMRExJJw9q1a/Hll1+iRYsWmD17Nrp37658xkRERGDRokW4desW1qxZg88//1zsuESiGzduHAIDA/Htt9/i+++/LzH2ys3NxaJFi7Bs2TL4+Phg06ZNIiYlkp4LFy7AyckJz549Q8+ePUs9c/755x/UqlULkZGRsLe3FzsuSRAbSkRqmjZtGn766SeMGjUKixcvLrHNeXJyMr777jvs2LEDU6dOxYoVK0RMSiQNYWFh6NevH3R0dODh4VFqsLJ161bI5XIcOXIErq6uYsclEpWtrS1yc3Nx9epVGBgYlLqenZ2NNm3aoHbt2oiNjRUhIZG0GBsbo23btggNDS23xtXVFVevXkV6eroGkxFJX9++fXHs2DEcPHgQvXv3LnX9yJEj+PDDD+Hq6oqQkBAREpLUsaFEpCZzc3OYmpri7Nmz5dZ07NgRKSkpuHfvngaTEUlTt27dcPnyZZw8eRLvv/9+qeuXL1+Go6Mj7O3tERkZKUJCIumoUaMGPvvsM6xcubLcmqlTp2LDhg14/vy5BpMRSVOtWrUwdepULFq0qNya77//Hj///DOePn2qwWRE0mdgYICPPvoIW7duLbdm1KhROHjwYIn1yYiKycQOQKRtMjIy0KtXrwprevXqhczMTA0lIpK2ixcvYsSIEWU2kwCgbdu2GD58OC5cuKDhZETSo+oaLyYmJpWchEg7vP/++0hKSqqwJikpqdxnEFFVpqurC0tLywprrK2toaOjo6FEpG3YUCJSU7NmzV47Zfrhw4d47733NJSISNpq1qyJhg0bVlhjbGyMmjVraigRkXSNHDkSv//+e7kzKXJycvD7779j5MiRGk5GJE2zZs3Cnj17yn3l7ejRo9izZw++//57DScjkr6uXbvizJkzFdacPn0a3bp101Ai0jZ85Y1ITf7+/pgyZQpOnz6N1q1bl7p+5coVdOnSBatXr4aPj48ICYmkZeTIkYiPj3/ta6LNmjXD9u3bNZiMSHry8/MxfPhw3Lp1C3PnzkW3bt2Ua45FRkZi4cKFaN68OXbt2gU9PT2x4xKJLjg4GHv27MFff/2F3r17l7pnQkNDMXDgQAwdOrTUZz09PUVITCQdsbGxcHR0xKRJkzBr1qwSP+49e/YMixYtwoYNGxAVFYVWrVqJmJSkig0lIjVFRERgxYoVOHr0KLy8vEoNXIKDg9G3b19Mmzat1GednJxESEwkrvv378PR0RFOTk744Ycf0KRJE+W1u3fvYtasWThx4gSioqJgamoqYlIi8RW/VvDqts2vKu+8IAgoLCys9HxEUiOTySAIAl73lebV+6b4PpLL5ZUdj0jSfHx8EB8fjxMnTqBOnTpo166d8nvNxYsXkZWVhe7du8PGxqbE5wRBgL+/v0ipSUrYUCJS078HLv8eoPz73Ks4cKGqyNXVFY8fP8bly5eho6MDCwsL5WAlOTkZcrkcbdu2Rd26dUt8ThAEhIWFiZSaSBwuLi7lPkNeJzw8/C2nIZK+oKCgN75nvLy83nIaIu0ik73ZCjhsyFIxNpSI1OTr6/vGA5d58+a95TRE0sfBChEREZH03Llz540/+7rFvKlqYEOJiIiISCKCg4NhYmKCvn37ih2FSCu4urrC0dERCxcuFDsKEVGVw13eiNTk4+ODVatWiR2DSGskJycjNTVV7BhEWmHcuHEICQkROwaR1jhz5gxnsxK9IR0dHYwePVrsGKTF2FAiUtP27duRnp4udgwirWFtbY1Zs2aJHYNIKzRu3JiLaxOpoWXLlv/TaztEVZmhoWGJzVKI1MWGEpGamjZtipSUFLFjEGmNunXron79+mLHINIKbm5u+Pvvv5Gfny92FCKt8MUXX2Dfvn2IjY0VOwqR1nFwcMClS5fEjkFajGsoEalpxYoVWLp0KWJiYmBmZiZ2HCLJGzx4MDIyMhARESF2FCLJy87OhqurKxo1aoTly5ejdevWYkcikrSIiAgsX74cERERmDhxIjp27AgTE5MyN1BxcnISISGRdJ06dQouLi7YuHEjPD09xY5DWogNJSI1JSUlYfLkybhy5QpmzJhR4cDFwsJChIRE0nL9+nV07twZ06ZNw6xZs6Crqyt2JCLJsrGxQX5+vnLdMX19fRgbG5d6xgiCgPj4eDEiEkmKTCaDIAgo/kpT0U68XGuJqKQFCxYgKioKoaGhaN++fbnfawRBwJw5c0RKSVLGhhKRml4duFQ0aBEEgetgEOHlQva3bt3CyZMn0ahRI9jZ2ZU7WPH39xcpJZE0WFlZVfhseVViYmIlpyGSPl9fX5XvmXnz5lVyGiLtIpOptgKOIAhsyFKZ2FAiUpO3t7fKA5fAwMBKTkMkfRysEBEREUnP8ePHVa51dnauxCSkrdhQIiKiSqXO7juWlpaVmISIiIiIiN4WNpSIiIiIJCg2NhbXr19Hbm4uPDw8xI5DJGkXL17Ejh07cP36dTx79gyhoaEAXv6ocebMGfTq1Qv16tUTOSUR0btFtfcQiKiU1NRUrFu3Dl9++SXGjRunPP/w4UOcPXsWz58/FzEdkXRlZmbi7t27Yscgkqxz587B3t4ebdq0wccffwxvb2/ltYiICNSsWRP79+8XLyCRxMyYMQMdOnSAn58fDh48iPDwcOU1hUKBUaNGYcuWLSImJJKuwsJCrFq1Cg4ODjA0NCyxeUpMTAw+//xz3Lx5U8SEJGVsKBG9gXXr1sHa2hqTJ0/G2rVrERQUpLyWnp6OLl26YOvWreIFJJKY7OxsfPXVVzAxMUHDhg1hbW2tvHbmzBkMGDAA0dHRIiYkkoZr167B1dUViYmJmDp1Kvr371/ievfu3dGgQQPs3r1bpIRE0hIYGAg/Pz8MHDgQly9fxnfffVfiupWVFRwcHNiEJSrD8+fP0aNHD3zzzTe4c+cODA0N8eoLTNbW1ggMDERwcLCIKUnK2FAiUtOBAwcwefJktGnTBvv378dnn31W4nrr1q3Rtm1b7N27V5yARBKTmZmJTp06Yc2aNWjSpAlatWpVYrDStm1bREVFYdu2bSKmJJKG4l2ooqOj4efnh44dO5a4LggCunTpgnPnzokRj0hy1q1bh1atWuH333/H+++/Dz09vVI1LVu2xK1bt0RIRyRtixcvRlRUFJYsWYLU1FR88sknJa4bGRnB2dkZR44cESkhSR0bSkRq+vHHH2FhYYHw8HAMHDgQxsbGpWratGmD2NhYEdIRSY+vry9u3ryJnTt34vz58/j4449LXK9RowacnZ3xzz//iJSQSDqOHz+OoUOH4r333iu3xsLCAikpKRpMRSRdsbGx6N27d4nXdP7NxMQE6enpGkxFpB1+++039OjRAzNmzIAgCGXuZG1jY4Pk5GQR0pE2YEOJSE0xMTH4z3/+g1q1apVbY2ZmhrS0NA2mIpKu/fv3Y+DAgRg+fHi5NVZWVrh3754GUxFJ05MnT8r8oeJVz58/h1wu11AiImnT1dXFixcvKqx58OABateuraFERNojOTkZHTp0qLDGwMAA2dnZGkpE2oYNJSI1FRUVoVq1ahXWpKeno3r16hpKRCRtKSkpsLW1rbCmevXqyM3N1VAiIulq0qQJrly5UmHNhQsX0LRpUw0lIpK2Nm3a4J9//im3yVq849sHH3yg4WRE0mdgYPDa2Xvx8fFo2LChhhKRtmFDiUhNLVq0QGRkZLnXCwsLERERgTZt2mgwFZF01a9f/7W7ul2/fh2NGzfWUCIi6Ro4cCCOHj2q3PL833bt2oXTp09j0KBBmg1GJFE+Pj64efMmPv30U+Tn55e4lpOTA29vb6SmpmL8+PEiJSSSrs6dO+PAgQPIysoq8/rdu3dx6NAhODk5aTYYaQ02lIjUNHr0aFy8eBHz588vdU0ul+Obb75BQkICPD09RUhHJD1OTk7Yt29fua+0xcbGIiQkBL169dJwMiLpmTVrFkxNTTFgwACMHz8e58+fB/By4WEPDw+MGjUKVlZWmDZtmshJiaTBx8cH7u7u8Pf3R8OGDeHv7w8AcHBwgJmZGfbs2QMvLy8MGzZM5KRE0jN9+nQ8fvwYPXv2RFRUFAoLCwG8nNkXFhaGvn37orCwkM8cKpegeHWrHSJ6rYKCAvTp0wcRERFo2rQp9PX1ce3aNQwdOhTnz59HUlIS+vTpg8OHD5e5sB1RVXPlyhU4ODjA2NgYixcvxunTp7Fu3TpcvXoVJ0+exPfff4+nT5/i4sWLaNasmdhxiUSXkJAADw8PnDp1qtS1Tp06YceOHbCystJ8MCIJ27hxI9auXYurV68qdxJt1aoVvvzyS0ycOFHkdETStX79enz11Vdlvjaqo6ODdevWldr9jagYG0pEb+DFixeYP38+NmzYgMePHyvPGxoa4rPPPsP8+fPL3LaWqKrav38/PDw88PTpUwCAQqGAIAhQKBQwMDDAjh07MGDAAJFTEklLTEwMTp8+jczMTBgaGqJTp07o2LGj2LGIJO358+d4/PgxDA0NuRA3kYri4uKwYcMGnDlzpsQz5/PPP0fr1q3FjkcSxoYS0f9AoVDgxo0byj+8rVq1go6OjtixiCQpMzMTmzdvLjVYGTt2LBo0aCB2PCIiIiIiUgMbSkREREREREREpBZdsQMQERER0Us+Pj6vrZHJZDA0NESLFi0wcOBAmJmZaSAZkTTJZLLXrlkpCILynhk8eDC++OIL1KhRQ0MJiaQrIiLitTXFz5z33nsPNWvW1EAq0iacoUSkJhsbm9fWvDrYHzx4MIYPH66BZETSFBwc/NqaV++ZFi1aaCAVkTS9+uW4rCFa8dpjxXR1dTF37lzMnj1bYxmJpMTFxQXZ2dm4dOkSdHR0YGFhARMTE6SlpSE5ORlyuRx2dnaQy+WIj49HXl4e3n//fURGRsLQ0FDs+ESiUqUh+2pt79698eOPP3JdJVJiQ4lITVZWVigsLMSDBw8AvBzMN2jQAI8ePVJutWlqaoqcnBw8ffoUgiCgZ8+eOHjwIBfqpipJncEKALRs2RJr1qyBq6trJaYikqbExERMmTIFZ8+exVdffQVHR0fll+OoqCisXr0aDg4O+P7773Hp0iUsWrQId+/exfbt2zFixAix4xNp3L1799CtWze4uLhg0aJFMDc3V167f/8+Zs+ejWPHjuHEiRMwMjLCN998g19//RUzZszA0qVLRUxOJD5fX1+cPXsWISEhaNGiBbp27ap85pw6dQrXr19H//790bRpU1y4cAEnT56EkZERzpw5g+bNm4sdnySADSUiNWVlZaF3794wMjLCokWL0KlTJ+UvxmfOnMGcOXOQnZ2No0eP4tGjR5g6dSoOHTqERYsW4bvvvhM7PpHGbd68GX/88QcOHDiAPn36lPqCfPToUbi5ucHJyQkXLlzAb7/9Bh0dHURGRnJHK6pyli5dip9++gmXLl2CiYlJqeupqamwt7fHtGnTMGPGDNy/fx+2trawt7fH8ePHRUhMJC53d3ckJyfj5MmT5dY4OjrCwsICO3bsQFFREdq2bYuCggLcuHFDg0mJpCcyMhK9e/fGhg0b4O3tXer65s2b8dlnn+Ho0aPo1q0btm7dCk9PT4wZM0alGej07mNDiUhNEydOxKlTpxATEwOZTFbqulwuR7t27dC1a1ds2LABeXl5sLW1hYGBAS5duiRCYiJx7d27FyNHjsShQ4fQo0ePUtePHTuGAQMGYOfOnXBzc8Px48fRs2dPfPTRR/j9999FSEwknmbNmqF///5YvXp1uTVffPEFQkJCcOvWLQDA6NGj8ddffyErK0tDKYmko0GDBpg4cSJ++OGHcmtmzZqFjRs34uHDhwCAzz77DEFBQXj+/LmmYhJJkouLCxo2bIjdu3eXW/Pxxx/j4cOHOHbsGADA1dUVN2/exL179zSUkqSs9LdhIqrQvn37MGDAgDKbSQCgo6ODAQMGYN++fQAAfX19uLq64vbt25qMSSQZixcvxvDhw8tsJgEvBzMff/wxFi1aBABwdnZGv379cOLECU3GJJKEe/fuoXr16hXW6OvrlxjIW1hYIC8vr7KjEUlSXl4eUlJSKqxJSUkp0TwyMDCAri73JiKKjo5+7dqVLVq0QHR0tPLY3t5e2ZwlYkOJSE05OTnIycmpsCY7OxvZ2dnK4wYNGlR2LCLJunbtWok1Lcpibm6Oa9euKY9tbW0524KqJDMzM+zdu7fcBlFeXh727t1bYme39PR01K1bV1MRiSSlffv22LlzJ06dOlXm9TNnzuC3337DBx98oDyXkJBQ5iulRFWNnp4eYmJiKqy5ePEiqlWrpjyWy+WoVatWJScjbcGGEpGabG1tsWPHDiQkJJR5PSEhATt37oStra3yXHJyMho2bKipiESSUrt2bURGRlZYExkZidq1ayuPc3NzYWBgUNnRiCRn3LhxiI+PR7du3bB//35kZGQAADIyMrB//35069YNCQkJ8PHxUX4mMjISdnZ2YkUmEtXChQtRWFiI7t27Y8iQIVixYgW2bNmCFStWYMiQIejWrRvkcjkWLFgAAHj69CmOHDkCZ2dnkZMTia9Xr144fPgwli1bhoKCghLXCgoK8OOPPyIkJAR9+vRRno+NjYWFhYWmo5JEcQ0lIjX98ccfGDZsGGrXro1PPvkEjo6OMDY2Rnp6OqKiouDv74+nT59i9+7dGDJkCF68eAFTU1P06dMH27dvFzs+kcZNmDAB/v7+mDhxIubPn1+iufro0SPMmzcPGzZswLhx4/Drr78CeLmAamFhIc6cOSNWbCJRyOVyjB07Flu3blXujiiTyVBUVAQAUCgUGDVqFIKDgyGTyZCWloalS5eiX79+6Nu3r5jRiURz9OhRTJgwAcnJyQCg3CwFePlK6IYNG9CvXz8AwLNnz3Dr1i2YmZlxBjlVeXfu3EGXLl2QlpYGY2NjdOjQQfm9Jjo6Wnn+9OnTsLS0RGpqKt5//3189tlnWLhwodjxSQLYUCJ6AwEBAZgyZQqePn1aYjt0hUKB2rVrY+XKlfjkk08AvNwV7vjx42jdujXee+89sSITiSYjIwNOTk6Ii4tD9erV8d577ykHK7dv30Z+fj5atmyJyMhI1K9fH6mpqRgwYAC8vb3x5Zdfih2fSBT//PMPtmzZgsuXLyMnJweGhoaws7PD6NGj0bNnT7HjEUlOUVERTpw4gUuXLpW4Z7p161buupdEBDx48AAzZ87Enj17kJ+frzxfvXp1DBs2DEuWLHnt0gVUdbGhRPSGsrOzsW/fvlIDl48++ghGRkZixyOSlNzcXCxduhTbtm1DUlKS8ryVlRVGjx6NmTNnlnjljYiIiIg058WLF7hx44bye02LFi2gp6cndiySODaUiIhIo548eaIcrHCdJCIiIiIi7cSGEhEREZHEpKamIjo6GllZWZDL5WXWeHp6ajgVkTQ9fPgQgYGBOHfuXLn3jCAICAsLEyEdEdG7iw0lojfw4sUL7N2797UDF39/fxHSEUlXbm5uhV+QuWsIVXV5eXkYP348du7cqVyI+98UCgUEQSj3PiKqSi5fvgxXV1c8fvwYFX2t4T1DVLbQ0FCsXLlS+b2mrGePIAgoLCwUIR1Jna7YAYi0zZ07d9C7d2/Ex8e/duDChhLRS/7+/lixYgVu3LhRbg0HK0TAt99+i23btqF58+YYOXIkzM3NoavL4RpReb7++mtkZmZi9uzZGDduHMzNzaGjoyN2LCKt8Pvvv2PEiBEoKiqCpaUlWrZsyWcOqYUzlIjUNGTIEOzduxceHh7w8fGpcLBvaWmp4XRE0rN+/XpMmjQJurq6cHR0rPCeCQwM1HA6ImkxNTVFvXr1EB0djerVq4sdh0jyateujT59+uCPP/4QOwqR1rGzs0NCQgL27dsHV1dXseOQFmL7kUhN//zzD3r27InNmzeLHYVIK/z0009o0KABTpw4gebNm4sdh0jSsrKyMGrUKDaTiFSkp6eHpk2bih2DSCvduHEDHh4ebCbRG5OJHYBI2xQVFaFdu3ZixyDSGnfu3MHw4cPZTCJSQYsWLZCWliZ2DCKt4ezsjPPnz4sdg0gr1a9fHzVr1hQ7BmkxNpSI1NSpUyfExcWJHYNIazRu3JgLoRKpaPr06di3bx9u374tdhQireDn54erV6/Cz89P7ChEWmfYsGEIDQ3lGpb0xriGEpGaoqOj4eTkhM2bN2PYsGFixyGSPF9fXwQFBeHatWuoVauW2HGIJC0iIgJr1qxBWFgYpkyZgvbt28PQ0LDMWicnJw2nI5IeHx8fJCYmIiIiAtbW1rC3ty/znuFmKUSl5ebmok+fPmjUqBFWrVrF3XZJbWwoEalpwYIFOHv2LA4fPgxnZ+dyB/uCIGDOnDkiJCSSlsLCQowcORL379/H0qVL0b59e9SuXVvsWESSJJPJIAiCchdRQRDKreXMP6KX94wqBEHgPUP0LzY2NigoKMCDBw8AAHXq1IGRkVGpOkEQEB8fr+l4pAXYUCJSEwcuROop3r5ZoVBU+OVYEAROuaYqz9fXt8L75FXz5s2r5DRE0nfnzh2Va7n7LlFJVlZWKj9zEhMTKzkNaSM2lIjUdPz4cZVrnZ2dKzEJkXZwcXFRebASHh5eyWmIiIiIiOhtYEOJiIiIiIiIiIjUoit2ACIiIiIiIlVEREQAABwcHKCvr688VgUXsiciers4Q4noNZKTkwEAZmZm0NHRUR6rgjslEBFRRWxsbCAIAkJDQ2FtbQ0bGxuVPscFUqmqKl64Pi4uDs2bN1ceq4JrW1JVt2DBAgiCgEmTJqFevXpYsGCBSp/jZkNUHjaUiF7jTQcuXGCYqiofHx8IgoDFixfDxMQEPj4+Kn2OWzpTVVS8IOo///wDa2trLpBK9BrFC9d/8cUXqFevHheyJ1JDWd9rVMHNhqg8bCgRvYa3tzcEQcDSpUthYmKiPFZFYGBgJacjkh4OVoiIiIikp3hzoU6dOkFfX5+bDdH/jA0lIiJ6q4q3cDYzM4Ouri63dCZ6jdWrV6Nz585wcHAQOwqRVmjfvj0+/fRTTJgwQXkuPT0dqampaNu2rYjJiKQvJycH+vr60NPTEzsKvQNU+9mYqIobMmQIdu3aVeLcixcvkJOTI1IiIumytLREdnY2MjMzlceq/kdUFU2ZMgUhISElzv33v/9F+/btRUpEJG0xMTFITU0tcW79+vVo166dSImItEfdunWxbNmyEufOnDmD1atXi5SItBkbSkQq2Lt3L65fv17i3JIlS1C3bl2REhFJW7t27bBhw4YS544cOYJp06aJlIhIu6SmpuLSpUtixyAioneMQqHAv19SCgkJwdSpU0VKRNqMDSUiInrrynqb+vTp0/j5559FSENERERERG8bG0pERERERERERKQWNpSIiIiIiIiIiEgtumIHICIiIqrqcnNzkZ6erjx++vQpAODhw4dlvkIKAMbGxhrJRiRFJ06cwPLly0scA8CPP/5Y7j0zY8YMjWQjIqoq2FAiUtHVq1dL7PR29epVAMDu3bvLHbgMHz5cI9mIiEi7+fn5wc/Pr8Q5hUKBRo0alVkvCAIKCws1EY1IkkJDQxEaGlrq/MyZM8usFwSBDSWi/7N161acPn1aeXz79m0AwIABA8qsFwQBf/31l0aykXYRFOV9EyYiJZlMBkEQSpwrvnX+fb74miAIkMvlGslHJDUymQwNGjRAgwYNlOcePXqEjIwMtGjRoszPCIKAa9euaSoikWS4uLiU+Sx5nfDw8EpIQyR9mzdvfqPPeXl5veUkRNpHJlN/1Rt+r6HysKFEpIL58+e/0efmzZv3lpMQaYc3GawAQFFR0VtOQkRERETF7ty580afs7S0fMtJ6F3AhhIREREREWklHx8ftGnTBlOnThU7ChFRlcNd3oiIiIiISCtt3769xIL2RESkOVyUm0hNT548wcOHD9GkSRNUq1ZNef63337D/v37oa+vj0mTJqF9+/YipiSSDh8fHwwaNAhubm7l1hw8eBB//PEHAgICNJiMSJoePnyIwMBAnDt3DllZWWWuWyEIAsLCwkRIRyQtTZs2RUpKitgxiLRaamoqoqOjy33mAICnp6eGU5E24CtvRGr67LPPsHXrVqSlpaFmzZoAgPXr12Py5MnKhbpr1KiB6OhotGzZUsyoRJIgk8ng6+uLuXPnllvzww8/YO7cuVzwkaq8y5cvw9XVFY8fPy53B1GAC6QSFVuxYgWWLl2KmJgYmJmZiR2HSKvk5eVh/Pjx2LlzZ7nrWHKzIaoIZygRqen48ePo1auXspkEAEuXLoWZmRm2b9+O1NRUeHp64scff4S/v7+ISYm0R15eHnR1+Ugi+vrrr5GZmYnZs2dj3LhxMDc3h46OjtixiCRr6NChCA8PR9euXTFjxgx07NgRJiYmZe6caGFhIUJCIun69ttvsW3bNjRv3hwjR46Eubk5x2OkFv5rIVJTSkoK+vXrpzyOi4vD3bt3sXz5cnTr1g0AsGfPHkRERIgVkUhyytsSXaFQ4O7duzh8+DBMTU01nIpIek6dOoVBgwZhwYIFYkch0go2NjYQBAEKhQJffvlluXWCIKCwsFCDyYikb9euXbC1tUV0dDSqV68udhzSQmwoEakpPz8fenp6yuPjx49DEAT06dNHec7Gxgb79+8XIx6RJMhkshJNJF9fX/j6+pZbr1AoMHPmTA0kI5I2PT09NG3aVOwYRFrD09Oz3B8tiKhiWVlZGDVqFJtJ9MbYUCJSk7m5OS5fvqw8PnjwIOrVq4e2bdsqz2VkZKB27dpixCOSBCcnJ+UAPyIiAhYWFrCysipVp6Ojg3r16sHV1RXjx4/XcEoi6XF2dsb58+fFjkGkNYKCgsSOQKS1WrRogbS0NLFjkBZjQ4lITf3798cvv/yCb775Bvr6+ggJCSm168HNmzf5nj5VaceOHVP+v0wmw9ixYytclJuIXvLz80Pnzp3h5+eHb775Ruw4RET0Dps+fTo+/fRT3L59G++9957YcUgLcZc3IjWlpqaia9euSEpKAgA0btwYZ86cgbm5OQAgPT0d5ubmmDx5MlauXCliUiIi0jY+Pj5ITExEREQErK2tYW9vD0NDw1J1giBw4wciIvqfREREYM2aNQgLC8OUKVPQvn37Mp85wMvZ50T/xoYS0Rt4/vw5wsLCALz84/rqH97Y2Fj8/fff6Nu3L1q2bClWRCIi0kIymUylOm7hTFWVq6srBEHA5s2bYW5uDldXV5U+JwiCcuxGRC8Vr3lZ3BKoaD0yPnOoLGwoERHRW+Xj4wNBELB48WKYmJjAx8dHpc9xxgURcOfOHZVrLS0tKzEJkTQVfwGOi4tD8+bN2YQl+h/4+vqqvKj9vHnzKjkNaSM2lIjU1L9/f0yYMAFubm7Q0dEROw6R5HCwT0RERET07mNDiUhNxV+WjY2N4e3tjXHjxnERO6JXFM+wMDMzg66uLmdcEBERERG9g9hQIlJTQkICNm7ciODgYKSkpEAQBLi4uGD8+PEYMmQI9PT0xI5IpJXS0tJgYmIidgwiSdi2bRuCgoIQExODnJwcGBoaol27dvD29saoUaPEjkdERETEhhLRm5LL5Th48CA2bdqEkJAQFBUVoW7duvD09MQnn3wCW1tbsSMSiWb9+vX47LPPVK5PS0tDjx49EBsbW4mpiKRPLpdj+PDh2Lt3LxQKBfT19WFiYoK0tDTk5eVBEAQMGjQIu3fvVvl1UqKqIC8vD+fOncODBw+Qn59fZo2np6eGUxFJ3927d7Fo0SKEhobiwYMHePHiRakaQRBQWFgoQjqSOjaUiN6ClJQUBAQEIDAwEImJiQCALl26YPz48RgxYgT09fVFTkikWbq6uti2bRtGjBjx2tpHjx7B2dkZ169f5xpKVOWtWrUKX3/9Nbp164Zly5ahS5cuymunT5/GzJkzceLECaxcuRJfffWViEmJpOOXX37BnDlzkJ2dXeZ1hULBdfqIypCQkIBOnTrh8ePHaN26Na5cuQJLS0vo6+sjISEBBQUFsLOzQ506dRAeHi52XJIg/rRF9BY0btwYM2fOxJIlS9C4cWMoFAqcPHkSPj4+MDc3x48//oiioiKxYxJpTKNGjeDl5YWjR49WWPfo0SO4uroiLi4On3/+uYbSEUnX5s2b0bx5c4SFhZVoJgFA586dERoaiubNmyMwMFCkhETS8scff+CLL75AkyZN4OfnB4VCgY8++giLFy9Gv379oFAoMHToUAQEBIgdlUhy5s+fj+zsbISFheHSpUsAgLFjxyIuLg5JSUlwc3NDbm4u9uzZI3JSkio2lIj+Rzdv3sSMGTNgbm4Od3d3ZGZmwsPDA6GhoVi2bBlq166Nb7/9FjNnzhQ7KpHGHD16FLVr18bQoUNx+vTpMmsyMjLQq1cvXL16FZ9++inWrFmj4ZRE0nPz5k24ubmhWrVqZV6vVq0aPvzwQ9y8eVPDyYik6aeffoKxsTFOnTqFqVOnAgDs7e0xc+ZM/PXXX9i6dSv27t3LTR+IyhAaGooBAwbA2dlZea74BabGjRvjt99+AwDMmjVLlHwkfWwoEb2BvLw8bNmyBc7OzmjVqhX8/PxQr149rFixAvfv38fmzZvh6uqKb775Bjdu3ICjoyOCg4PFjk2kMba2tjh06BAAYODAgbh27VqJ648fP0bv3r1x+fJljB8/HuvWrRMjJpHk6OnpITc3t8Ka3NxcbgBB9H8uX74MNzc31KxZU3nu1VfbRo0aBVdXVyxYsECMeESS9ujRI7Rs2VJ5rKuri2fPnimPq1evjt69e+PgwYNixCMtwIYSkZomT54MU1NTeHt748yZMxgxYgTCw8MRGxuLKVOmoG7duiXqq1evjr59++LRo0ciJSYSh4ODA/bu3Yvc3Fz07dsXSUlJAICsrCz07t0bMTEx8PHxwX//+19xgxJJSLt27bBr1y48ePCgzOspKSnYtWsX2rdvr+FkRNJUUFCAhg0bKo9r1KiBrKysEjV2dna4cOGChpMRSV+DBg1K/IjRoEED5XitmK6ubql7iqgYG0pEalq3bh3q16+PpUuX4t69e9i+fXuJaaJlcXFxwdy5czWUkEg6evbsiW3btiEtLQ29e/fG9evX0bt3b1y4cAFeXl7YtGmT2BGJJGXatGnIyMhAhw4dsGLFCpw/fx53797F+fPn4efnhw8++ACZmZmYNm2a2FGJJMHU1BQpKSnKY0tLS1y8eLFEzZ07d6Crq6vpaESS16xZM8THxyuPHRwccOTIESQkJAAAHj58iD179qBp06ZiRSSJ4y5vRGoKCwtDz549xY5BpFX8/f0xfvx46OjoQC6XY/To0QgODoYgCGJHI5KclStX4ttvvy21I5VCoYCuri6WLVumXCuGqKobNWoUYmNjERMTA+BlU/bnn3/GokWL4ObmhhMnTmDy5Mno1asXDh8+LG5YIolZtmwZfH19kZKSgjp16uDYsWPo2bMnatSogVatWuH27dvIycnBhg0bMH78eLHjkgSxoURERG9denp6qXN+fn7w8/NDnz59EBgYCB0dnVI1xsbGmohHJHkJCQnYtm0bYmJikJOTA0NDQ7Rr1w6jRo2CjY2N2PGIJOPPP//ErFmzcPjwYVhZWeHhw4fo0KED7t27B+BlI9bIyAgRERFo06aNyGmJpCUnJwdxcXGwtbWFgYEBAGD37t3w9fVFQkICLC0t8cUXX2DSpEkiJyWpYkOJ6A0UFhZizZo12LFjB65fv45nz56hsLAQABATE4Nff/0VU6ZMQfPmzUVOSiQOmUxW5uwjhUJR7qwkQRCU9xEREdGbevz4MTZt2qT8Quzh4QEzMzOxYxERvXPYUCJS0/Pnz9GnTx+cPHkSDRo0QLVq1ZCSkqJ8NSE7OxuNGjXC119/jUWLFomclkgcLi4ub/Q6W3h4eCWkISKid1FERATOnTsHQRDg4OCAbt26iR2JiKhKYUOJSE1z5szBDz/8gKVLl2L69OmYP38+Fi5cWGKti379+iEjIwPnzp0TMSkREUldRETEG3/WycnpLSYh0h6FhYUYOnRoqa3MBw0ahN27d0Mm475DRKpITk5+bY1MJoOhoSEMDQ01kIi0Dbc7IFLTb7/9hh49emDGjBkAUOYsDBsbm1I7jBAREf3bm87mA1Bq0W6iqmLt2rU4cOAAjI2NMWTIEAAv11Lau3cv1q1bh8mTJ4uckEg7WFlZqfwMMjY2xuDBgzFv3jyYmJhUcjLSFmwoEakpOTkZgwcPrrDGwMAA2dnZGkpEpB2SkpLw6NEjAEDDhg1haWkpciIi8c2dO5e7HRKpafv27ahTpw5iYmLQqFEjAC/vJVtbW2zdupUNJSIVeXp6IikpCREREahbty7s7e1hYmKCtLQ0XLp0CZmZmXB2doaBgQGuXLmCDRs24MCBAzh79iwaN24sdnySADaUiNRkYGBQ5g5Wr4qPj0fDhg01lIhIulJTU7Fo0SLs2rULGRkZJa41bNgQ7u7u+O677/hLF1VZvr6+Ykcg0jo3btzAxx9/rGwmAUCjRo0wePBg7NmzR8RkRNpl+vTp6NatG+bOnYsZM2agZs2aymvPnz/H8uXL8fPPP+PEiRNo2bIllixZgjlz5mDRokX45ZdfRExOUsEXjInU1LlzZxw4cABZWVllXr979y4OHTrEtS2oyrty5Qrat2+P9evX49GjRzA3N4eDgwMcHBxgbm6O9PR0rF69Gh06dEBcXJzYcYmISEs8efIETZo0KXW+SZMmePr0qQiJiLTTjBkz0KlTJ/j6+pZoJgFAjRo1MG/ePHTq1AkzZ86ETCbD999/j44dO+LQoUMiJSapYUOJSE3Tp0/H48eP0bNnT0RFRSm3OX/27BnCwsLQt29fFBYWYtq0aSInJRJPQUEB3N3dkZqaCi8vL8THx+POnTs4deoUTp06hTt37iA+Ph5eXl64f/8+3N3duR4MERGprKxXRfn6KJF6oqKi0KFDhwpr2rdvj8jISOVxp06dkJKSUtnRSEvwlTciNTk5OWHt2rX46quvSsxCMjAwAADo6Ohg3bp1+OCDD8SKSCS6/fv3Iy4uDtOmTYOfn1+ZNdbW1ggMDES9evXw008/Yf/+/a9dn4yoKnjy5AnWrl2L0NBQPHjwAPn5+aVqBEFAfHy8COmIpOHevXs4e/ZsqXMAcO7cOZS1kbWDg4NGshFpi6KiIty+fbvCmtu3b5e4n6pVqwZ9ff3KjkZaQlCU9deWiF4rLi4OGzZswJkzZ5CZmQlDQ0N06tQJn3/+OVq3bo20tDSuC0NV1pgxY3Dw4EHcv38ftWrVqrA2NzcXpqam+OijjxAcHKyhhETS9PDhQ3Tt2hXx8fEwNDRETk4OjIyM8OLFCzx//hwAYGpqimrVqiExMVHktETikMlk5c5GUigU5V7jTFiikgYMGIC///4bW7duxYgRI0pd3717N0aNGoXevXsrX3P78MMPER8fj9jYWE3HJQliQ4lIBevXr8dnn32mcn1aWhp69OjBP7RUZbVu3RpNmzbF/v37Vap3c3NDYmIirly5UsnJiKRt0qRJWL9+PYKDgzF69Gjo6OjA19cXc+fOxblz5/DFF19AV1cXR48eLbXeBVFVMXbs2Df6XGBg4FtOQqTdrly5AkdHR+Tm5sLOzg6Ojo4wNjZGeno6Tp48iZiYGNSqVQsnTpxA27ZtkZGRATMzM3zyySdYu3at2PFJAvjKG5EKvvjiC9SrV6/Mzv2/PXr0CK6urrhx44YGkhFJU0pKCvr166dyfbNmzRAVFVWJiYi0w6FDh9CzZ0+MGTOm1LWOHTvi8OHDaNOmDebPn49ly5aJkJBIfGwMEb0dbdq0QWRkJCZPnoyoqCjExMSUuO7o6Ig1a9agbdu2AIA6deogLS2NP2iQEhtKRCpo1KgRvLy8ULduXfTp06fcuuJmUlxcHCZNmqTBhETS8uTJExgaGqpcb2BggCdPnlRiIiLtkJKSgo8//lh5rKOjo3zVDQDq1q2L/v37Y9euXWwoERHR/8zOzg6RkZFITk7GpUuXkJOTA0NDQ9jZ2cHCwqJErY6ODoyMjERKSlLEhhKRCo4ePQonJycMHToUf//9Nzp37lyqJiMjA7169cLVq1fx6aefYs2aNSIkJZIGuVyu1m47giBwbQsiAEZGRigoKFAe161bV7nQcDFDQ0OkpaVpOhoREb1jXF1d4ejoiIULF8LCwqJUA4noddhQIlKBra2t8jWEgQMH4vjx42jdurXy+uPHj9G7d29cvnwZ48ePx7p160RMSyQNZe3AU1EtEQE2NjZISkpSHrdr1w5///03MjIyUL9+fTx//hwHDhzgoJ/oFYmJifj5559x6dIlPHjwoERTthh3RiQq7cyZM2X+UE6kKi7KTaSGsLAwDBw4EPXr18eJEydgZWWFrKws9OrVCxcuXICPjw82bdokdkwi0VW0A09Zinfl4SwlqurmzZuHVatWITU1FTVr1sQff/yBYcOGwdTUFF26dMGFCxeQlJSEH374Ad9++63YcYlEFxISgkGDBuHFixeoVq0ajI2Noatb9m/m3BmRqKQPPvgALVu2xLZt28SOQlqKDSUiNf3xxx8YMWIErKyscODAAXh4eCA6OhpeXl5cJJLo/3AHHqI3k5KSgoiICPTs2RMNGjQAAKxYsQKLFi1CdnY2atSogc8//xxLly6Fjo6OyGmJxGdnZ4fbt28jKCgIQ4cOhUwmEzsSkdYICgrC5MmTcfbsWdja2oodh7QQG0pEb8Df3x/jx4+Hjo4O5HI5Ro8ejeDgYLVmZBAREalKLpfj0aNHMDY25rOG6BU1atTAmDFjsHHjRrGjEGmdiIgILF++HBEREZg4cSI6duwIExOTMp8zTk5OIiQkqWNDiUgF6enppc75+fnBz88Pffr0QWBgYJm/FBsbG2siHpHWS0xMxPz58xEUFCR2FCJRPX36FLVr1xY7BpHWsLa2xsCBA7kZCtEbKF6ioLglUNEPFlyWgMrChhKRCspbD6Z43ZeyCIKAwsLCyo5GpNWSk5OxcOFCBAcHo7CwkIMVqvJq1aqFQYMGwcPDA3369OHrO0Sv8f333+O3337D1atXoa+vL3YcIq3i6+ur8qzXefPmVXIa0kZsKBGpwMXF5Y1eMQgPD6+ENETa4cSJE5gzZw6io6Ohq6uL7t27Y/ny5WjRogWePXuG2bNnY926dXjx4gVMTU3x3XffYdKkSWLHJhJV27ZtcfXqVQiCgIYNG2LkyJEYM2YMPvjgA7GjEUlSQUEBBg8ejCdPnmDx4sWws7PjLD8iIg1hQ4mIiN666OhoODo64sWLFyXON27cGJGRkXBzc0NsbCxMTU0xc+ZMTJgwAdWrVxcpLZG0XL58GcHBwdixYwdSUlIgCAJatGgBDw8PjB49GhYWFmJHJJKUo0ePwt3dHdnZ2eXWcOY4EdHbx4YSERG9dSNGjMDu3buxZMkSjBs3DgCwceNGfP/992jcuDHS0tIwa9YszJo1i68oEJVDoVAgNDQUW7Zswd69e/H06VPIZDJ069YNHh4eynuLqCr77bffMHr0aBQVFcHGxgaNGzeGrq5umbWcOU5UttzcXOzduxcxMTHIycmBoaEh7O3tMWjQINSqVUvseCRhbCgRvQWFhYW4cuUKAOD9999HtWrVRE5EJC5zc3O0bNkSoaGhJc737NkTx44dw48//ohp06aJlI5I+zx//hx//vkntmzZgtDQUCgUCs62IALQunVrpKamIiQkBB07dhQ7DpHW+f333zFhwgRkZWXh1daAIAioU6cONm7ciCFDhoiYkKSMKz0SqSAxMREBAQG4efNmqWsHDx6EmZkZOnTogA4dOqBx48bYtWuXCCmJpCM9Pb3MNV+Kz3l5eWk6EpFWKywsRH5+PvLz81FUVAT+Hkj0UmJiItzd3dlMInoDJ0+ehLu7O3Jzc/HJJ59g+/btCA8Px44dOzB+/Hg8e/YM7u7uOHXqlNhRSaLKng9KRCVs3LgRy5YtQ0JCQonzt2/fxvDhw5GXlwdLS0vUqlULcXFxGD16NJo1a4Z27dqJlJhIXIWFhWVOkS4+V79+fU1HItI6crkchw4dwtatW3Hw4EHk5eVBJpOhT58+8PDwEDsekSQ0adKEO4QSvaHFixejevXqiIqKgp2dXYlrI0aMwOeff46uXbti8eLFOHDggEgpSco4Q4lIBSdOnIC9vT0sLS1LnP/555+Rl5eHSZMmITExEVevXsXvv/8OuVyOtWvXipSWiIi02enTpzF58mQ0btwYgwYNwu7du9GiRQv4+fnh3r17OHz4MEaNGiV2TCJJGD9+PA4cOIDMzEyxoxBpnVOnTmHEiBGlmknF2rZti+HDh+PkyZMaTkbagjOUiFSQmJiIgQMHljofEhICPT09LF68WHlu0KBB6N69OyIjIzUZkUhytm7ditOnT5c4d/v2bQDAgAEDStULgoC//vpLI9mIpKpZs2ZISEiAQqGAmZkZpk+fDg8PD7Ru3bpEXX5+PndGJAIwbNgwREVFwdHREbNnz4adnR0MDQ3LrOUOiUQlPXv2DCYmJhXWmJiY4NmzZxpKRNqGi3ITqUBfXx/Tp0/HwoULlecyMzPRoEEDdO/eHcePHy9RP2XKFGzcuBG5ubmajkokCTKZ+hNgBUHgawtU5RkYGGDYsGHw8PBAjx49IAhCiesXLlyAv78/du7ciYyMDJFSEkmHTCaDIAhQKBSl7pdXCYLAheyJ/qVVq1aoXbs2zp07V26Ng4MDnjx5gri4OA0mI23BGUpEKqhWrVqpgXt0dDQAoEOHDqXqub0mVXWJiYliRyDSSunp6ahRo0aJc1lZWdi6dSv8/f1x+fJlKBSKUjVEVZWnp2eFjSQiKt/w4cOxcOFCeHl5YcmSJTA1NVVeS0lJwXfffYfo6GjMmTNHxJQkZWwoEamgefPmCAsLK3Hu6NGjEAQBXbt2LVX/4MEDNG7cWFPxiCTn3+uNEZFqXm0UhYaGwt/fH/v27UN+fj4UCgW6dOmCsWPHYsSIESKmJJKOoKAgsSMQaa2ZM2ciJCQEW7ZswW+//Yb33nsPJiYmSEtLw+3bt/HixQs4ODhg5syZYkclieIrb0QqWLx4MWbPno0JEybg888/x82bNzFu3DgAL5tH/56R1Lx5c9jY2CAkJESMuEREpKXu3r2LwMBABAYGIjk5WbmW0v379+Ht7Y2AgACxIxIR0TskPz8fy5YtQ3BwcIkdrW1sbODl5YUZM2ZwzT4qFxtKRCp49uwZunTpgitXriinVSsUCqxcuRJTpkwpUXv+/Hk4ODjgxx9/xNdffy1CWiIi0iYFBQXYu3cv/P39ERYWBrlcjlq1amHw4MHw9PSEq6srdHV18cknn+DXX38VOy6RZEVFRSEmJgY5OTkwNDSEvb09HB0dxY5FpDWePHmivH8MDAzEjkNagK+8EamgZs2aiIqKwqpVq3D69GnUr18fH3/8MT788MNStRcuXMBHH30ENzc3EZISEZG2MTU1RWZmJgRBQI8ePeDp6YkhQ4ZwPT4iFZ08eRJjx45V7iT66gLdzZo1Q2BgILp06SJmRCKtYGBgwEYSqYUzlIiIiIhEJJPJIJPJMHXqVMyYMQMNGzYss4YzlIhKu3btGjp16oRnz56hd+/e6NGjBxo3bozU1FSEh4fj6NGjqF27Nk6fPg1bW1ux4xKJzsbGRu3PCIKA+Pj4SkhD2o4NJSIiIiIR+fj4YPfu3Xj27Bl0dXXRt29feHh44KOPPoKenh4ANpSIyjNixAj8+eef2L9/P/r161fqekhICNzc3DBkyBDs3LlThIRE0iKTyaCjowNdXfVeVnr+/HklJSJtJhM7AJE2yM3NRbNmzeDo6IiCgoJy6168eIFu3bqhZcuW/KNLREQqCQgIQEpKCv773/+iffv2OHjwINzd3WFiYoKJEyfixIkTYkckkqxjx45h2LBhZTaTAKBfv34YNmwYwsPDNZyMSNpcXFwQHByMnJwcPH/+/LX/EZWFDSUiFQQGBiIhIQFLlixBtWrVyq3T09PDkiVLcPPmTQQGBmowIRERabPatWvjk08+walTp3Dt2jVMmTIFenp62LhxI5ydnSEIAm7cuIE7d+6IHZVIUrKzs2FtbV1hjbW1NbKzszWUiEjaYmNj8dVXXyEmJgbu7u4wNTXF1KlTceXKFbGjkRbiK29EKujduzdSUlJw9epVlert7OzQoEEDhIWFVXIyIiJ6VxUWFip3f/v7779RVFQEmUwGZ2dneHt7w8PDQ+yIRKKzsbGBtbV1hWOuXr16ISEhocSW6ERVnVwux4EDBxAQEICQkBDI5XK0a9cO48aNw6hRo2BkZCR2RNICnKFEpIJLly7ByclJ5XpHR0d2+YmI6H+iq6uLYcOG4fDhw0hKSsL8+fNhaWmJ8PBweHt7ix2PSBLc3Nxw7NgxzJkzB3l5eSWu5eXlYd68eQgPD8dHH30kUkIiadLR0cGgQYOwf/9+3L17F4sXL0Zubi4mTZoEU1NTjBkzBsnJyWLHJInjDCUiFejp6WHmzJlYuHChSvWzZ8/Gjz/+iPz8/EpORkREVU1YWBgCAgKwbds2saMQiS4jIwOdOnVCYmIi6tevDwcHB5iYmCAtLQ3nzp3Dw4cPYWNjg7Nnz6JevXpixyWSvLCwMHh7e+PBgwf4888/4ebmJnYkkjD1lnYnqqIMDQ2RkZGhcn1mZiYMDAwqMREREVVVPXv2RM+ePcWOQSQJ9evXx+nTpzFjxgzs3LkThw4dUl7T19fH2LFjsWzZMjaTiF7j3LlzCAgIwM6dO5GdnQ0zMzOYm5uLHYskjjOUiFTQtWtX5OTkqLyG0vvvvw8jIyNERUVVcjIiIiIiAoCCggJcv34dOTk5MDQ0RMuWLSvcTIWoqnv06BG2bNmCwMBAXLt2Dbq6uvjwww8xbtw49O3bFzIZV8ihivFfCJEKBgwYgLi4OOzcufO1tbt27UJsbCz+85//aCAZERERUdWVnJyMnJwcAEC1atXQpk0bODo6ok2bNspm0pMnT7gWDNH/KSoqwsGDBzFkyBCYmZnh66+/BgCsWLEC9+/fx549e9C/f382k0glnKFEpIKsrCw0bdoU+fn5WLt2bbmLoW7evBmTJ0+Gvr4+bt26hTp16mg0JxEREVFVoqOjA19fX8yZM6fcmh9++AFz586FXC7XYDIiaTI1NUVaWhqMjIzg7u4OHx8fdOjQQexYpKW4hhKRCurUqYNdu3bBzc0N48aNg6+vL5ydnZXvFd+/fx/Hjh3D3bt3oa+vj127drGZRERERFTJFAoFXvf7OH8/J/r/UlNTUa1aNdjZ2SEpKQlz58597WcEQcBff/2lgXSkbdhQIlJRz549cfLkSXz55ZeIjIzEli1bStU4OTnh559/hp2dnQgJiYiIiOjf7t27x81SiF5RUFCA48ePq1wvCEIlpiFtxoYSkRrs7Oxw/PhxxMfHIyoqCqmpqQCARo0awdHREU2bNhU5IREREdG7bcGCBSWOjx07VmadXC7H3bt3sXPnTnTu3FkDyYikLzExUewI9A7hGkpERERERKQ1Xl0sWBCE177SZmpqij///BMdO3as7GhERFUKZygRqSgiIgLZ2dno169fuVvQvnjxAkeOHEGdOnXQvXt3DSckIiIieveFh4cDeLk2kqurK7y9veHl5VWqTkdHB/Xq1UPLli1RUFCg6ZhERO88zlAiUkFcXBzatm0LLy8vbNq0qcLaCRMmICgoCFeuXEGLFi00lJCIiIio6pk/fz569OgBJyenMq9fuHAB/v7+2LlzJzIyMjScjojo3caGEpEKpk2bhvXr1yMpKQkmJiYV1qalpcHa2hqffvopVq5cqaGERERERAQAWVlZ2Lp1K/z9/XH58mUoFArUqFEDubm5YkcjInqn8JU3IhX8888/cHFxeW0zCQBMTEzg4uKCsLAwDSQjIiIiIgAIDQ2Fv78/9u3bh/z8fCgUCnTp0gVjx47FiBEjxI5HRPTOYUOJSAUJCQno1auXyvW2traIjIysxEREREREdPfuXQQGBiIwMBDJyclQKBQwMzPD/fv34e3tjYCAALEjEhG9s9hQIlLBixcvoKenp3K9np4eCgsLKzERERERUdVUUFCAvXv3wt/fH2FhYZDL5ahVqxZGjx4NT09PuLq6QldXF7q6/KpDRFSZ+FeWSAUNGzZEQkKCyvWJiYlo0KBBJSYiIiIiqppMTU2RmZkJQRDQo0cPeHp6YsiQIahVq5bY0YiIqhQ2lIhU0LFjR/z99994+vQpateuXWHt06dPcfToUbi4uGgmHBEREVEVkpGRAZlMhqlTp2LGjBlo2LCh2JGIiKokmdgBiLTBmDFj8PjxY0yePPm1tV988QWysrIwZswYDSQjIiIiqlq8vb1Ro0YNrFy5Eubm5nBzc8Pu3bvx4sULsaMREVUpbCgRqWDIkCHo0aMHtmzZAldXV/zzzz8lBi0FBQUICwtDz549ERwcDFdXVwwePFjExERERETvpoCAAKSkpOC///0v2rdvj4MHD8Ld3R0mJiaYOHEiTpw4IXZEIqIqQVAoFAqxQxBpg8ePH2PQoEGIjIyEIAjQ1dVVrpOUkZGBgoICKBQKdO/eHfv27UOdOnXEDUxERERUBcTFxWHTpk3YunUrHj58CEEQAADdunVDcHAwLC0tRU5IRPRuYkOJSA1yuRzBwcHw9/fHuXPnUFBQAACoVq0aHBwcMG7cOHh4eEBHR0fkpERERERVS2FhoXL3t7///htFRUWQyWRwdnaGt7c3PDw8xI5IRPROYUOJ6A3J5XJkZGQAAOrXr88mEhEREZFE3Lt3D4GBgQgKCkJiYiIEQYBcLhc7FhHRO4UNJaK3rKCgQPnrWEhIiNhxiIiIiKq0sLAwBAQEYNu2bWJHISJ6p7ChRPSWXL16Ff7+/ti6dSsyMzMBgL+EERERERER0TtJV+wARNrsyZMn2L59OwICAnD+/HkAgL6+PkaOHImxY8eKnI6IiIiIiIiocrChRPQGIiIi4O/vj99//x3Pnz9H8US/fv36YefOnTA0NBQ5IREREREREVHlYUOJSEWpqakICgpCQEAA4uPjoVAoYGFhgTFjxsDDwwOtWrWCubk5m0lERERERET0zmNDiUgFH374IY4cOYLCwkIYGBgot551cXEROxoRERERERGRxrGhRKSCv/76CzKZDNOnT8eCBQtQvXp1sSMRERERERERiUYmdgAibWBjY4OioiL4+fmhU6dOWLlyJVJTU8WORURERERERCQKNpSIVHD79m38888/GDlyJG7evIlvvvkGTZo0Qf/+/bFjxw7k5eWJHZGIiIiIiIhIYwRF8fZURKSS7OxsbNu2Df7+/rh48SIEQUDt2rXx9OlTfPzxx9i5c6fYEYmIiIiIiIgqFRtKRP+DS5cuYePGjdi+fTuysrIgCAKsrKzg7e0NT09PWFpaih2RiIiIiIiI6K1jQ4noLcjPz8fvv/8Of39/HDt2DAqFAjo6OigoKBA7GhEREREREdFbx4YS0VuWlJQEf39/bN68GcnJyWLHISIiIiIiInrr2FAiqiQKhQKCIIgdg4iIiIiIiOit0xU7AJE2sLGxUfszgiAgPj6+EtIQERERERERiYszlIhUIJPJoKOjA11d9Xqwz58/r6REREREREREROLhDCUiNbi4uMDHxweDBg1CtWrVxI5DREREREREJAqZ2AGItEFsbCy++uorxMTEwN3dHaamppg6dSquXLkidjQiIiIiIiIijeMrb0RqkMvlOHDgAAICAhASEgK5XI527dph3LhxGDVqFIyMjMSOSERERERERFTp2FAiekNpaWkICgpCUFAQbty4gRo1amDw4MFYvHgxLCwsxI5HREREREREVGnYUCJ6C8LCwuDt7Y0HDx7gzz//hJubm9iRiIiIiIiIiCoNF+Um+h+cO3cOAQEB2LlzJ7Kzs2FmZgZzc3OxYxERERERERFVKjaUiNT06NEjbNmyBYGBgbh27Rp0dXXx4YcfYty4cejbty9kMq51T0RERERERO82vvJGpIKioiIcOnQIAQEB+Ouvv1BQUID3338fPj4+GDNmDBo0aCB2RCIiIiIiIiKNYUOJSAWmpqZIS0uDkZER3N3d4ePjgw4dOogdi4iIiIiIiEgUbCgRqUAmk6FatWro2rUratSoodJnBEHAX3/9VcnJiIiIiIiIiDSPDSUiFbzJukiCIEAul1dCGiIiIiIiIiJxcVFuIhUkJiaKHYGIiIiIiIhIMjhDiYiIiIiIiIiI1ML9zYmIiIiIiIiISC1sKBERERERERERkVrYUCIiIiIiIiIiIrWwoURERERERERERGphQ4mIiIiIiIiIiNTChhIREREREREREamFDSUiIiIiIiIiIlILG0pERERERERERKSW/wfjOQJj6mEm6QAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -660,17 +2676,17 @@ "id": "3ee14366", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:28:28.576983Z", - "iopub.status.busy": "2024-11-24T09:28:28.576761Z", - "iopub.status.idle": "2024-11-24T09:28:28.913143Z", - "shell.execute_reply": "2024-11-24T09:28:28.912512Z" + "iopub.execute_input": "2025-05-08T16:23:24.713891Z", + "iopub.status.busy": "2025-05-08T16:23:24.713590Z", + "iopub.status.idle": "2025-05-08T16:23:25.088793Z", + "shell.execute_reply": "2025-05-08T16:23:25.087682Z" }, "lines_to_next_cell": 2 }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -721,16 +2737,16 @@ "id": "20f7e139", "metadata": { "execution": { - "iopub.execute_input": "2024-11-24T09:28:28.915675Z", - "iopub.status.busy": "2024-11-24T09:28:28.915430Z", - "iopub.status.idle": "2024-11-24T09:28:29.314170Z", - "shell.execute_reply": "2024-11-24T09:28:29.313570Z" + "iopub.execute_input": "2025-05-08T16:23:25.091970Z", + "iopub.status.busy": "2025-05-08T16:23:25.091624Z", + "iopub.status.idle": "2025-05-08T16:23:25.443209Z", + "shell.execute_reply": "2025-05-08T16:23:25.441976Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -967,9 +2983,9 @@ "formats": "docs//notebooks//ipynb,docs//notebooks//scripts//py:percent" }, "kernelspec": { - "display_name": "aniEnv", + "display_name": ".venv", "language": "python", - "name": "anienv" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -981,7 +2997,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.12.6" } }, "nbformat": 4, diff --git a/docs/notebooks/10_pipeline_pandas_output.ipynb b/docs/notebooks/10_pipeline_pandas_output.ipynb index 40f5c6f..f9ae568 100644 --- a/docs/notebooks/10_pipeline_pandas_output.ipynb +++ b/docs/notebooks/10_pipeline_pandas_output.ipynb @@ -14,7 +14,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 14, "id": "cb457069", "metadata": { "execution": { @@ -43,7 +43,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 15, "id": "bc72ca09", "metadata": { "execution": { @@ -55,7 +55,7 @@ }, "outputs": [], "source": [ - "csv_file = Path(\"../tests/data/SLC6A4_active_excapedb_subset.csv\")\n", + "csv_file = Path(\"../../tests/data/SLC6A4_active_excapedb_subset.csv\")\n", "assert csv_file.is_file()\n", "data = pd.read_csv(csv_file)\n", "data.drop_duplicates(subset=\"Ambit_InchiKey\", inplace=True)" @@ -71,7 +71,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 16, "id": "6019d09f", "metadata": { "execution": { @@ -88,7 +88,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 17, "id": "fe9efa0e", "metadata": { "execution": { @@ -128,7 +128,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 18, "id": "33ce774b", "metadata": { "execution": { @@ -142,9 +142,10 @@ { "data": { "text/html": [ - "
Pipeline(steps=[('smilestomoltransformer', SmilesToMolTransformer()),\n",
+       "
Pipeline(steps=[('smilestomoltransformer', SmilesToMolTransformer()),\n",
        "                ('standardizer', Standardizer()),\n",
        "                ('moleculardescriptortransformer',\n",
        "                 MolecularDescriptorTransformer(desc_list=['MaxAbsEStateIndex',\n",
@@ -575,7 +586,7 @@
        "                                                           'BCUT2D_MRHI',\n",
        "                                                           'BCUT2D_MRLOW',\n",
        "                                                           'AvgIpc', 'BalabanJ',\n",
-       "                                                           'BertzCT', 'Chi0', ...]))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. 
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
"
       ],
       "text/plain": [
        "               feature  importance\n",
-       "0    MaxAbsEStateIndex    0.002776\n",
-       "1       MaxEStateIndex    0.003859\n",
-       "2    MinAbsEStateIndex    0.006311\n",
-       "3       MinEStateIndex    0.004721\n",
-       "4                  qed    0.007605\n",
+       "0    MaxAbsEStateIndex    0.003240\n",
+       "1       MaxEStateIndex    0.001821\n",
+       "2    MinAbsEStateIndex    0.002461\n",
+       "3       MinEStateIndex    0.004588\n",
+       "4                  qed    0.009382\n",
        "..                 ...         ...\n",
-       "205        fr_thiazole    0.000000\n",
-       "206        fr_thiocyan    0.000000\n",
-       "207       fr_thiophene    0.000046\n",
-       "208   fr_unbrch_alkane    0.000000\n",
-       "209            fr_urea    0.000000\n",
+       "212        fr_thiazole    0.000000\n",
+       "213        fr_thiocyan    0.000000\n",
+       "214       fr_thiophene    0.000835\n",
+       "215   fr_unbrch_alkane    0.000000\n",
+       "216            fr_urea    0.000000\n",
        "\n",
-       "[210 rows x 2 columns]"
+       "[217 rows x 2 columns]"
       ]
      },
-     "execution_count": 13,
+     "execution_count": 26,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -4358,7 +3246,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 27,
    "id": "713d24f1",
    "metadata": {
     "execution": {
@@ -4398,27 +3286,27 @@
        "    \n",
        "      0\n",
        "      PEOE_VSA6\n",
-       "      0.147449\n",
+       "      0.138689\n",
        "    \n",
        "    \n",
        "      1\n",
        "      VSA_EState5\n",
-       "      0.087963\n",
+       "      0.062832\n",
        "    \n",
        "    \n",
        "      2\n",
        "      MaxAbsPartialCharge\n",
-       "      0.057491\n",
+       "      0.052241\n",
        "    \n",
        "    \n",
        "      3\n",
        "      VSA_EState6\n",
-       "      0.034922\n",
+       "      0.048135\n",
        "    \n",
        "    \n",
        "      4\n",
        "      SlogP_VSA6\n",
-       "      0.028875\n",
+       "      0.027086\n",
        "    \n",
        "    \n",
        "      ...\n",
@@ -4426,53 +3314,53 @@
        "      ...\n",
        "    \n",
        "    \n",
-       "      205\n",
-       "      fr_hdrzine\n",
+       "      212\n",
+       "      fr_term_acetylene\n",
        "      0.000000\n",
        "    \n",
        "    \n",
-       "      206\n",
-       "      fr_hdrzone\n",
+       "      213\n",
+       "      fr_thiazole\n",
        "      0.000000\n",
        "    \n",
        "    \n",
-       "      207\n",
-       "      fr_imidazole\n",
+       "      214\n",
+       "      fr_thiocyan\n",
        "      0.000000\n",
        "    \n",
        "    \n",
-       "      208\n",
-       "      fr_imide\n",
+       "      215\n",
+       "      fr_unbrch_alkane\n",
        "      0.000000\n",
        "    \n",
        "    \n",
-       "      209\n",
+       "      216\n",
        "      fr_urea\n",
        "      0.000000\n",
        "    \n",
        "  \n",
        "\n",
-       "
210 rows × 2 columns
\n",
+       "
217 rows × 2 columns
\n",
        "
"
       ],
       "text/plain": [
        "                 feature  importance\n",
-       "0              PEOE_VSA6    0.147449\n",
-       "1            VSA_EState5    0.087963\n",
-       "2    MaxAbsPartialCharge    0.057491\n",
-       "3            VSA_EState6    0.034922\n",
-       "4             SlogP_VSA6    0.028875\n",
+       "0              PEOE_VSA6    0.138689\n",
+       "1            VSA_EState5    0.062832\n",
+       "2    MaxAbsPartialCharge    0.052241\n",
+       "3            VSA_EState6    0.048135\n",
+       "4             SlogP_VSA6    0.027086\n",
        "..                   ...         ...\n",
-       "205           fr_hdrzine    0.000000\n",
-       "206           fr_hdrzone    0.000000\n",
-       "207         fr_imidazole    0.000000\n",
-       "208             fr_imide    0.000000\n",
-       "209              fr_urea    0.000000\n",
+       "212    fr_term_acetylene    0.000000\n",
+       "213          fr_thiazole    0.000000\n",
+       "214          fr_thiocyan    0.000000\n",
+       "215     fr_unbrch_alkane    0.000000\n",
+       "216              fr_urea    0.000000\n",
        "\n",
-       "[210 rows x 2 columns]"
+       "[217 rows x 2 columns]"
       ]
      },
-     "execution_count": 14,
+     "execution_count": 27,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -4486,7 +3374,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 28,
    "id": "4b97778f",
    "metadata": {
     "execution": {
@@ -4538,7 +3426,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 29,
    "id": "bf8ddaf9",
    "metadata": {
     "execution": {
@@ -4920,13 +3808,13 @@
        "[194 rows x 513 columns]"
       ]
      },
-     "execution_count": 16,
+     "execution_count": 29,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "file_cddd_features = Path(\"../tests/data/CDDD_SLC6A4_active_excapedb_subset.csv.gz\")\n",
+    "file_cddd_features = Path(\"../../tests/data/CDDD_SLC6A4_active_excapedb_subset.csv.gz\")\n",
     "assert file_cddd_features.is_file()\n",
     "df_cddd = pd.read_csv(file_cddd_features)\n",
     "df_cddd"
@@ -4944,7 +3832,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 30,
    "id": "db83be01",
    "metadata": {
     "execution": {
@@ -4973,7 +3861,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 31,
    "id": "dae995b7",
    "metadata": {
     "execution": {
@@ -5005,7 +3893,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 32,
    "id": "dc6de049",
    "metadata": {
     "execution": {
@@ -5019,9 +3907,10 @@
     {
      "data": {
       "text/html": [
-       "
ColumnTransformer(transformers=[('pipeline-1',\n",
+       "
ColumnTransformer(transformers=[('pipeline-1',\n",
        "                                 Pipeline(steps=[('smilestomoltransformer',\n",
        "                                                  SmilesToMolTransformer()),\n",
        "                                                 ('standardizer',\n",
@@ -5447,11 +4346,11 @@
        "                                                                                            'BalabanJ',\n",
        "                                                                                            'BertzCT',\n",
        "                                                                                            'Chi0', ...]))]),\n",
-       "                                 <sklearn.compose._column_transformer.make_column_selector object at 0x729f1412c520>),\n",
+       "                                 <sklearn.compose._column_transformer.make_column_selector object at 0x7fb59f3aff50>),\n",
        "                                ('pipeline-2',\n",
        "                                 Pipeline(steps=[('functiontransformer',\n",
        "                                                  FunctionTransformer())]),\n",
-       "                                 <sklearn.compose._column_transformer.make_column_selector object at 0x729f1412ebf0>)])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. 
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
 
<sklearn.compose._column_transformer.make_column_selector object at 0x7fb59f3ad2b0>
FunctionTransformer()
" ], "text/plain": [ "ColumnTransformer(transformers=[('pipeline-1',\n", @@ -5523,14 +4422,14 @@ " 'BalabanJ',\n", " 'BertzCT',\n", " 'Chi0', ...]))]),\n", - " ),\n", + " ),\n", " ('pipeline-2',\n", " Pipeline(steps=[('functiontransformer',\n", " FunctionTransformer())]),\n", - " )])" + " )])" ] }, - "execution_count": 19, + "execution_count": 32, "metadata": {}, "output_type": "execute_result" } @@ -5557,7 +4456,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 33, "id": "6ee85c3c", "metadata": { "execution": { @@ -5571,9 +4470,10 @@ { "data": { "text/html": [ - "
Pipeline(steps=[('columntransformer',\n",
+       "
Pipeline(steps=[('columntransformer',\n",
        "                 ColumnTransformer(transformers=[('pipeline-1',\n",
        "                                                  Pipeline(steps=[('smilestomoltransformer',\n",
        "                                                                   SmilesToMolTransformer()),\n",
@@ -5990,13 +4900,13 @@
        "                                                                                                             'SPS',\n",
        "                                                                                                             'MolW...\n",
        "                                                                                                             'Chi0', ...]))]),\n",
-       "                                                  <sklearn.compose._column_transformer.make_column_selector object at 0x729f1412c520>),\n",
+       "                                                  <sklearn.compose._column_transformer.make_column_selector object at 0x7fb59f3aff50>),\n",
        "                                                 ('pipeline-2',\n",
        "                                                  Pipeline(steps=[('functiontransformer',\n",
        "                                                                   FunctionTransformer())]),\n",
-       "                                                  <sklearn.compose._column_transformer.make_column_selector object at 0x729f1412ebf0>)])),\n",
+       "                                                  <sklearn.compose._column_transformer.make_column_selector object at 0x7fb59f3ad2b0>)])),\n",
        "                ('standardscaler', StandardScaler()),\n",
-       "                ('randomforestregressor', RandomForestRegressor(max_depth=5))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. 
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
<sklearn.compose._column_transformer.make_column_selector object at 0x7fb59f3ad2b0>
FunctionTransformer()
StandardScaler()
RandomForestRegressor(max_depth=5)
" ], "text/plain": [ "Pipeline(steps=[('columntransformer',\n", @@ -6080,16 +4990,16 @@ " 'SPS',\n", " 'MolW...\n", " 'Chi0', ...]))]),\n", - " ),\n", + " ),\n", " ('pipeline-2',\n", " Pipeline(steps=[('functiontransformer',\n", " FunctionTransformer())]),\n", - " )])),\n", + " )])),\n", " ('standardscaler', StandardScaler()),\n", " ('randomforestregressor', RandomForestRegressor(max_depth=5))])" ] }, - "execution_count": 20, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" } @@ -6105,7 +5015,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 34, "id": "03960958", "metadata": { "execution": { @@ -6120,661 +5030,25 @@ "name": "stderr", "output_type": "stream", "text": [ - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:38] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:39] DEPRECATION WARNING: please use MorganGenerator\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "[10:28:42] DEPRECATION WARNING: please use MorganGenerator\n", - "/home/esben/python_envs/vscode/lib/python3.10/site-packages/sklearn/metrics/_regression.py:492: FutureWarning: 'squared' is deprecated in version 1.4 and will be removed in 1.6. To calculate the root mean squared error, use the function'root_mean_squared_error'.\n", - " warnings.warn(\n" + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'DataFrame.swapaxes' is deprecated and will be removed in a future version. Please use 'DataFrame.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'DataFrame.swapaxes' is deprecated and will be removed in a future version. Please use 'DataFrame.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'DataFrame.swapaxes' is deprecated and will be removed in a future version. Please use 'DataFrame.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'DataFrame.swapaxes' is deprecated and will be removed in a future version. Please use 'DataFrame.transpose' instead.\n", + " return bound(*args, **kwds)\n" ] }, { "data": { "text/plain": [ - "{'RMSE': 0.8314055216871027,\n", - " 'MAE': 0.7061918187521163,\n", - " 'R2': 0.2104167870060334}" + "{'RMSE': 0.8008666941742995,\n", + " 'MAE': 0.6900085446099777,\n", + " 'R2': 0.26735673218396616}" ] }, - "execution_count": 21, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } @@ -6796,7 +5070,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 35, "id": "6ce2fe53", "metadata": { "execution": { @@ -6836,15 +5110,15 @@ " \n", " \n", " descriptors\n", - " 0.873696\n", - " 0.707222\n", - " 0.122139\n", + " 0.853908\n", + " 0.722250\n", + " 0.161453\n", " \n", " \n", " combined\n", - " 0.831406\n", - " 0.706192\n", - " 0.210417\n", + " 0.800867\n", + " 0.690009\n", + " 0.267357\n", " \n", " \n", "\n", @@ -6852,11 +5126,11 @@ ], "text/plain": [ " RMSE MAE R2\n", - "descriptors 0.873696 0.707222 0.122139\n", - "combined 0.831406 0.706192 0.210417" + "descriptors 0.853908 0.722250 0.161453\n", + "combined 0.800867 0.690009 0.267357" ] }, - "execution_count": 22, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } @@ -6879,7 +5153,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 36, "id": "9c98ac71", "metadata": { "execution": { @@ -6919,27 +5193,27 @@ " \n", " 0\n", " pipeline-1__PEOE_VSA6\n", - " 0.078597\n", + " 0.077408\n", " \n", " \n", " 1\n", " pipeline-2__cddd_102\n", - " 0.064366\n", + " 0.069598\n", " \n", " \n", " 2\n", - " pipeline-2__cddd_378\n", - " 0.045695\n", + " pipeline-2__cddd_369\n", + " 0.051396\n", " \n", " \n", " 3\n", - " pipeline-1__VSA_EState5\n", - " 0.032759\n", + " pipeline-2__cddd_378\n", + " 0.044292\n", " \n", " \n", " 4\n", - " pipeline-2__cddd_369\n", - " 0.030738\n", + " pipeline-2__cddd_372\n", + " 0.030435\n", " \n", " \n", " ...\n", @@ -6947,53 +5221,53 @@ " ...\n", " \n", " \n", - " 717\n", - " pipeline-1__fr_lactam\n", + " 724\n", + " pipeline-1__PEOE_VSA3\n", " 0.000000\n", " \n", " \n", - " 718\n", - " pipeline-1__fr_NH2\n", + " 725\n", + " pipeline-1__Ipc\n", " 0.000000\n", " \n", " \n", - " 719\n", - " pipeline-1__SMR_VSA2\n", + " 726\n", + " pipeline-1__SMR_VSA8\n", " 0.000000\n", " \n", " \n", - " 720\n", - " pipeline-1__fr_Imine\n", + " 727\n", + " pipeline-2__cddd_461\n", " 0.000000\n", " \n", " \n", - " 721\n", - " pipeline-1__fr_phos_acid\n", + " 728\n", + " pipeline-1__NumRadicalElectrons\n", " 0.000000\n", " \n", " \n", "\n", - "

722 rows × 2 columns

\n", + "

729 rows × 2 columns

\n", "" ], "text/plain": [ - " feature importance\n", - "0 pipeline-1__PEOE_VSA6 0.078597\n", - "1 pipeline-2__cddd_102 0.064366\n", - "2 pipeline-2__cddd_378 0.045695\n", - "3 pipeline-1__VSA_EState5 0.032759\n", - "4 pipeline-2__cddd_369 0.030738\n", - ".. ... ...\n", - "717 pipeline-1__fr_lactam 0.000000\n", - "718 pipeline-1__fr_NH2 0.000000\n", - "719 pipeline-1__SMR_VSA2 0.000000\n", - "720 pipeline-1__fr_Imine 0.000000\n", - "721 pipeline-1__fr_phos_acid 0.000000\n", - "\n", - "[722 rows x 2 columns]" + " feature importance\n", + "0 pipeline-1__PEOE_VSA6 0.077408\n", + "1 pipeline-2__cddd_102 0.069598\n", + "2 pipeline-2__cddd_369 0.051396\n", + "3 pipeline-2__cddd_378 0.044292\n", + "4 pipeline-2__cddd_372 0.030435\n", + ".. ... ...\n", + "724 pipeline-1__PEOE_VSA3 0.000000\n", + "725 pipeline-1__Ipc 0.000000\n", + "726 pipeline-1__SMR_VSA8 0.000000\n", + "727 pipeline-2__cddd_461 0.000000\n", + "728 pipeline-1__NumRadicalElectrons 0.000000\n", + "\n", + "[729 rows x 2 columns]" ] }, - "execution_count": 23, + "execution_count": 36, "metadata": {}, "output_type": "execute_result" } @@ -7011,7 +5285,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 37, "id": "9dbd2a9e", "metadata": { "execution": { @@ -7029,9 +5303,9 @@ "The 5 most important features are:\n", "pipeline-1__PEOE_VSA6\n", "pipeline-2__cddd_102\n", + "pipeline-2__cddd_369\n", "pipeline-2__cddd_378\n", - "pipeline-1__VSA_EState5\n", - "pipeline-2__cddd_369\n" + "pipeline-2__cddd_372\n" ] } ], @@ -7058,7 +5332,7 @@ "formats": "docs//notebooks//ipynb,docs//notebooks//scripts//py:percent" }, "kernelspec": { - "display_name": "Python 3.9.4 ('rdkit')", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -7072,7 +5346,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.12.6" } }, "nbformat": 4, diff --git a/docs/notebooks/11_safe_inference.ipynb b/docs/notebooks/11_safe_inference.ipynb index 66d53fd..126086e 100644 --- a/docs/notebooks/11_safe_inference.ipynb +++ b/docs/notebooks/11_safe_inference.ipynb @@ -16,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 10, "id": "ac780f4c", "metadata": { "execution": { @@ -30,16 +30,16 @@ { "data": { "text/plain": [ - "array([[],\n", - " [],\n", - " [],\n", - " [],\n", + "array([[],\n", + " [],\n", + " [],\n", + " [],\n", " [InvalidMol('SmilesToMolTransformer(safe_inference_mode=True)', error='Invalid Molecule: Explicit valence for atom # 0 N, 4, is greater than permitted')],\n", " [InvalidMol('SmilesToMolTransformer(safe_inference_mode=True)', error='Invalid SMILES: I'm not a SMILES')]],\n", " dtype=object)" ] }, - "execution_count": 1, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -72,7 +72,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 11, "id": "44a6019c", "metadata": { "execution": { @@ -86,13 +86,13 @@ { "data": { "text/plain": [ - "[array([], dtype=object),\n", - " array([], dtype=object),\n", - " array([], dtype=object),\n", - " array([], dtype=object)]" + "[array([], dtype=object),\n", + " array([], dtype=object),\n", + " array([], dtype=object),\n", + " array([], dtype=object)]" ] }, - "execution_count": 2, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -111,7 +111,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 12, "id": "8286fd44", "metadata": { "execution": { @@ -125,13 +125,13 @@ { "data": { "text/plain": [ - "array([,\n", - " ,\n", - " ,\n", - " ], dtype=object)" + "array([,\n", + " ,\n", + " ,\n", + " ], dtype=object)" ] }, - "execution_count": 3, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -151,7 +151,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 13, "id": "9a705642", "metadata": { "execution": { @@ -200,7 +200,7 @@ " fill_value=1e+20)" ] }, - "execution_count": 4, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -223,7 +223,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 14, "id": "37987dc9", "metadata": { "execution": { @@ -239,7 +239,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/esben/git/scikit-mol/scikit_mol/safeinference.py:49: UserWarning: SafeInferenceWrapper is in safe_inference_mode during use of fit and invalid data detected. This mode is intended for safe inference in production, not for training and evaluation.\n", + "/home/anton/projects/scikit-mol/scikit_mol/safeinference.py:64: UserWarning: SafeInferenceWrapper is in safe_inference_mode during use of fit and invalid data detected. This mode is intended for safe inference in production, not for training and evaluation.\n", + " warnings.warn(\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", " warnings.warn(\n" ] }, @@ -249,7 +251,7 @@ "array([ 0., 1., 0., 1., nan, nan])" ] }, - "execution_count": 5, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -285,7 +287,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 15, "id": "51436aa8", "metadata": { "execution": { @@ -354,7 +356,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 16, "id": "b8dbd88c", "metadata": { "execution": { @@ -539,7 +541,7 @@ "[4 rows x 25 columns]" ] }, - "execution_count": 7, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -563,7 +565,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 17, "id": "710ceeb0", "metadata": { "execution": { @@ -804,7 +806,7 @@ "[6 rows x 25 columns]" ] }, - "execution_count": 8, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -824,7 +826,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 18, "id": "bbfe1ec0", "metadata": { "execution": { @@ -835,14 +837,6 @@ } }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/esben/git/scikit-mol/scikit_mol/fingerprints/morgan.py:69: DeprecationWarning: dtype is no longer supported, due to move to generator based fingerprints\n", - " self.dtype = dtype\n" - ] - }, { "data": { "text/html": [ @@ -1017,7 +1011,7 @@ "[4 rows x 25 columns]" ] }, - "execution_count": 9, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -1045,7 +1039,7 @@ "formats": "docs//notebooks//ipynb,docs//notebooks//scripts//py:percent" }, "kernelspec": { - "display_name": "Python 3.9.4 ('rdkit')", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -1059,7 +1053,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.12.6" } }, "nbformat": 4, diff --git a/docs/notebooks/12_custom_fingerprint_transformer.ipynb b/docs/notebooks/12_custom_fingerprint_transformer.ipynb index 710cb0b..9f8c0cb 100644 --- a/docs/notebooks/12_custom_fingerprint_transformer.ipynb +++ b/docs/notebooks/12_custom_fingerprint_transformer.ipynb @@ -30,6 +30,22 @@ "id": "1ed1c7f0", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/joblib/externals/loky/backend/fork_exec.py:38: DeprecationWarning: This process (pid=43991) is multi-threaded, use of fork() may lead to deadlocks in the child.\n", + " pid = os.fork()\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/joblib/externals/loky/backend/fork_exec.py:38: DeprecationWarning: This process (pid=43991) is multi-threaded, use of fork() may lead to deadlocks in the child.\n", + " pid = os.fork()\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/joblib/externals/loky/backend/fork_exec.py:38: DeprecationWarning: This process (pid=43991) is multi-threaded, use of fork() may lead to deadlocks in the child.\n", + " pid = os.fork()\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/joblib/externals/loky/backend/fork_exec.py:38: DeprecationWarning: This process (pid=43991) is multi-threaded, use of fork() may lead to deadlocks in the child.\n", + " pid = os.fork()\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/joblib/externals/loky/backend/fork_exec.py:38: DeprecationWarning: This process (pid=43991) is multi-threaded, use of fork() may lead to deadlocks in the child.\n", + " pid = os.fork()\n" + ] + }, { "data": { "text/plain": [ @@ -39,7 +55,7 @@ " ...,\n", " [2., 2., 2., ..., 2., 2., 2.],\n", " [2., 2., 2., ..., 2., 2., 2.],\n", - " [2., 2., 2., ..., 2., 2., 2.]])" + " [2., 2., 2., ..., 2., 2., 2.]], shape=(100, 64))" ] }, "execution_count": 1, @@ -97,7 +113,7 @@ " ...,\n", " [0, 0, 0, ..., 0, 0, 0],\n", " [0, 0, 0, ..., 0, 0, 0],\n", - " [0, 0, 0, ..., 0, 0, 0]], dtype=uint8)" + " [0, 0, 0, ..., 0, 0, 0]], shape=(100, 512), dtype=uint8)" ] }, "execution_count": 2, @@ -145,10 +161,32 @@ "name": "stdout", "output_type": "stream", "text": [ - "n_jobs=1 is fine\n", + "n_jobs=1 is fine\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/joblib/externals/loky/backend/fork_exec.py:38: DeprecationWarning: This process (pid=43991) is multi-threaded, use of fork() may lead to deadlocks in the child.\n", + " pid = os.fork()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "n_jobs=2 is not fine, because the generator passed as an argument is not picklable\n", "Error msg: Could not pickle the task to send it to the workers.\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/joblib/externals/loky/backend/fork_exec.py:38: DeprecationWarning: This process (pid=43991) is multi-threaded, use of fork() may lead to deadlocks in the child.\n", + " pid = os.fork()\n" + ] } ], "source": [ @@ -234,7 +272,7 @@ "formats": "docs//notebooks//ipynb,docs//notebooks//scripts//py:percent" }, "kernelspec": { - "display_name": "Python 3.9.4 ('rdkit')", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -248,7 +286,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.12.6" } }, "nbformat": 4, diff --git a/docs/notebooks/13_applicability_domain.ipynb b/docs/notebooks/13_applicability_domain.ipynb index 01fa965..e456495 100644 --- a/docs/notebooks/13_applicability_domain.ipynb +++ b/docs/notebooks/13_applicability_domain.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 5, "id": "40500fae", "metadata": {}, "outputs": [], @@ -49,7 +49,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 6, "id": "79d3b853", "metadata": {}, "outputs": [ @@ -57,13 +57,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "0 out of 7228 SMILES failed in conversion\n" + "0 out of 200 SMILES failed in conversion\n" ] } ], "source": [ "# Load the dataset\n", - "csv_file = \"../tests/data/SLC6A4_active_excapedb_subset.csv\"\n", + "csv_file = \"../../tests/data/SLC6A4_active_excapedb_subset.csv\"\n", "data = pd.read_csv(csv_file)\n", "\n", "# Add RDKit mol objects\n", @@ -93,7 +93,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 7, "id": "9c89148b", "metadata": {}, "outputs": [ @@ -101,440 +101,35 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/esben/envs/vscode/lib/python3.10/site-packages/numpy/core/fromnumeric.py:59: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", - " return bound(*args, **kwds)\n" + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/sklearn/metrics/pairwise.py:2466: DataConversionWarning: Data was converted to boolean for metric jaccard\n", + " warnings.warn(msg, DataConversionWarning)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/sklearn/metrics/pairwise.py:2466: DataConversionWarning: Data was converted to boolean for metric jaccard\n", + " warnings.warn(msg, DataConversionWarning)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/sklearn/metrics/pairwise.py:2466: DataConversionWarning: Data was converted to boolean for metric jaccard\n", + " warnings.warn(msg, DataConversionWarning)\n" ] - }, - { - "data": { - "text/html": [ - "
Pipeline(steps=[('fp', MorganFingerprintTransformer()),\n",
-       "                ('rf', RandomForestRegressor(n_jobs=-1, random_state=61453))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ], - "text/plain": [ - "Pipeline(steps=[('fp', MorganFingerprintTransformer()),\n", - " ('rf', RandomForestRegressor(n_jobs=-1, random_state=61453))])" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ @@ -574,37 +169,56 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "id": "ee7b2f64", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/esben/envs/vscode/lib/python3.10/site-packages/numpy/core/fromnumeric.py:59: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", - " return bound(*args, **kwds)\n" - ] - }, { "data": { + "image/png": "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", "text/plain": [ - "Text(0.5, 1.0, 'Predicted pXC50 vs Absolute Error')" + "
" ] }, - "execution_count": 9, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "95th percentile of errors inside domain: 1.29\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/_core/fromnumeric.py:57: FutureWarning: 'Series.swapaxes' is deprecated and will be removed in a future version. Please use 'Series.transpose' instead.\n", + " return bound(*args, **kwds)\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/home/anton/projects/scikit-mol/.venv/lib/python3.12/site-packages/sklearn/metrics/pairwise.py:2466: DataConversionWarning: Data was converted to boolean for metric jaccard\n", + " warnings.warn(msg, DataConversionWarning)\n" + ] + }, + { + "ename": "IndexError", + "evalue": "index -1 is out of bounds for axis 0 with size 0", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[8], line 16\u001b[0m\n\u001b[1;32m 13\u001b[0m errors_out \u001b[38;5;241m=\u001b[39m abs_errors[in_domain \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\n\u001b[1;32m 15\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m95th percentile of errors inside domain: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mnp\u001b[38;5;241m.\u001b[39mpercentile(errors_in,\u001b[38;5;250m \u001b[39m\u001b[38;5;241m95\u001b[39m)\u001b[38;5;132;01m:\u001b[39;00m\u001b[38;5;124m.2f\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m---> 16\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m95th percentile of errors outside domain: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpercentile\u001b[49m\u001b[43m(\u001b[49m\u001b[43merrors_out\u001b[49m\u001b[43m,\u001b[49m\u001b[38;5;250;43m \u001b[39;49m\u001b[38;5;241;43m95\u001b[39;49m\u001b[43m)\u001b[49m\u001b[38;5;132;01m:\u001b[39;00m\u001b[38;5;124m.2f\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 17\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFraction of samples outside domain: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m(in_domain\u001b[38;5;250m \u001b[39m\u001b[38;5;241m==\u001b[39m\u001b[38;5;250m \u001b[39m\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m)\u001b[38;5;241m.\u001b[39mmean()\u001b[38;5;132;01m:\u001b[39;00m\u001b[38;5;124m.2f\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n", + "File \u001b[0;32m~/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/lib/_function_base_impl.py:4273\u001b[0m, in \u001b[0;36mpercentile\u001b[0;34m(a, q, axis, out, overwrite_input, method, keepdims, weights, interpolation)\u001b[0m\n\u001b[1;32m 4270\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m np\u001b[38;5;241m.\u001b[39many(weights \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m0\u001b[39m):\n\u001b[1;32m 4271\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mWeights must be non-negative.\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m-> 4273\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_quantile_unchecked\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 4274\u001b[0m \u001b[43m \u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mq\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mout\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43moverwrite_input\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkeepdims\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mweights\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/lib/_function_base_impl.py:4550\u001b[0m, in \u001b[0;36m_quantile_unchecked\u001b[0;34m(a, q, axis, out, overwrite_input, method, keepdims, weights)\u001b[0m\n\u001b[1;32m 4541\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21m_quantile_unchecked\u001b[39m(a,\n\u001b[1;32m 4542\u001b[0m q,\n\u001b[1;32m 4543\u001b[0m axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 4547\u001b[0m keepdims\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m,\n\u001b[1;32m 4548\u001b[0m weights\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[1;32m 4549\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m\"\"\"Assumes that q is in [0, 1], and is an ndarray\"\"\"\u001b[39;00m\n\u001b[0;32m-> 4550\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_ureduce\u001b[49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4551\u001b[0m \u001b[43m \u001b[49m\u001b[43mfunc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m_quantile_ureduce_func\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4552\u001b[0m \u001b[43m \u001b[49m\u001b[43mq\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mq\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4553\u001b[0m \u001b[43m \u001b[49m\u001b[43mweights\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mweights\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4554\u001b[0m \u001b[43m \u001b[49m\u001b[43mkeepdims\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mkeepdims\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4555\u001b[0m \u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maxis\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4556\u001b[0m \u001b[43m \u001b[49m\u001b[43mout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4557\u001b[0m \u001b[43m \u001b[49m\u001b[43moverwrite_input\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moverwrite_input\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4558\u001b[0m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmethod\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m~/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/lib/_function_base_impl.py:3894\u001b[0m, in \u001b[0;36m_ureduce\u001b[0;34m(a, func, keepdims, **kwargs)\u001b[0m\n\u001b[1;32m 3891\u001b[0m index_out \u001b[38;5;241m=\u001b[39m (\u001b[38;5;241m0\u001b[39m, ) \u001b[38;5;241m*\u001b[39m nd\n\u001b[1;32m 3892\u001b[0m kwargs[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mout\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m out[(\u001b[38;5;28mEllipsis\u001b[39m, ) \u001b[38;5;241m+\u001b[39m index_out]\n\u001b[0;32m-> 3894\u001b[0m r \u001b[38;5;241m=\u001b[39m \u001b[43mfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3896\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m out \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 3897\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m out\n", + "File \u001b[0;32m~/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/lib/_function_base_impl.py:4727\u001b[0m, in \u001b[0;36m_quantile_ureduce_func\u001b[0;34m(a, q, weights, axis, out, overwrite_input, method)\u001b[0m\n\u001b[1;32m 4725\u001b[0m arr \u001b[38;5;241m=\u001b[39m a\u001b[38;5;241m.\u001b[39mcopy()\n\u001b[1;32m 4726\u001b[0m wgt \u001b[38;5;241m=\u001b[39m weights\n\u001b[0;32m-> 4727\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[43m_quantile\u001b[49m\u001b[43m(\u001b[49m\u001b[43marr\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4728\u001b[0m \u001b[43m \u001b[49m\u001b[43mquantiles\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mq\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4729\u001b[0m \u001b[43m \u001b[49m\u001b[43maxis\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maxis\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4730\u001b[0m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4731\u001b[0m \u001b[43m \u001b[49m\u001b[43mout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 4732\u001b[0m \u001b[43m \u001b[49m\u001b[43mweights\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwgt\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 4733\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m result\n", + "File \u001b[0;32m~/projects/scikit-mol/.venv/lib/python3.12/site-packages/numpy/lib/_function_base_impl.py:4849\u001b[0m, in \u001b[0;36m_quantile\u001b[0;34m(arr, quantiles, axis, method, out, weights)\u001b[0m\n\u001b[1;32m 4842\u001b[0m arr\u001b[38;5;241m.\u001b[39mpartition(\n\u001b[1;32m 4843\u001b[0m np\u001b[38;5;241m.\u001b[39munique(np\u001b[38;5;241m.\u001b[39mconcatenate(([\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m],\n\u001b[1;32m 4844\u001b[0m previous_indexes\u001b[38;5;241m.\u001b[39mravel(),\n\u001b[1;32m 4845\u001b[0m next_indexes\u001b[38;5;241m.\u001b[39mravel(),\n\u001b[1;32m 4846\u001b[0m ))),\n\u001b[1;32m 4847\u001b[0m axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m)\n\u001b[1;32m 4848\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m supports_nans:\n\u001b[0;32m-> 4849\u001b[0m slices_having_nans \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39misnan(\u001b[43marr\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m-\u001b[39;49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m]\u001b[49m)\n\u001b[1;32m 4850\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m 4851\u001b[0m slices_having_nans \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "\u001b[0;31mIndexError\u001b[0m: index -1 is out of bounds for axis 0 with size 0" + ] } ], "source": [ @@ -640,7 +254,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "fe4a6819", "metadata": {}, "outputs": [ @@ -1143,7 +757,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "57d73a11", "metadata": {}, "outputs": [ @@ -1196,7 +810,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "id": "1d33100d", "metadata": {}, "outputs": [ @@ -1273,7 +887,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "id": "3aaf4485", "metadata": {}, "outputs": [ @@ -1350,7 +964,7 @@ "formats": "docs//notebooks//ipynb,docs//notebooks//scripts//py:percent" }, "kernelspec": { - "display_name": "Python 3.9.4 ('rdkit')", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -1364,7 +978,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.12.6" } }, "nbformat": 4, From c070f64203f55d60482895945ecc3556e11aef86 Mon Sep 17 00:00:00 2001 From: Anton Siomchen <41703271+asiomchen@users.noreply.github.com> Date: Thu, 8 May 2025 18:27:45 +0200 Subject: [PATCH 6/7] sync py files --- docs/notebooks/scripts/05_smiles_sanitization.py | 2 +- docs/notebooks/scripts/06_hyperparameter_tuning.py | 2 +- docs/notebooks/scripts/08_external_library_skopt.py | 2 +- ...natorial_Method_Usage_with_FingerPrint_Transformers.py | 6 +++--- docs/notebooks/scripts/10_pipeline_pandas_output.py | 8 ++++---- docs/notebooks/scripts/11_safe_inference.py | 2 +- .../scripts/12_custom_fingerprint_transformer.py | 2 +- docs/notebooks/scripts/13_applicability_domain.py | 4 ++-- 8 files changed, 14 insertions(+), 14 deletions(-) diff --git a/docs/notebooks/scripts/05_smiles_sanitization.py b/docs/notebooks/scripts/05_smiles_sanitization.py index c5338b3..e2f36da 100644 --- a/docs/notebooks/scripts/05_smiles_sanitization.py +++ b/docs/notebooks/scripts/05_smiles_sanitization.py @@ -21,7 +21,7 @@ import pandas as pd from rdkit.Chem import PandasTools -csv_file = "../tests/data/SLC6A4_active_excapedb_subset.csv" # Hmm, maybe better to download directly +csv_file = "../../tests/data/SLC6A4_active_excapedb_subset.csv" # Hmm, maybe better to download directly data = pd.read_csv(csv_file) diff --git a/docs/notebooks/scripts/06_hyperparameter_tuning.py b/docs/notebooks/scripts/06_hyperparameter_tuning.py index aa425ac..e1408de 100644 --- a/docs/notebooks/scripts/06_hyperparameter_tuning.py +++ b/docs/notebooks/scripts/06_hyperparameter_tuning.py @@ -47,7 +47,7 @@ url = "https://ndownloader.figshare.com/files/25747817" urllib.request.urlretrieve(url, csv_file) else: - csv_file = "../tests/data/SLC6A4_active_excapedb_subset.csv" + csv_file = "../../tests/data/SLC6A4_active_excapedb_subset.csv" # %% [markdown] # The CSV data is loaded into a Pandas dataframe and the PandasTools utility from RDKit is used to add a column with RDKit molecules diff --git a/docs/notebooks/scripts/08_external_library_skopt.py b/docs/notebooks/scripts/08_external_library_skopt.py index 14dc493..aa6e0ce 100644 --- a/docs/notebooks/scripts/08_external_library_skopt.py +++ b/docs/notebooks/scripts/08_external_library_skopt.py @@ -8,7 +8,7 @@ # format_version: '1.3' # jupytext_version: 1.16.6 # kernelspec: -# display_name: vscode +# display_name: .venv # language: python # name: python3 # --- diff --git a/docs/notebooks/scripts/09_Combinatorial_Method_Usage_with_FingerPrint_Transformers.py b/docs/notebooks/scripts/09_Combinatorial_Method_Usage_with_FingerPrint_Transformers.py index 48c1f5b..ce275c2 100644 --- a/docs/notebooks/scripts/09_Combinatorial_Method_Usage_with_FingerPrint_Transformers.py +++ b/docs/notebooks/scripts/09_Combinatorial_Method_Usage_with_FingerPrint_Transformers.py @@ -8,9 +8,9 @@ # format_version: '1.3' # jupytext_version: 1.16.6 # kernelspec: -# display_name: aniEnv +# display_name: .venv # language: python -# name: anienv +# name: python3 # --- # %% [markdown] @@ -66,7 +66,7 @@ url = "https://ndownloader.figshare.com/files/25747817" urllib.request.urlretrieve(url, csv_file) else: - csv_file = "../tests/data/SLC6A4_active_excapedb_subset.csv" + csv_file = "../../tests/data/SLC6A4_active_excapedb_subset.csv" # Parse Database data = pd.read_csv(csv_file) diff --git a/docs/notebooks/scripts/10_pipeline_pandas_output.py b/docs/notebooks/scripts/10_pipeline_pandas_output.py index 64158b8..f49339f 100644 --- a/docs/notebooks/scripts/10_pipeline_pandas_output.py +++ b/docs/notebooks/scripts/10_pipeline_pandas_output.py @@ -8,7 +8,7 @@ # format_version: '1.3' # jupytext_version: 1.16.6 # kernelspec: -# display_name: Python 3.9.4 ('rdkit') +# display_name: .venv # language: python # name: python3 # --- @@ -36,7 +36,7 @@ from scikit_mol.fingerprints import MorganFingerprintTransformer # %% -csv_file = Path("../tests/data/SLC6A4_active_excapedb_subset.csv") +csv_file = Path("../../tests/data/SLC6A4_active_excapedb_subset.csv") assert csv_file.is_file() data = pd.read_csv(csv_file) data.drop_duplicates(subset="Ambit_InchiKey", inplace=True) @@ -131,7 +131,7 @@ # %% def compute_metrics(y_true, y_pred): result = { - "RMSE": mean_squared_error(y_true=y_true, y_pred=y_pred, squared=False), + "RMSE": mean_squared_error(y_true=y_true, y_pred=y_pred) ** 0.5, "MAE": mean_absolute_error(y_true=y_true, y_pred=y_pred), "R2": r2_score(y_true=y_true, y_pred=y_pred), } @@ -187,7 +187,7 @@ def compute_metrics(y_true, y_pred): # We have precomputed these features and stored them in a file: # %% -file_cddd_features = Path("../tests/data/CDDD_SLC6A4_active_excapedb_subset.csv.gz") +file_cddd_features = Path("../../tests/data/CDDD_SLC6A4_active_excapedb_subset.csv.gz") assert file_cddd_features.is_file() df_cddd = pd.read_csv(file_cddd_features) df_cddd diff --git a/docs/notebooks/scripts/11_safe_inference.py b/docs/notebooks/scripts/11_safe_inference.py index fab5502..c55045b 100644 --- a/docs/notebooks/scripts/11_safe_inference.py +++ b/docs/notebooks/scripts/11_safe_inference.py @@ -8,7 +8,7 @@ # format_version: '1.3' # jupytext_version: 1.16.6 # kernelspec: -# display_name: Python 3.9.4 ('rdkit') +# display_name: .venv # language: python # name: python3 # --- diff --git a/docs/notebooks/scripts/12_custom_fingerprint_transformer.py b/docs/notebooks/scripts/12_custom_fingerprint_transformer.py index 1ca80c4..f905db7 100644 --- a/docs/notebooks/scripts/12_custom_fingerprint_transformer.py +++ b/docs/notebooks/scripts/12_custom_fingerprint_transformer.py @@ -8,7 +8,7 @@ # format_version: '1.3' # jupytext_version: 1.16.6 # kernelspec: -# display_name: Python 3.9.4 ('rdkit') +# display_name: .venv # language: python # name: python3 # --- diff --git a/docs/notebooks/scripts/13_applicability_domain.py b/docs/notebooks/scripts/13_applicability_domain.py index d6e3ebf..93ace0b 100644 --- a/docs/notebooks/scripts/13_applicability_domain.py +++ b/docs/notebooks/scripts/13_applicability_domain.py @@ -8,7 +8,7 @@ # format_version: '1.3' # jupytext_version: 1.16.6 # kernelspec: -# display_name: Python 3.9.4 ('rdkit') +# display_name: .venv # language: python # name: python3 # --- @@ -45,7 +45,7 @@ # %% # Load the dataset -csv_file = "../tests/data/SLC6A4_active_excapedb_subset.csv" +csv_file = "../../tests/data/SLC6A4_active_excapedb_subset.csv" data = pd.read_csv(csv_file) # Add RDKit mol objects From f3fd02150832bee4e0bb5be7b1cbafbf554e4c75 Mon Sep 17 00:00:00 2001 From: Anton Siomchen <41703271+asiomchen@users.noreply.github.com> Date: Thu, 8 May 2025 18:30:01 +0200 Subject: [PATCH 7/7] update target Python version to 3.9 in ruff.toml --- ruff.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ruff.toml b/ruff.toml index af72105..a8c0dca 100644 --- a/ruff.toml +++ b/ruff.toml @@ -35,8 +35,8 @@ exclude = [ line-length = 88 indent-width = 4 -# Assume Python 3.8 -target-version = "py38" +# Assume Python 3.9 +target-version = "py39" [lint] # Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`) codes by default.