├── .gitignore ├── LICENSE ├── README.md ├── UPGMA_classification-rdkit.ipynb ├── UPGMA_classification.arthor.ipynb ├── requirements.txt ├── setup.cfg ├── setup.py └── src └── automated_series_classification ├── Butinaclustering.py ├── UPGMAclustering.py ├── __init__.py ├── dataprep.py ├── mainSeriesClassification.py ├── utilsDataPrep.py ├── utilsDrawing.py └── utilsStructureEval.py /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | build/ 12 | develop-eggs/ 13 | dist/ 14 | downloads/ 15 | eggs/ 16 | .eggs/ 17 | lib/ 18 | lib64/ 19 | parts/ 20 | sdist/ 21 | var/ 22 | wheels/ 23 | pip-wheel-metadata/ 24 | share/python-wheels/ 25 | *.egg-info/ 26 | .installed.cfg 27 | *.egg 28 | MANIFEST 29 | 30 | # PyInstaller 31 | # Usually these files are written by a python script from a template 32 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 33 | *.manifest 34 | *.spec 35 | 36 | # Installer logs 37 | pip-log.txt 38 | pip-delete-this-directory.txt 39 | 40 | # Unit test / coverage reports 41 | htmlcov/ 42 | .tox/ 43 | .nox/ 44 | .coverage 45 | .coverage.* 46 | .cache 47 | nosetests.xml 48 | coverage.xml 49 | *.cover 50 | *.py,cover 51 | .hypothesis/ 52 | .pytest_cache/ 53 | 54 | # Translations 55 | *.mo 56 | *.pot 57 | 58 | # Django stuff: 59 | *.log 60 | local_settings.py 61 | db.sqlite3 62 | db.sqlite3-journal 63 | 64 | # Flask stuff: 65 | instance/ 66 | .webassets-cache 67 | 68 | # Scrapy stuff: 69 | .scrapy 70 | 71 | # Sphinx documentation 72 | docs/_build/ 73 | 74 | # PyBuilder 75 | target/ 76 | 77 | # Jupyter Notebook 78 | .ipynb_checkpoints 79 | 80 | # IPython 81 | profile_default/ 82 | ipython_config.py 83 | 84 | # pyenv 85 | .python-version 86 | 87 | # pipenv 88 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 89 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 90 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 91 | # install all needed dependencies. 92 | #Pipfile.lock 93 | 94 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow 95 | __pypackages__/ 96 | 97 | # Celery stuff 98 | celerybeat-schedule 99 | celerybeat.pid 100 | 101 | # SageMath parsed files 102 | *.sage.py 103 | 104 | # Environments 105 | .env 106 | .venv 107 | env/ 108 | venv/ 109 | ENV/ 110 | env.bak/ 111 | venv.bak/ 112 | 113 | # Spyder project settings 114 | .spyderproject 115 | .spyproject 116 | 117 | # Rope project settings 118 | .ropeproject 119 | 120 | # mkdocs documentation 121 | /site 122 | 123 | # mypy 124 | .mypy_cache/ 125 | .dmypy.json 126 | dmypy.json 127 | 128 | # Pyre type checker 129 | .pyre/ 130 | 131 | # 132 | *.pkl 133 | *.db 134 | *.sdf.gz 135 | *.xls 136 | rdk_db 137 | CDK2Kinase 138 | BACE 139 | 140 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2020 iwatobipen 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # AutomatedSeriesClassification 2 | 3 | This is code for automated chemical series classification 4 | 5 | 6 | ## Original article 7 | 8 | Automated Identification of Chemical Series: Classifying like a Medicinal Chemist 9 | https://pubs.acs.org/doi/abs/10.1021/acs.jcim.0c00204 10 | 11 | ## Installation 12 | 13 | First, you should have RDKit installed. Then, the code can be downloaded and installed with: 14 | 15 | ```bash 16 | git clone https://github.com/rdkit/AutomatedSeriesClassification 17 | cd AutomatedSeriesClassification 18 | pip install -e . 19 | ``` 20 | 21 | The ``-e`` flag means it gets installed in editable mode. 22 | 23 | ## Example usage 24 | 25 | ### Data Preparation 26 | 27 | 1. The following script will download chembl27.sdf.gz and make substructurefingerprint library. 28 | If you want to use an alternate version of chembl, specify the `--chebml-version` flag. You 29 | can run `python -m automated_series_classification.dataprep --help` in your shell to see all options. 30 | 31 | ``` 32 | $ python -m automated_series_classification.dataprep # it'll take ~30 or more minutes on my PC 33 | ``` 34 | 35 | 2. Then launch jupyter notebook, the notebook use same dataset as original articles. But you'll get different results compared to the article. This is because I used more newer version of ChEMBL for this code. If you would like to use same dataset to original article it is easy, just changing download link of chembl 36 | 37 | 38 | ## Acknoledgements 39 | 40 | - Greg Landrum 41 | 42 | 43 | ## etc 44 | 45 | Any comments, requests and suggestions will be greatly appreciated. 46 | 47 | 48 | 49 | ## License 50 | [MIT](https://choosealicense.com/licenses/mit/) 51 | -------------------------------------------------------------------------------- /UPGMA_classification-rdkit.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "name": "stdout", 10 | "output_type": "stream", 11 | "text": [ 12 | "RDKit version: 2021.03.3\n", 13 | "Pandas version: 1.2.4\n", 14 | "Numpy version: 1.20.3\n", 15 | "MatplotLib version: 3.4.2\n", 16 | "Sklearn version: 0.24.2\n", 17 | "Seaborn version: 0.11.1\n" 18 | ] 19 | } 20 | ], 21 | "source": [ 22 | "import imp\n", 23 | "import pickle\n", 24 | "import os\n", 25 | "import sys\n", 26 | "import time\n", 27 | "\n", 28 | "import pandas as pd\n", 29 | "import numpy as np\n", 30 | "import sklearn\n", 31 | "import seaborn as sns\n", 32 | "import matplotlib as mpl\n", 33 | "import matplotlib.pyplot as plt\n", 34 | "from ipywidgets import interact,fixed,IntSlider\n", 35 | "from IPython.display import SVG\n", 36 | "from matplotlib import rcParams\n", 37 | "from matplotlib.colors import hex2color\n", 38 | "from rdkit import Chem, rdBase\n", 39 | "from rdkit.Chem import rdFMCS, Draw, PandasTools, AllChem, DataStructs, Descriptors\n", 40 | "from rdkit.Chem import rdSubstructLibrary\n", 41 | "from rdkit.Chem.Draw import IPythonConsole\n", 42 | "from rdkit import DataStructs\n", 43 | "\n", 44 | "print('RDKit version: ',rdBase.rdkitVersion)\n", 45 | "print('Pandas version:', pd.__version__)\n", 46 | "print('Numpy version:', np.__version__)\n", 47 | "print('MatplotLib version:', mpl.__version__)\n", 48 | "print('Sklearn version:', sklearn.__version__)\n", 49 | "print('Seaborn version:', sns.__version__)" 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": 2, 55 | "metadata": {}, 56 | "outputs": [ 57 | { 58 | "data": { 59 | "text/plain": [ 60 | "" 61 | ] 62 | }, 63 | "execution_count": 2, 64 | "metadata": {}, 65 | "output_type": "execute_result" 66 | } 67 | ], 68 | "source": [ 69 | "import automated_series_classification\n", 70 | "imp.reload(automated_series_classification)\n", 71 | "from automated_series_classification import utilsDataPrep\n", 72 | "from automated_series_classification import mainSeriesClassification\n", 73 | "imp.reload(mainSeriesClassification)\n", 74 | "from automated_series_classification import utilsDrawing\n", 75 | "from automated_series_classification import UPGMAclustering\n", 76 | "imp.reload(UPGMAclustering)\n" 77 | ] 78 | }, 79 | { 80 | "cell_type": "markdown", 81 | "metadata": {}, 82 | "source": [ 83 | "Load ChEMBL database for substructure matching (constructed during data preprocessing)" 84 | ] 85 | }, 86 | { 87 | "cell_type": "code", 88 | "execution_count": 3, 89 | "metadata": {}, 90 | "outputs": [ 91 | { 92 | "name": "stdout", 93 | "output_type": "stream", 94 | "text": [ 95 | "CPU times: user 20.9 s, sys: 620 ms, total: 21.6 s\n", 96 | "Wall time: 21.6 s\n" 97 | ] 98 | } 99 | ], 100 | "source": [ 101 | "%%time\n", 102 | "with open('./data/chembl27_sssdata.pkl','rb') as file:\n", 103 | " chembldb = pickle.load(file)\n", 104 | " " 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": 4, 110 | "metadata": {}, 111 | "outputs": [ 112 | { 113 | "name": "stdout", 114 | "output_type": "stream", 115 | "text": [ 116 | "The library has 1855322 molecules.\n", 117 | "CPU times: user 2.71 s, sys: 148 ms, total: 2.86 s\n", 118 | "Wall time: 2.86 s\n" 119 | ] 120 | } 121 | ], 122 | "source": [ 123 | "%%time\n", 124 | "mols = rdSubstructLibrary.CachedTrustedSmilesMolHolder()\n", 125 | "fps = rdSubstructLibrary.PatternHolder()\n", 126 | "for smi,fp in chembldb:\n", 127 | " mols.AddSmiles(smi)\n", 128 | " fps.AddFingerprint(fp)\n", 129 | "chembl_library = rdSubstructLibrary.SubstructLibrary(mols,fps)\n", 130 | "chembldb = None\n", 131 | "print(f\"The library has {len(chembl_library)} molecules.\")" 132 | ] 133 | }, 134 | { 135 | "cell_type": "code", 136 | "execution_count": 5, 137 | "metadata": {}, 138 | "outputs": [], 139 | "source": [ 140 | "Nchembl = len(chembl_library)" 141 | ] 142 | }, 143 | { 144 | "cell_type": "markdown", 145 | "metadata": {}, 146 | "source": [ 147 | "Define Parameters, note that flimit corresponds to the specificity limit E(p) as described in the paper\n", 148 | "\n", 149 | "TIPS:dbpath is not automatically updated so if you would like to try to analyze different dataset, you should remove rdk_db or define dbpath by different name" 150 | ] 151 | }, 152 | { 153 | "cell_type": "code", 154 | "execution_count": 6, 155 | "metadata": {}, 156 | "outputs": [], 157 | "source": [ 158 | "flimit=2e-3\n", 159 | "MinClusterSize=20 #20\n", 160 | "proj='CDK2Kinase'\n", 161 | "dbpath='./rdk_db/cdk2_db'\n", 162 | "filename='moldata_preprocessed.csv'\n", 163 | "datapath='./{0}/'.format(proj)" 164 | ] 165 | }, 166 | { 167 | "cell_type": "markdown", 168 | "metadata": {}, 169 | "source": [ 170 | "### UPGMA classification" 171 | ] 172 | }, 173 | { 174 | "cell_type": "markdown", 175 | "metadata": {}, 176 | "source": [ 177 | "Set \"calcDists\" to True only if the pairwise molecular distance matrix for clustering is not calculated yet (this will take a while). Set \"calcScores\" only if you are interested in the intra-cluster distance metric, this slows down the clustering." 178 | ] 179 | }, 180 | { 181 | "cell_type": "code", 182 | "execution_count": 7, 183 | "metadata": {}, 184 | "outputs": [ 185 | { 186 | "name": "stdout", 187 | "output_type": "stream", 188 | "text": [ 189 | "read 3187 molecules\n", 190 | "creating database\n" 191 | ] 192 | } 193 | ], 194 | "source": [ 195 | "UPGMAClassification=mainSeriesClassification.Classification(proj, datapath, dbpath, filename, chembl_library, \n", 196 | " flimit, MinClusterSize, clustering='UPGMA', \n", 197 | " calcDists=True, calcScores=False, useArthor=False)" 198 | ] 199 | }, 200 | { 201 | "cell_type": "code", 202 | "execution_count": 8, 203 | "metadata": { 204 | "scrolled": true 205 | }, 206 | "outputs": [ 207 | { 208 | "name": "stdout", 209 | "output_type": "stream", 210 | "text": [ 211 | "Time elapsed during the calculation: 1121.0\n" 212 | ] 213 | } 214 | ], 215 | "source": [ 216 | "#imp.reload(UPGMAclustering)\n", 217 | "#imp.reload(mainSeriesClassification)\n", 218 | "start=time.time()\n", 219 | "UPGMAClassification.ApplyClustering()\n", 220 | "end=time.time()\n", 221 | "print(f\"Time elapsed during the calculation: {end-start:.1f}\")" 222 | ] 223 | }, 224 | { 225 | "cell_type": "markdown", 226 | "metadata": {}, 227 | "source": [ 228 | "### Benchmark against human-defined classification (seriescolumn is the column with the human series assignment to each molecule in the dataframe moldata)" 229 | ] 230 | }, 231 | { 232 | "cell_type": "code", 233 | "execution_count": 9, 234 | "metadata": {}, 235 | "outputs": [], 236 | "source": [ 237 | "UPGMAClassification.CalculatePerformance(seriescolumn='series assignment')" 238 | ] 239 | }, 240 | { 241 | "cell_type": "code", 242 | "execution_count": 10, 243 | "metadata": {}, 244 | "outputs": [], 245 | "source": [ 246 | "moldata_proj=UPGMAClassification.moldata_proj\n", 247 | "ProjectClusters=UPGMAClassification.MCSdict\n", 248 | "PerformanceClusters=UPGMAClassification.PerformanceClusters" 249 | ] 250 | }, 251 | { 252 | "cell_type": "code", 253 | "execution_count": 11, 254 | "metadata": {}, 255 | "outputs": [ 256 | { 257 | "data": { 258 | "text/plain": [ 259 | "dict_keys([6347, 6149, 6317, 6319, 6016, 6181, 6230, 6147, 5970, 6313, 6316, 6168, 6277, 6104, 6020, 6198, 6105, 6151, 6067, 5996, 5740])" 260 | ] 261 | }, 262 | "execution_count": 11, 263 | "metadata": {}, 264 | "output_type": "execute_result" 265 | } 266 | ], 267 | "source": [ 268 | "UPGMAClassification.MCSdict.keys()" 269 | ] 270 | }, 271 | { 272 | "cell_type": "markdown", 273 | "metadata": {}, 274 | "source": [ 275 | "### Calculate performance metrics" 276 | ] 277 | }, 278 | { 279 | "cell_type": "code", 280 | "execution_count": 12, 281 | "metadata": { 282 | "scrolled": true 283 | }, 284 | "outputs": [], 285 | "source": [ 286 | "UPGMAClassification.CalculatePerformance()" 287 | ] 288 | }, 289 | { 290 | "cell_type": "code", 291 | "execution_count": 13, 292 | "metadata": {}, 293 | "outputs": [ 294 | { 295 | "name": "stdout", 296 | "output_type": "stream", 297 | "text": [ 298 | "fraction of assigned molecules: 0.8650768748038908 , ambiguity score: 1.1454479506710191\n" 299 | ] 300 | } 301 | ], 302 | "source": [ 303 | "Nmol=len(moldata_proj)\n", 304 | "Nrep=sum(moldata_proj['ClusterID'].map(lambda x: len(x)).tolist())\n", 305 | "Nunassigned=len(moldata_proj.loc[moldata_proj['ClusterID'].map(lambda x: len(x)==0)])\n", 306 | "frac_assigned=(Nmol-Nunassigned)/Nmol\n", 307 | "a=Nrep/(Nmol-Nunassigned)\n", 308 | "print('fraction of assigned molecules:',frac_assigned,', ambiguity score:',a)" 309 | ] 310 | }, 311 | { 312 | "cell_type": "markdown", 313 | "metadata": {}, 314 | "source": [ 315 | "### Plot benchmarking between automatically identified and human defined series" 316 | ] 317 | }, 318 | { 319 | "cell_type": "markdown", 320 | "metadata": {}, 321 | "source": [ 322 | "rearrange performance results" 323 | ] 324 | }, 325 | { 326 | "cell_type": "code", 327 | "execution_count": 37, 328 | "metadata": {}, 329 | "outputs": [], 330 | "source": [ 331 | "scaflist=list(set(moldata_proj['scaffold'].tolist()))\n", 332 | "scaflist.sort()\n", 333 | "N_auto_series=len(PerformanceClusters['recall'])\n", 334 | "LinkVector=PerformanceClusters['linked series']\n", 335 | "\n", 336 | "dict_recall={LinkVector[ind,0]:np.zeros(len(scaflist)) for ind in range(N_auto_series)}\n", 337 | "dict_prec={LinkVector[ind,0]:np.zeros(len(scaflist)) for ind in range(N_auto_series)}\n", 338 | "for ind in range(N_auto_series):\n", 339 | " scafind=np.where(np.array(scaflist)==LinkVector[ind,1])\n", 340 | " dict_recall[LinkVector[ind,0]][scafind]=PerformanceClusters['recall'][ind]\n", 341 | " dict_prec[LinkVector[ind,0]][scafind]=PerformanceClusters['precision'][ind]\n", 342 | " \n", 343 | "keylist=LinkVector[:,0].tolist()\n", 344 | "keylist.sort()\n", 345 | "dict_recall_sorted={k:dict_recall[k] for k in keylist}\n", 346 | "dict_prec_sorted={k:dict_prec[k] for k in keylist}" 347 | ] 348 | }, 349 | { 350 | "cell_type": "code", 351 | "execution_count": 39, 352 | "metadata": {}, 353 | "outputs": [ 354 | { 355 | "data": { 356 | "image/png": "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\n", 357 | "text/plain": [ 358 | "
" 359 | ] 360 | }, 361 | "metadata": { 362 | "needs_background": "light" 363 | }, 364 | "output_type": "display_data" 365 | } 366 | ], 367 | "source": [ 368 | "legend=['Series '+s[-2:] for s in scaflist]\n", 369 | "rcParams.update({'figure.autolayout': True})\n", 370 | "fig,ax=plt.subplots(2,1,figsize=(10,10))\n", 371 | "fig,_=utilsDrawing.barplot_vertical(fig, ax[0],dict_recall_sorted,'recall linked h. series',[],['']*len(keylist),1.02)\n", 372 | "fig,_=utilsDrawing.barplot_vertical(fig, ax[1],dict_prec_sorted,'precision linked h. series',legend,keylist,1.02)\n", 373 | "ax[1].set_xlabel('ID automatically-identified series',fontsize=22)\n", 374 | "plt.show()" 375 | ] 376 | }, 377 | { 378 | "cell_type": "markdown", 379 | "metadata": {}, 380 | "source": [ 381 | "### Draw MCS of automatically-identified series and linked human-defined series" 382 | ] 383 | }, 384 | { 385 | "cell_type": "code", 386 | "execution_count": 40, 387 | "metadata": { 388 | "scrolled": true 389 | }, 390 | "outputs": [], 391 | "source": [ 392 | "imp.reload(utilsDrawing)\n", 393 | "def renderMCS(seriesid,newscafslist,newscafsnames,linkedscafslist,linkedscafsnames):\n", 394 | " listid=np.where(np.array(newscafsnames)==seriesid)[0][0]\n", 395 | " svg_new=utilsDrawing.moltosvg(Chem.MolFromSmarts(newscafslist[listid]), molSize=(450,250))\n", 396 | " svg_linked=utilsDrawing.moltosvg(Chem.MolFromSmarts(linkedscafslist[listid]), molSize=(450,250))\n", 397 | " labels=[newscafsnames[listid],linkedscafsnames[listid]]\n", 398 | " svgGrid = utilsDrawing.SvgsToGrid([svg_new,svg_linked], labels=labels, svgsPerRow=2, molSize=(450,250))\n", 399 | " return(SVG(svgGrid))" 400 | ] 401 | }, 402 | { 403 | "cell_type": "code", 404 | "execution_count": 41, 405 | "metadata": {}, 406 | "outputs": [ 407 | { 408 | "data": { 409 | "text/plain": [ 410 | "'./CDK2Kinase/'" 411 | ] 412 | }, 413 | "execution_count": 41, 414 | "metadata": {}, 415 | "output_type": "execute_result" 416 | } 417 | ], 418 | "source": [ 419 | "datapath" 420 | ] 421 | }, 422 | { 423 | "cell_type": "code", 424 | "execution_count": 42, 425 | "metadata": {}, 426 | "outputs": [ 427 | { 428 | "data": { 429 | "application/vnd.jupyter.widget-view+json": { 430 | "model_id": "dd26780701c94c718c9fc3706742bb73", 431 | "version_major": 2, 432 | "version_minor": 0 433 | }, 434 | "text/plain": [ 435 | "interactive(children=(Dropdown(description='seriesid', options=('5740', '5970', '5996', '6016', '6020', '6067'…" 436 | ] 437 | }, 438 | "metadata": {}, 439 | "output_type": "display_data" 440 | } 441 | ], 442 | "source": [ 443 | "seriesdata_proj=pd.read_csv('{0}seriesdata.csv'.format(datapath))\n", 444 | "LinkVector_sorted=np.array([[x,y] for x,y in sorted(zip(LinkVector[:,0],LinkVector[:,1]))])\n", 445 | "linkedScafsList=[seriesdata_proj['MCSsampled'].loc[seriesdata_proj['ScafName']==x].iloc[0] for x in LinkVector_sorted[:,1]]\n", 446 | "linkedScafsNames=[x for x in LinkVector_sorted[:,1]]\n", 447 | "MCSlist=[ProjectClusters[int(k)][2] for k in keylist]\n", 448 | "\n", 449 | "interact(renderMCS, seriesid=keylist, newscafslist=fixed(MCSlist),newscafsnames=fixed(keylist),linkedscafslist=fixed(linkedScafsList),linkedscafsnames=fixed(linkedScafsNames));\n" 450 | ] 451 | } 452 | ], 453 | "metadata": { 454 | "kernelspec": { 455 | "display_name": "Python 3", 456 | "language": "python", 457 | "name": "python3" 458 | }, 459 | "language_info": { 460 | "codemirror_mode": { 461 | "name": "ipython", 462 | "version": 3 463 | }, 464 | "file_extension": ".py", 465 | "mimetype": "text/x-python", 466 | "name": "python", 467 | "nbconvert_exporter": "python", 468 | "pygments_lexer": "ipython3", 469 | "version": "3.8.10" 470 | } 471 | }, 472 | "nbformat": 4, 473 | "nbformat_minor": 2 474 | } 475 | -------------------------------------------------------------------------------- /UPGMA_classification.arthor.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "name": "stdout", 10 | "output_type": "stream", 11 | "text": [ 12 | "RDKit version: 2021.03.3\n", 13 | "Pandas version: 1.2.4\n", 14 | "Numpy version: 1.20.3\n", 15 | "MatplotLib version: 3.4.2\n", 16 | "Arthor version: 3.4\n", 17 | "Sklearn version: 0.24.2\n", 18 | "Seaborn version: 0.11.1\n" 19 | ] 20 | } 21 | ], 22 | "source": [ 23 | "import sys, os\n", 24 | "import pandas as pd\n", 25 | "import numpy as np\n", 26 | "import sklearn\n", 27 | "from rdkit import Chem, rdBase\n", 28 | "from rdkit.Chem import rdFMCS, Draw, PandasTools, AllChem, DataStructs, Descriptors\n", 29 | "from rdkit.Chem.Draw import IPythonConsole\n", 30 | "from IPython.display import SVG\n", 31 | "import arthor\n", 32 | "import matplotlib as mpl\n", 33 | "import matplotlib.pyplot as plt\n", 34 | "from matplotlib import rcParams\n", 35 | "from matplotlib.colors import hex2color\n", 36 | "import seaborn as sns\n", 37 | "import time\n", 38 | "\n", 39 | "print('RDKit version: ',rdBase.rdkitVersion)\n", 40 | "print('Pandas version:', pd.__version__)\n", 41 | "print('Numpy version:', np.__version__)\n", 42 | "print('MatplotLib version:', mpl.__version__)\n", 43 | "print('Arthor version:', arthor.__version__)\n", 44 | "print('Sklearn version:', sklearn.__version__)\n", 45 | "print('Seaborn version:', sns.__version__)" 46 | ] 47 | }, 48 | { 49 | "cell_type": "code", 50 | "execution_count": 2, 51 | "metadata": {}, 52 | "outputs": [ 53 | { 54 | "data": { 55 | "text/plain": [ 56 | "" 57 | ] 58 | }, 59 | "execution_count": 2, 60 | "metadata": {}, 61 | "output_type": "execute_result" 62 | } 63 | ], 64 | "source": [ 65 | "import imp\n", 66 | "import automated_series_classification\n", 67 | "imp.reload(automated_series_classification)\n", 68 | "from automated_series_classification import utilsDataPrep\n", 69 | "from automated_series_classification import mainSeriesClassification\n", 70 | "imp.reload(mainSeriesClassification)\n", 71 | "\n", 72 | "from automated_series_classification import utilsDrawing\n", 73 | "from automated_series_classification import UPGMAclustering\n", 74 | "imp.reload(UPGMAclustering)\n" 75 | ] 76 | }, 77 | { 78 | "cell_type": "markdown", 79 | "metadata": {}, 80 | "source": [ 81 | "Load ChEMBL database for substructure matching (constructed during data preprocessing)" 82 | ] 83 | }, 84 | { 85 | "cell_type": "code", 86 | "execution_count": 3, 87 | "metadata": {}, 88 | "outputs": [ 89 | { 90 | "name": "stdout", 91 | "output_type": "stream", 92 | "text": [ 93 | "1941410\n" 94 | ] 95 | } 96 | ], 97 | "source": [ 98 | "chembldb=arthor.SubDb('./arthor/chembl_27.atdb')\n", 99 | "Nchembl=len(chembldb.search('*'))\n", 100 | "print(Nchembl)" 101 | ] 102 | }, 103 | { 104 | "cell_type": "markdown", 105 | "metadata": {}, 106 | "source": [ 107 | "Define Parameters, note that flimit corresponds to the specificity limit E(p) as described in the paper" 108 | ] 109 | }, 110 | { 111 | "cell_type": "code", 112 | "execution_count": 4, 113 | "metadata": {}, 114 | "outputs": [], 115 | "source": [ 116 | "flimit=2e-3\n", 117 | "MinClusterSize=20\n", 118 | "proj='CDK2Kinase'\n", 119 | "filename='moldata_preprocessed.csv'\n", 120 | "arthorpath='./arthor/'\n", 121 | "datapath='./{0}/'.format(proj)" 122 | ] 123 | }, 124 | { 125 | "cell_type": "markdown", 126 | "metadata": {}, 127 | "source": [ 128 | "### UPGMA classification" 129 | ] 130 | }, 131 | { 132 | "cell_type": "markdown", 133 | "metadata": {}, 134 | "source": [ 135 | "Set \"calcDists\" to True only if the pairwise molecular distance matrix for clustering is not calculated yet (this will take a while). Set \"calcScores\" only if you are interested in the intra-cluster distance metric, this slows down the clustering." 136 | ] 137 | }, 138 | { 139 | "cell_type": "code", 140 | "execution_count": 5, 141 | "metadata": {}, 142 | "outputs": [ 143 | { 144 | "name": "stdout", 145 | "output_type": "stream", 146 | "text": [ 147 | "read 3187 molecules\n" 148 | ] 149 | } 150 | ], 151 | "source": [ 152 | "UPGMAClassification=mainSeriesClassification.Classification(proj, datapath, arthorpath, filename, chembldb, \n", 153 | " flimit, MinClusterSize, clustering='UPGMA', \n", 154 | " calcDists=True, calcScores=False)\n" 155 | ] 156 | }, 157 | { 158 | "cell_type": "code", 159 | "execution_count": 6, 160 | "metadata": {}, 161 | "outputs": [ 162 | { 163 | "name": "stdout", 164 | "output_type": "stream", 165 | "text": [ 166 | "Time elapsed during the calculation: 98.2\n" 167 | ] 168 | } 169 | ], 170 | "source": [ 171 | "start=time.time()\n", 172 | "UPGMAClassification.ApplyClustering()\n", 173 | "end=time.time()\n", 174 | "print(f\"Time elapsed during the calculation: {end-start:.1f}\") " 175 | ] 176 | }, 177 | { 178 | "cell_type": "markdown", 179 | "metadata": {}, 180 | "source": [ 181 | "Benchmark against human-defined classification (seriescolumn is the column with the human series assignment to each molecule in the dataframe moldata)" 182 | ] 183 | }, 184 | { 185 | "cell_type": "code", 186 | "execution_count": 7, 187 | "metadata": {}, 188 | "outputs": [], 189 | "source": [ 190 | "UPGMAClassification.CalculatePerformance(seriescolumn='series assignment')" 191 | ] 192 | }, 193 | { 194 | "cell_type": "code", 195 | "execution_count": 8, 196 | "metadata": {}, 197 | "outputs": [], 198 | "source": [ 199 | "moldata_proj=UPGMAClassification.moldata_proj\n", 200 | "ProjectClusters=UPGMAClassification.MCSdict\n", 201 | "PerformanceClusters=UPGMAClassification.PerformanceClusters" 202 | ] 203 | }, 204 | { 205 | "cell_type": "markdown", 206 | "metadata": {}, 207 | "source": [ 208 | "### Calculate performance metrics" 209 | ] 210 | }, 211 | { 212 | "cell_type": "code", 213 | "execution_count": 9, 214 | "metadata": {}, 215 | "outputs": [ 216 | { 217 | "name": "stdout", 218 | "output_type": "stream", 219 | "text": [ 220 | "fraction of assigned molecules: 0.8650768748038908 , ambiguity score: 1.1454479506710191\n" 221 | ] 222 | } 223 | ], 224 | "source": [ 225 | "Nmol=len(moldata_proj)\n", 226 | "Nrep=sum(moldata_proj['ClusterID'].map(lambda x: len(x)).tolist())\n", 227 | "Nunassigned=len(moldata_proj.loc[moldata_proj['ClusterID'].map(lambda x: len(x)==0)])\n", 228 | "frac_assigned=(Nmol-Nunassigned)/Nmol\n", 229 | "a=Nrep/(Nmol-Nunassigned)\n", 230 | "print('fraction of assigned molecules:',frac_assigned,', ambiguity score:',a)" 231 | ] 232 | }, 233 | { 234 | "cell_type": "markdown", 235 | "metadata": {}, 236 | "source": [ 237 | "### Plot benchmarking between automatically identified and human defined series" 238 | ] 239 | }, 240 | { 241 | "cell_type": "markdown", 242 | "metadata": {}, 243 | "source": [ 244 | "rearrange performance results" 245 | ] 246 | }, 247 | { 248 | "cell_type": "code", 249 | "execution_count": 10, 250 | "metadata": {}, 251 | "outputs": [], 252 | "source": [ 253 | "scaflist=list(set(moldata_proj['scaffold'].tolist()))\n", 254 | "scaflist.sort()\n", 255 | "N_auto_series=len(PerformanceClusters['recall'])\n", 256 | "LinkVector=PerformanceClusters['linked series']\n", 257 | "\n", 258 | "dict_recall={LinkVector[ind,0]:np.zeros(len(scaflist)) for ind in range(N_auto_series)}\n", 259 | "dict_prec={LinkVector[ind,0]:np.zeros(len(scaflist)) for ind in range(N_auto_series)}\n", 260 | "for ind in range(N_auto_series):\n", 261 | " scafind=np.where(np.array(scaflist)==LinkVector[ind,1])\n", 262 | " dict_recall[LinkVector[ind,0]][scafind]=PerformanceClusters['recall'][ind]\n", 263 | " dict_prec[LinkVector[ind,0]][scafind]=PerformanceClusters['precision'][ind]\n", 264 | " \n", 265 | "keylist=LinkVector[:,0].tolist()\n", 266 | "keylist.sort()\n", 267 | "dict_recall_sorted={k:dict_recall[k] for k in keylist}\n", 268 | "dict_prec_sorted={k:dict_prec[k] for k in keylist}" 269 | ] 270 | }, 271 | { 272 | "cell_type": "code", 273 | "execution_count": 11, 274 | "metadata": {}, 275 | "outputs": [ 276 | { 277 | "data": { 278 | "image/png": "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\n", 279 | "text/plain": [ 280 | "
" 281 | ] 282 | }, 283 | "metadata": { 284 | "needs_background": "light" 285 | }, 286 | "output_type": "display_data" 287 | } 288 | ], 289 | "source": [ 290 | "legend=['Series '+s[-2:] for s in scaflist]\n", 291 | "rcParams.update({'figure.autolayout': True})\n", 292 | "fig,ax=plt.subplots(2,1,figsize=(10,10))\n", 293 | "fig,_=utilsDrawing.barplot_vertical(fig, ax[0],dict_recall_sorted,'recall linked h. series',[],['']*len(keylist),1.02)\n", 294 | "fig,_=utilsDrawing.barplot_vertical(fig, ax[1],dict_prec_sorted,'precision linked h. series',legend,keylist,1.02)\n", 295 | "ax[1].set_xlabel('ID automatically-identified series',fontsize=22)\n", 296 | "plt.show()" 297 | ] 298 | }, 299 | { 300 | "cell_type": "markdown", 301 | "metadata": {}, 302 | "source": [ 303 | "### Draw MCS of automatically-identified series and linked human-defined series" 304 | ] 305 | }, 306 | { 307 | "cell_type": "code", 308 | "execution_count": 12, 309 | "metadata": { 310 | "scrolled": true 311 | }, 312 | "outputs": [], 313 | "source": [ 314 | "from ipywidgets import interact,fixed,IntSlider\n", 315 | "def renderMCS(seriesid,newscafslist,newscafsnames,linkedscafslist,linkedscafsnames):\n", 316 | " listid=np.where(np.array(newscafsnames)==seriesid)[0][0]\n", 317 | " svg_new=utilsDrawing.moltosvg(Chem.MolFromSmarts(newscafslist[listid]), molSize=(450,250))\n", 318 | " svg_linked=utilsDrawing.moltosvg(Chem.MolFromSmarts(linkedscafslist[listid]), molSize=(450,250))\n", 319 | " labels=[newscafsnames[listid],linkedscafsnames[listid]]\n", 320 | " svgGrid = utilsDrawing.SvgsToGrid([svg_new,svg_linked], labels=labels, svgsPerRow=2, molSize=(450,250))\n", 321 | " \n", 322 | " return(display(SVG(svgGrid)))" 323 | ] 324 | }, 325 | { 326 | "cell_type": "code", 327 | "execution_count": 13, 328 | "metadata": {}, 329 | "outputs": [ 330 | { 331 | "data": { 332 | "application/vnd.jupyter.widget-view+json": { 333 | "model_id": "8b770e6b46754dbc84bfc81ebb062aed", 334 | "version_major": 2, 335 | "version_minor": 0 336 | }, 337 | "text/plain": [ 338 | "interactive(children=(Dropdown(description='seriesid', options=('5740', '5970', '5996', '6016', '6020', '6067'…" 339 | ] 340 | }, 341 | "metadata": {}, 342 | "output_type": "display_data" 343 | } 344 | ], 345 | "source": [ 346 | "seriesdata_proj=pd.read_csv('{0}seriesdata.csv'.format(datapath))\n", 347 | "LinkVector_sorted=np.array([[x,y] for x,y in sorted(zip(LinkVector[:,0],LinkVector[:,1]))])\n", 348 | "linkedScafsList=[seriesdata_proj['MCSsampled'].loc[seriesdata_proj['ScafName']==x].iloc[0] for x in LinkVector_sorted[:,1]]\n", 349 | "linkedScafsNames=[x for x in LinkVector_sorted[:,1]]\n", 350 | "MCSlist=[ProjectClusters[int(k)][2] for k in keylist]\n", 351 | "\n", 352 | "interact(renderMCS, seriesid=keylist, newscafslist=fixed(MCSlist),newscafsnames=fixed(keylist),linkedscafslist=fixed(linkedScafsList),linkedscafsnames=fixed(linkedScafsNames));\n" 353 | ] 354 | }, 355 | { 356 | "cell_type": "markdown", 357 | "metadata": {}, 358 | "source": [ 359 | "### 10fold cross-validation by sampling 40% of all compounds" 360 | ] 361 | }, 362 | { 363 | "cell_type": "code", 364 | "execution_count": 14, 365 | "metadata": {}, 366 | "outputs": [ 367 | { 368 | "name": "stdout", 369 | "output_type": "stream", 370 | "text": [ 371 | "Time elapsed during the calculation: 492.38566040992737\n" 372 | ] 373 | } 374 | ], 375 | "source": [ 376 | "fraction_sample=0.4\n", 377 | "N_sample=10\n", 378 | "start=time.time()\n", 379 | "UPGMAClassification.ClassificationCrossValidation(fraction_sample, N_sample)\n", 380 | "end=time.time()\n", 381 | "print(\"Time elapsed during the calculation:\", end - start) " 382 | ] 383 | }, 384 | { 385 | "cell_type": "code", 386 | "execution_count": 15, 387 | "metadata": {}, 388 | "outputs": [], 389 | "source": [ 390 | "UPGMAClassification.EvaluationCrossValidation()" 391 | ] 392 | }, 393 | { 394 | "cell_type": "code", 395 | "execution_count": 16, 396 | "metadata": {}, 397 | "outputs": [ 398 | { 399 | "data": { 400 | "image/png": "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\n", 401 | "text/plain": [ 402 | "
" 403 | ] 404 | }, 405 | "metadata": { 406 | "needs_background": "light" 407 | }, 408 | "output_type": "display_data" 409 | } 410 | ], 411 | "source": [ 412 | "rcParams.update({'figure.autolayout': True})\n", 413 | "fig,ax=plt.subplots(1,1,figsize=(12,8))\n", 414 | "ax = sns.boxplot(x=\"series id\", y=\"fscore\", data=UPGMAClassification.EvalCrossval, color=[0.5,0.6,1.0],ax=ax)\n", 415 | "ax.set_ylabel('F$_1$ score',fontsize=26)\n", 416 | "ax.set_xlabel('series ID',fontsize=26)\n", 417 | "\n", 418 | "plt.setp(ax.get_xticklabels(), fontsize=22, rotation='vertical')\n", 419 | "plt.setp(ax.get_yticklabels(), fontsize=22)\n", 420 | "plt.show()" 421 | ] 422 | }, 423 | { 424 | "cell_type": "code", 425 | "execution_count": null, 426 | "metadata": {}, 427 | "outputs": [], 428 | "source": [] 429 | } 430 | ], 431 | "metadata": { 432 | "kernelspec": { 433 | "display_name": "Python 3", 434 | "language": "python", 435 | "name": "python3" 436 | }, 437 | "language_info": { 438 | "codemirror_mode": { 439 | "name": "ipython", 440 | "version": 3 441 | }, 442 | "file_extension": ".py", 443 | "mimetype": "text/x-python", 444 | "name": "python", 445 | "nbconvert_exporter": "python", 446 | "pygments_lexer": "ipython3", 447 | "version": "3.8.10" 448 | } 449 | }, 450 | "nbformat": 4, 451 | "nbformat_minor": 2 452 | } 453 | -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | rdkit 2 | seaborn 3 | xlrd 4 | -------------------------------------------------------------------------------- /setup.cfg: -------------------------------------------------------------------------------- 1 | ########################## 2 | # Setup.py Configuration # 3 | ########################## 4 | [metadata] 5 | name = automated_series_classification 6 | version = 0.0.1 7 | long_description = file: README.rst 8 | 9 | # URLs associated with the project 10 | url = https://github.com/iwatobipen/AutomatedSeriesClassification 11 | download_url = https://github.com/iwatobipen/AutomatedSeriesClassification/releases 12 | project_urls = 13 | Bug Tracker = https://github.com/iwatobipen/AutomatedSeriesClassification/issues 14 | Source Code = https://github.com/iwatobipen/AutomatedSeriesClassification 15 | 16 | # Author information 17 | author = iwatobipen 18 | # author_email = ... 19 | maintainer = iwatobipen 20 | # maintainer_email = ... 21 | 22 | # License Information 23 | license = MIT 24 | license_file = LICENSE 25 | 26 | [options] 27 | # Requirements (formerly known as requirements.txt) 28 | install_requires = 29 | numpy 30 | pandas 31 | sklearn 32 | matplotlib 33 | wget 34 | tqdm 35 | click 36 | # Since RDKit can't be installed through pip, don't put it here 37 | 38 | # Where is my code (Part 1/3) 39 | packages = find: 40 | # Where is my code (Part 2/3) 41 | package_dir = 42 | = src 43 | 44 | [options.packages.find] 45 | # Where is my code (Part 3/3) 46 | where = src 47 | -------------------------------------------------------------------------------- /setup.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | 3 | """Setup module.""" 4 | 5 | import setuptools 6 | 7 | if __name__ == '__main__': 8 | setuptools.setup() 9 | -------------------------------------------------------------------------------- /src/automated_series_classification/Butinaclustering.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # -*- coding: utf-8 -*- 3 | """ 4 | Created on Tue Jan 28 14:14:10 2020 5 | 6 | @author: krugefr1 7 | """ 8 | 9 | import numpy as np 10 | from automated_series_classification import utilsStructureEval 11 | 12 | def ApplyButina(distdata, moldata, chembldb, flimit, MinClusterSize,calcScores): 13 | MCSdict={} 14 | # sort assaydata ascending (i.e., lowest value is most active -> preprocess data accordingly) 15 | # indices: list in which molecules are selected as cluster centers 16 | assaydata=np.array(moldata['assay'].tolist()) 17 | indices=np.argsort(assaydata) 18 | Nchembl=len(chembldb.search('*')) 19 | 20 | while len(indices)>0: 21 | # assign all molecules to cluster center that comply with distthresh 22 | # distthresh is adjusted iteratively until MCS complies with specificity threshold flimit 23 | distthresh=0.8 24 | cluster=np.where(distdata[indices[0],:]=MinClusterSize: 26 | fChembl,Smarts=utilsStructureEval.MCSFromMollist(moldata.Molecule.iloc[cluster].tolist(),chembldb,Nchembl) 27 | step=0.1 28 | cluster_upper=cluster 29 | if fChembl>=flimit and len(cluster_upper)>MinClusterSize: 30 | while fChembl>=flimit: 31 | fChembl_upper=fChembl 32 | cluster_upper=cluster 33 | distupper=distthresh 34 | distthresh-=step 35 | cluster=np.where(distdata[indices[0],:]1: 37 | fChembl,Smarts=utilsStructureEval.MCSFromMollist(moldata.Molecule.iloc[cluster].tolist(),chembldb,Nchembl) 38 | else: break 39 | distlower=distthresh 40 | fChembl_lower=fChembl 41 | fChembl_lower_old=0 42 | while ((fChembl_lower-fChembl_lower_old)>1e-8) and (len(cluster_upper)>=MinClusterSize): 43 | distthresh=(distupper+distlower)/2 44 | cluster=np.where(distdata[indices[0],:]1: 46 | fChembl,Smarts=utilsStructureEval.MCSFromMollist(moldata.Molecule.iloc[cluster].tolist(),chembldb,Nchembl) 47 | else: break 48 | if fChembl>=flimit: 49 | fChembl_upper=fChembl 50 | distupper=distthresh 51 | cluster_upper=cluster 52 | else: 53 | fChembl_lower_old=fChembl_lower 54 | fChembl_lower=fChembl 55 | distlower=distthresh 56 | 57 | # select cluster/MCS if compliant with flimit and MinClusterSize 58 | if fChembl=MinClusterSize: 59 | if calcScores: 60 | MCSdict[indices[0]]=(fChembl,len(cluster),Smarts,distthresh) 61 | else: 62 | MCSdict[indices[0]]=(fChembl,len(cluster),Smarts) 63 | # remove molecules that were assigned to cluster (also incompliant, i.e. too small clusters) 64 | indices=np.array([x for x in indices if x not in cluster]) 65 | distdata[cluster,:]=1 66 | distdata[:,cluster]=1 67 | return MCSdict -------------------------------------------------------------------------------- /src/automated_series_classification/UPGMAclustering.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # -*- coding: utf-8 -*- 3 | """ 4 | Created on Mon Jan 27 16:07:23 2020 5 | 6 | @author: krugefr1 7 | """ 8 | import numpy as np 9 | import sklearn 10 | from sklearn.cluster import AgglomerativeClustering 11 | from automated_series_classification import utilsStructureEval 12 | try: 13 | import arthor 14 | except ImportError: 15 | arthor = None 16 | 17 | def CalcSizeAndAssignment(children,Ndata): 18 | # Assigns molecules to the clusters of the UPGMA tree 19 | NumMolList=[] 20 | MolDict={} 21 | for i in range(len(children)): 22 | N=0 23 | mols_assigned=[] 24 | for j in range(len(children[i])): 25 | if children[i][j]0: 70 | childlayer=[] 71 | for c in currlayer: 72 | if c>=Ndata: 73 | if len(MolDict[c])>=MinClusterSize: 74 | fChembl,Smarts=utilsStructureEval.MCSFromMollist(moldata.Molecule.iloc[MolDict[c]].tolist(),chembldb,Nchembl,onlyCompleteRings=onlyCompleteRings) 75 | if fChembl>=flimit: 76 | childlayer+=children[c-Ndata].tolist() 77 | else: 78 | if calcScores: 79 | MCSdict[c]=(fChembl,len(MolDict[c]),Smarts,ScoreDict[c]) 80 | else: 81 | MCSdict[c]=(fChembl,len(MolDict[c]),Smarts) 82 | currlayer=childlayer 83 | return MCSdict 84 | 85 | def ApplyUPGMA(distdata_proj,moldata_proj,chembldb, flimit, MinClusterSize, calcScores, 86 | onlyCompleteRings=False, useArthor=True): 87 | global arthor 88 | if not useArthor: 89 | arthor = None 90 | utilsStructureEval.arthor = None 91 | # Apply UPGMA clustering 92 | cluster=AgglomerativeClustering(n_clusters=2, compute_full_tree=True, affinity='precomputed',linkage='average') 93 | cluster.fit(distdata_proj) 94 | 95 | # Assign Clusters 96 | NumMolList, MolDict= CalcSizeAndAssignment(cluster.children_,len(distdata_proj)) 97 | # Calculate intra-cluster distance scores 98 | if calcScores: 99 | ScoreDict=CalcScore(cluster.children_,distdata_proj,NumMolList) 100 | else: 101 | ScoreDict={} 102 | 103 | # filter out irrelevant clusters and calculate MCS on selected clusters 104 | MCSdict=DetermineRelevantMCS(len(distdata_proj),cluster.children_,MolDict,ScoreDict,chembldb,moldata_proj,flimit,MinClusterSize, calcScores, onlyCompleteRings=onlyCompleteRings) 105 | 106 | return MCSdict 107 | 108 | 109 | -------------------------------------------------------------------------------- /src/automated_series_classification/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rdkit/AutomatedSeriesClassification/a0be9997fbfd4a6708fddd136e27b7b373dcd57f/src/automated_series_classification/__init__.py -------------------------------------------------------------------------------- /src/automated_series_classification/dataprep.py: -------------------------------------------------------------------------------- 1 | import gzip 2 | import os 3 | import pickle 4 | 5 | import click 6 | import wget 7 | from rdkit import Chem, RDLogger, rdBase 8 | from rdkit.Chem import rdSubstructLibrary 9 | from tqdm import tqdm 10 | 11 | RDLogger.DisableLog("rdApp.warning") 12 | 13 | # See https://pubs.acs.org/doi/10.1021/jm020472j 14 | bradley_url = 'https://pubs.acs.org/doi/suppl/10.1021/jm020472j/suppl_file/jm020472j_s2.xls' 15 | 16 | 17 | @click.command() 18 | @click.option( 19 | '--directory', type=click.Path(file_okay=False, dir_okay=True), 20 | default=os.getcwd, help='Defaults to current directory', 21 | ) 22 | @click.option('--chebml-version', default='27', show_default=True) 23 | def main(directory: str, chebml_version: str): 24 | """Download the ChEBML data.""" 25 | os.makedirs(directory, exist_ok=True) 26 | 27 | bradley_path = os.path.join(directory, 'jm020472j_s2.xls') 28 | if not os.path.exists(bradley_path): 29 | try: 30 | wget.download(bradley_url, out=directory) 31 | except: 32 | click.echo('There goes ACS stopping science') 33 | 34 | chembl_url = ( 35 | f'ftp://ftp.ebi.ac.uk/pub/databases/chembl/ChEMBLdb/releases/' 36 | f'chembl_{chebml_version}/chembl_{chebml_version}.sdf.gz' 37 | ) 38 | 39 | sdf_path = os.path.join(directory, f'chembl_{chebml_version}.sdf.gz') 40 | if not os.path.exists(sdf_path): 41 | wget.download(chembl_url, out=directory) 42 | 43 | sss_path = os.path.join(directory, f'chembl{chebml_version}_sssdata.pkl') 44 | if not os.path.exists(sss_path): 45 | click.echo(f'RDKit Version: {rdBase.rdkitVersion}') 46 | data = [] 47 | 48 | with gzip.GzipFile(sdf_path) as gz: 49 | suppl = Chem.ForwardSDMolSupplier(gz) 50 | for mol in tqdm(suppl, desc=f'Processing ChEBML {chebml_version}', unit_scale=True): 51 | if mol is None or mol.GetNumAtoms() > 50: 52 | continue 53 | fp = Chem.PatternFingerprint(mol) 54 | smi = Chem.MolToSmiles(mol) 55 | data.append((smi, fp)) 56 | 57 | click.echo(f'Outputting to {sss_path}') 58 | with open(sss_path, 'wb') as file: 59 | mols = rdSubstructLibrary.CachedTrustedSmilesMolHolder() 60 | fps = rdSubstructLibrary.PatternHolder() 61 | for smi,fp in data: 62 | mols.AddSmiles(smi) 63 | fps.AddFingerprint(fp) 64 | library = rdSubstructLibrary.SubstructLibrary(mols,fps) 65 | pickle.dump(library, file, protocol=pickle.HIGHEST_PROTOCOL) 66 | 67 | click.echo('Done ;)') 68 | 69 | 70 | if __name__ == '__main__': 71 | main() 72 | -------------------------------------------------------------------------------- /src/automated_series_classification/mainSeriesClassification.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # -*- coding: utf-8 -*- 3 | """ 4 | Created on Mon Jan 27 16:40:49 2020 5 | 6 | @author: krugefr1 7 | """ 8 | 9 | import numpy as np 10 | import os 11 | try: 12 | import arthor 13 | except ImportError: 14 | arthor = None 15 | from rdkit import Chem 16 | from rdkit.Chem import rdSubstructLibrary 17 | import pickle 18 | import random 19 | import pandas as pd 20 | import copy 21 | 22 | from automated_series_classification import UPGMAclustering, Butinaclustering, utilsDataPrep 23 | 24 | 25 | class Classification: 26 | def __init__(self, 27 | proj, 28 | datapath, 29 | dbpath, 30 | filename, 31 | chembldb, 32 | flimit=1e-3, 33 | MinClusterSize=20, 34 | clustering='UPGMA', 35 | calcDists=True, 36 | calcScores=False, 37 | smilesCol='Smiles', 38 | idCol='ID', 39 | onlyCompleteRings=False, 40 | useArthor=True): 41 | global arthor 42 | if not useArthor: 43 | arthor = None 44 | self.useArthor = useArthor 45 | self.proj = proj 46 | self.datapath = datapath 47 | self.dbpath = dbpath 48 | self.chembldb = chembldb 49 | self.flimit = flimit 50 | self.MinClusterSize = MinClusterSize 51 | self.clustering = clustering 52 | self.calcScores = calcScores 53 | self.calcDists = calcDists 54 | self.smilesCol = smilesCol 55 | self.idCol = idCol 56 | self.onlyCompleteRings = onlyCompleteRings 57 | # load data 58 | self.moldata_proj, self.distdata_proj = utilsDataPrep.PrepareData( 59 | self.proj, 60 | self.datapath, 61 | filename, 62 | distMeasure='Tanimoto', 63 | FP='Morgan2', 64 | calcDists=self.calcDists, 65 | smilesCol=smilesCol) 66 | if arthor is not None: 67 | if not os.path.isdir(dbpath): 68 | os.mkdir(dbpath) 69 | # set up project database for arthor substructure matching 70 | df = self.moldata_proj[[smilesCol, idCol]] 71 | df.to_csv('./arthor/{0}.smi'.format(self.proj), 72 | header=None, 73 | index=None, 74 | sep=' ') 75 | os.system('smi2atdb -j 0 -l {0}{1}.smi {0}{1}.atdb'.format( 76 | self.dbpath, self.proj)) 77 | os.system('atdb2fp -j 0 {0}{1}.atdb'.format( 78 | self.dbpath, self.proj)) 79 | self.proj_db = arthor.SubDb('{0}{1}.atdb'.format( 80 | self.dbpath, self.proj)) 81 | else: 82 | if type(dbpath) == rdSubstructLibrary.SubstructLibrary: 83 | self.proj_db = dbpath 84 | self.db_size = len(self.proj_db) 85 | else: 86 | if not os.path.exists(dbpath): 87 | print("creating database") 88 | mols = rdSubstructLibrary.CachedTrustedSmilesMolHolder() 89 | fps = rdSubstructLibrary.PatternHolder() 90 | for smi in self.moldata_proj[smilesCol]: 91 | m = Chem.MolFromSmiles(smi) 92 | mols.AddSmiles(Chem.MolToSmiles(m)) 93 | fps.AddFingerprint(Chem.PatternFingerprint(m)) 94 | self.proj_db = rdSubstructLibrary.SubstructLibrary( 95 | mols, fps) 96 | self.db_size = len(mols) 97 | pickle.dump(self.proj_db, open(dbpath, 'wb+')) 98 | else: 99 | self.proj_db = pickle.load(open(dbpath, 'rb')) 100 | self.db_size = len(self.proj_db) 101 | 102 | def AssignSeriesToMCS(self, MCSdict): 103 | # assign series to MCS of selected clusters 104 | smartslist = [v[2] for v in MCSdict.values()] 105 | MolAssign_prel = {} 106 | MolAssignment = {} 107 | for s in range(len(smartslist)): 108 | if arthor is not None: 109 | res = self.proj_db.search(smartslist[s]) 110 | mols = [int(i) for i in res.to_array()] 111 | else: 112 | mols = self.proj_db.GetMatches(Chem.MolFromSmarts( 113 | smartslist[s]), 114 | maxResults=self.db_size) 115 | MolAssign_prel[list(MCSdict.keys())[s]] = list(mols) 116 | 117 | # remove all series that are entirely in another series 118 | for key1 in MolAssign_prel.keys(): 119 | add = 1 120 | for key2 in MolAssign_prel.keys(): 121 | if key2 != key1: 122 | if set(MolAssign_prel[key1]).issubset( 123 | set(MolAssign_prel[key2])): 124 | if set(MolAssign_prel[key2]).issubset( 125 | set(MolAssign_prel[key1])) and ( 126 | MCSdict[key1][0] >= MCSdict[key2][0]): 127 | add = 1 128 | else: 129 | add = 0 130 | break 131 | if add == 1 and MolAssign_prel[key1] not in MolAssignment.values(): 132 | MolAssignment[key1] = MolAssign_prel[key1] 133 | 134 | MolAssignment = { 135 | k: MolAssignment[k] 136 | for k in MolAssignment.keys() 137 | if len(MolAssignment[k]) > self.MinClusterSize 138 | } 139 | if self.calcScores: 140 | MCSdict = { 141 | k: (MCSdict[k][0], len(MolAssignment[k]), MCSdict[k][2], 142 | MCSdict[k][3], MolAssignment[k]) 143 | for k in MolAssignment.keys() 144 | } 145 | else: 146 | MCSdict = { 147 | k: (MCSdict[k][0], len(MolAssignment[k]), MCSdict[k][2], 148 | MolAssignment[k]) 149 | for k in MolAssignment.keys() 150 | } 151 | return MolAssignment, MCSdict 152 | 153 | def ApplyClustering(self): 154 | # apply custering and calculate MCS 155 | if self.clustering == 'UPGMA': 156 | MCSdict = UPGMAclustering.ApplyUPGMA( 157 | self.distdata_proj, 158 | self.moldata_proj, 159 | self.chembldb, 160 | self.flimit, 161 | self.MinClusterSize, 162 | self.calcScores, 163 | onlyCompleteRings=self.onlyCompleteRings, 164 | useArthor=self.useArthor) 165 | elif self.clustering == 'Butina': 166 | distdata = copy.deepcopy(self.distdata_proj) 167 | MCSdict = Butinaclustering.ApplyButina(distdata, 168 | self.moldata_proj, 169 | self.chembldb, 170 | self.flimit, 171 | self.MinClusterSize, 172 | self.calcScores, 173 | useArthor=self.useArthor) 174 | else: 175 | print('Clustering algorithm not implemented.') 176 | return 177 | 178 | # assign series through substructure matching and filtering 179 | self.MolAssignment, self.MCSdict = self.AssignSeriesToMCS(MCSdict) 180 | 181 | # prepare and save output 182 | self.moldata_proj['ClusterID'] = [ 183 | list() for x in range(self.moldata_proj.shape[0]) 184 | ] 185 | 186 | for k, vs in self.MolAssignment.items(): 187 | for v in vs: 188 | self.moldata_proj['ClusterID'].iloc[v].append(k) 189 | if self.clustering == 'UPGMA': 190 | self.moldata_proj.to_csv('{0}moldata_UPGMA.csv'.format( 191 | self.datapath)) 192 | with open('{0}ClusterData_UPGMA.pkl'.format(self.datapath), 193 | 'wb') as fileout: 194 | pickle.dump(self.MCSdict, fileout) 195 | elif self.clustering == 'Butina': 196 | self.moldata_proj.to_csv('{0}moldata_Butina.csv'.format( 197 | self.datapath)) 198 | with open('{0}ClusterData_Butina.pkl'.format(self.datapath), 199 | 'wb') as fileout: 200 | pickle.dump(self.MCSdict, fileout) 201 | else: 202 | print('Clustering algorithm not implemented.') 203 | return 204 | 205 | def CalculatePerformance(self, seriescolumn='series assignment'): 206 | 207 | # benchmark the automated classification against a different (probably human-defined) classification 208 | # human-defined compound assignment is specified in the column "seriescolumn" of the dataframe "moldata" 209 | # automated classification assignment specified in dict "MolAssignment" 210 | 211 | # calculates F1 score of automatically-identified series w.r.t. to all human-defined series, then links 212 | # each automatically-identified series to the human-defined series with highest F1 score 213 | 214 | scaflist = list(set(self.moldata_proj['scaffold'].tolist())) 215 | scaflist.sort() 216 | 217 | intersect_matrix = np.zeros((len(scaflist), len(self.MolAssignment))) 218 | NMatchScaf = [] 219 | NMatchCluster = np.array([len(v) for v in self.MolAssignment.values()]) 220 | for scaf_ind in range(len(scaflist)): 221 | mollist = self.moldata_proj[self.idCol].loc[self.moldata_proj[ 222 | seriescolumn].map(lambda x: scaflist[scaf_ind] in x)].tolist() 223 | intersect_scaf = np.array([ 224 | len(list(set(mollist) & set(clusterlist))) 225 | for clusterlist in self.MolAssignment.values() 226 | ]) 227 | intersect_matrix[scaf_ind, :] = intersect_scaf 228 | NMatchScaf.append(len(mollist)) 229 | 230 | NMatchScaf = np.array(NMatchScaf) 231 | RecallMatrix = intersect_matrix / NMatchScaf[:, None] 232 | PrecMatrix = intersect_matrix / NMatchCluster[None, :] 233 | Fscore = (2 * RecallMatrix * PrecMatrix) / (RecallMatrix + PrecMatrix + 234 | 1e-9) 235 | maxscore = np.argmax(Fscore, axis=0) 236 | 237 | PrecVector = np.zeros(len(self.MolAssignment)) 238 | RecallVector = np.zeros(len(self.MolAssignment)) 239 | FscoreVector = np.zeros(len(self.MolAssignment)) 240 | LinkVector = [] 241 | 242 | for col in range(len(self.MolAssignment)): 243 | PrecVector[col] = PrecMatrix[maxscore[col], col] 244 | RecallVector[col] = RecallMatrix[maxscore[col], col] 245 | FscoreVector[col] = Fscore[maxscore[col], col] 246 | LinkVector.append((list(self.MolAssignment.keys())[col], 247 | scaflist[maxscore[col]])) 248 | 249 | LinkVector = np.array(LinkVector) 250 | self.PerformanceClusters = { 251 | 'recall': RecallVector, 252 | 'precision': PrecVector, 253 | 'Fscore': FscoreVector, 254 | 'linked series': LinkVector 255 | } 256 | 257 | if self.clustering == 'UPGMA': 258 | with open('{0}PerformanceData_UPGMA.pkl'.format(self.datapath), 259 | 'wb') as fileout: 260 | pickle.dump(self.PerformanceClusters, fileout) 261 | elif self.clustering == 'Butina': 262 | with open('{0}PerformanceData_Butina.pkl'.format(self.datapath), 263 | 'wb') as fileout: 264 | pickle.dump(self.PerformanceClusters, fileout) 265 | else: 266 | print('Clustering algorithm not implemented.') 267 | return 268 | 269 | def ClassificationCrossValidation(self, fraction_sample, N_sample): 270 | samplerange = np.arange(len(self.moldata_proj)) 271 | invfrac = 1 / fraction_sample 272 | self.SampledSeries = {} 273 | for i in range(N_sample): 274 | 275 | # random sampling 276 | random.seed((i + 1) * 10) 277 | molinds = random.sample(population=samplerange.tolist(), 278 | k=int( 279 | len(samplerange.tolist()) // invfrac)) 280 | moldata_sample = self.moldata_proj.iloc[molinds] 281 | distdata_sample = self.distdata_proj[molinds, :] 282 | distdata_sample = distdata_sample[:, molinds] 283 | 284 | # apply custering and calculate MCS 285 | if self.clustering == 'UPGMA': 286 | MCSdict_sampled = UPGMAclustering.ApplyUPGMA( 287 | distdata_sample, 288 | moldata_sample, 289 | self.chembldb, 290 | self.flimit, 291 | self.MinClusterSize, 292 | self.calcScores, 293 | useArthor=self.useArthor) 294 | elif self.clustering == 'Butina': 295 | MCSdict_sampled = Butinaclustering.ApplyButina( 296 | distdata_sample, 297 | moldata_sample, 298 | self.chembldb, 299 | self.flimit, 300 | self.MinClusterSize, 301 | self.calcScores, 302 | useArthor=self.useArthor) 303 | else: 304 | print('Clustering algorithm not implemented.') 305 | return 306 | 307 | # assign series through substructure matching and filtering 308 | MolAssignment_sampled, MCSdict_sampled = self.AssignSeriesToMCS( 309 | MCSdict_sampled) 310 | self.SampledSeries[i] = MCSdict_sampled 311 | 312 | if self.clustering == 'UPGMA': 313 | with open( 314 | '{0}SampledSeries{1}_UPGMA.pkl'.format( 315 | self.datapath, int(fraction_sample * 100)), 316 | 'wb') as fileout: 317 | pickle.dump(self.SampledSeries, fileout) 318 | elif self.clustering == 'Butina': 319 | with open( 320 | '{0}SampledSeries{1}_Butina.pkl'.format( 321 | self.datapath, int(fraction_sample * 100)), 322 | 'wb') as fileout: 323 | pickle.dump(self.SampledSeries, fileout) 324 | else: 325 | print('Clustering algorithm not implemented.') 326 | return 327 | 328 | return 329 | 330 | def EvaluationCrossValidation(self): 331 | # Compare the classification obtained from sampling ("SampledSeries") against the original classification ("MCSdict") 332 | self.EvalCrossval = pd.DataFrame( 333 | columns=['series id', 'repetition', 'fscore']) 334 | for rep in self.SampledSeries.keys(): 335 | rep_dict = self.SampledSeries[rep] 336 | keylist = [k for k in rep_dict.keys()] 337 | for k in self.MCSdict.keys(): 338 | intersect = [ 339 | len(set(self.MCSdict[k][-1]) & set(v[-1])) 340 | for v in rep_dict.values() 341 | ] 342 | recall = np.array([ 343 | intersect[i] / len(rep_dict[keylist[i]][-1]) 344 | for i in range(len(keylist)) 345 | ]) 346 | precision = np.array(intersect) / len(self.MCSdict[k][-1]) 347 | fscore = max(2 * recall * precision / 348 | (recall + precision + 1e-9)) 349 | row = [int(k), int(rep), fscore] 350 | self.EvalCrossval.loc[len(self.EvalCrossval)] = row 351 | self.EvalCrossval['series id'] = self.EvalCrossval['series id'].apply( 352 | int) 353 | -------------------------------------------------------------------------------- /src/automated_series_classification/utilsDataPrep.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # -*- coding: utf-8 -*- 3 | """ 4 | Created on Mon Jan 27 14:51:39 2020 5 | 6 | @author: krugefr1 7 | """ 8 | 9 | from rdkit import Chem 10 | from rdkit.Chem import AllChem, PandasTools, DataStructs 11 | import pickle 12 | import pandas as pd 13 | import numpy as np 14 | 15 | def calcDistMatrix(df, distMeasure): 16 | # calculates the distance matrix between all paris of molecules, standard: Tanimoto and Morgan2 FPs 17 | dists=np.zeros([len(df),len(df)]) 18 | if distMeasure=='Tanimoto': 19 | for i in range(1,len(df)): 20 | ds = DataStructs.BulkTanimotoSimilarity(df.FP.iloc[i],list(df.FP.iloc[:i]),returnDistance=1) 21 | for j in range(i): 22 | dists[i,j] = ds[j] 23 | dists[j,i] = ds[j] 24 | else: 25 | print(distMeasure, 'distance metric not implemented.') 26 | return 27 | return dists 28 | 29 | def readProjectData(filename, FP, smilesCol): 30 | # reads in the project data and calculates fingerprints 31 | df_proj=pd.read_csv(filename)#,names=['ID','Structure','mol name','scaffold','series assignment','assay'], skiprows=[0]) 32 | #df_proj = df_proj.head(100) 33 | PandasTools.AddMoleculeColumnToFrame(df_proj,smilesCol=smilesCol,molCol='Molecule') 34 | df_proj=df_proj.loc[df_proj['Molecule'].map(lambda x: x is not None)] 35 | if FP=='Morgan2': 36 | df_proj['FP']=df_proj.Molecule.map(lambda x : AllChem.GetMorganFingerprint(x,2)) 37 | else: 38 | print(FP, ' fingerprint not implemented.') 39 | return 40 | return df_proj 41 | 42 | 43 | def PrepareData(proj,datapath,filename,distMeasure='Tanimoto',FP='Morgan2', calcDists=False, smilesCol='Smiles'): 44 | # reads in project data and distance matrix (or calculate distance matrix) 45 | filename='{0}{1}'.format(datapath,filename) 46 | moldata=readProjectData(filename, FP, smilesCol) 47 | print(f'read {len(moldata)} molecules') 48 | if calcDists: 49 | dists=calcDistMatrix(moldata, distMeasure) 50 | with open('{0}distmatrix.txt'.format(datapath), 'wb') as fileout: 51 | pickle.dump(dists,fileout) 52 | else: 53 | with open('{0}distmatrix.txt'.format(datapath), 'rb') as filein: 54 | dists=pickle.load(filein) 55 | 56 | return moldata, dists 57 | 58 | -------------------------------------------------------------------------------- /src/automated_series_classification/utilsDrawing.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # -*- coding: utf-8 -*- 3 | """ 4 | Created on Mon Jan 27 19:10:21 2020 5 | 6 | @author: krugefr1 7 | """ 8 | 9 | from rdkit.Chem import rdDepictor 10 | from rdkit.Chem.Draw import rdMolDraw2D 11 | from rdkit import Chem 12 | import numpy as np 13 | import matplotlib.pyplot as plt 14 | import re 15 | 16 | def moltosvg(mol,molSize=(450,250),kekulize=True): 17 | mc = Chem.Mol(mol.ToBinary()) 18 | if kekulize: 19 | try: 20 | Chem.Kekulize(mc) 21 | except: 22 | mc = Chem.Mol(mol.ToBinary()) 23 | if not mc.GetNumConformers(): 24 | rdDepictor.Compute2DCoords(mc) 25 | drawer = rdMolDraw2D.MolDraw2DSVG(molSize[0],molSize[1]) 26 | # the MolDraw2D code is not very good at the moment at dealing with atom queries, 27 | # this is a workaround until that's fixed. 28 | # The rendering is still not going to be perfect because query bonds are not properly indicated 29 | opts = drawer.drawOptions() 30 | for atom in mc.GetAtoms(): 31 | if atom.HasQuery() and atom.DescribeQuery().find('AtomAtomicNum')!=0: 32 | opts.atomLabels[atom.GetIdx()]=atom.GetSmarts() 33 | drawer.DrawMolecule(mc) 34 | drawer.FinishDrawing() 35 | svg = drawer.GetDrawingText() 36 | # It seems that the svg renderer used doesn't quite hit the spec. 37 | # Here are some fixes to make it work in the notebook, although I think 38 | # the underlying issue needs to be resolved at the generation step 39 | return svg.replace('svg:','') 40 | 41 | def SvgsToGrid(svgs, labels, svgsPerRow=4,molSize=(250,150),fontSize=12): 42 | 43 | matcher = re.compile(r'^(<.*>\n)(\n)(.*)',re.DOTALL) 44 | hdr='' 45 | ftr='' 46 | rect='' 47 | nRows = len(svgs)//svgsPerRow 48 | if len(svgs)%svgsPerRow : nRows+=1 49 | blocks = ['']*(nRows*svgsPerRow) 50 | labelSizeDist = fontSize*5 51 | fullSize=(svgsPerRow*(molSize[0]+molSize[0]/10.0),nRows*(molSize[1]+labelSizeDist)) 52 | print(fullSize) 53 | 54 | count=0 55 | for svg,name in zip(svgs,labels): 56 | h,r,b = matcher.match(svg).groups() 57 | if not hdr: 58 | hdr = h.replace("width='"+str(molSize[0])+"px'","width='%dpx'"%fullSize[0]) 59 | hdr = hdr.replace("height='"+str(molSize[1])+"px'","height='%dpx'"%fullSize[1]) 60 | hdr = hdr.replace("viewBox='0 0 %d %d'"%(molSize[0],molSize[1]), 61 | "viewBox='0 0 %d %d'"%(fullSize[0],fullSize[1])) 62 | 63 | if not rect: 64 | rect = r 65 | legend = '\n' 66 | legend += ''+name.split('|')[0]+'\n' 67 | if len(name.split('|')) > 1: 68 | legend += ''+name.split('|')[1]+'\n' 69 | legend += '\n' 70 | blocks[count] = b + legend 71 | count+=1 72 | 73 | for i,elem in enumerate(blocks): 74 | row = i//svgsPerRow 75 | col = i%svgsPerRow 76 | elem = rect+elem 77 | blocks[i] = '%s'%(col*(molSize[0]+molSize[0]/10.0),row*(molSize[1]+labelSizeDist),elem) 78 | res = hdr + '\n'.join(blocks)+ftr 79 | return res 80 | 81 | def barplot_vertical(fig, ax, dict_input,ylabel,legend,xticks,legend_x_pos): 82 | N=len(dict_input) 83 | N2=len(list(dict_input.values())[0]) 84 | ind=np.arange(N) 85 | width=0.35 86 | if N2<=20: 87 | clist=list(np.arange(0,20,2))+list(np.arange(1,21,2)) 88 | else: 89 | clist=list(np.arange(0,N2//2*2+2,2))+list(np.arange(1,N2//2*2+1,2)) 90 | colors=plt.cm.tab20(clist[0:len(list(dict_input.values())[0])]) 91 | #p=np.zeros(N) 92 | bottom=np.zeros(N) 93 | for i in range(len(list(dict_input.values())[0])): 94 | ax.bar(ind,[v[i] for v in dict_input.values()], width, bottom=bottom, color=colors[i]) 95 | bottom = bottom + np.array([v[i] for v in dict_input.values()]) 96 | ax.set_ylabel(ylabel,fontsize=22) 97 | ax.set_xticks(ind) 98 | ax.set_xticklabels(xticks, rotation='vertical') 99 | if legend!=[]: 100 | ax.legend(legend, fontsize=20, ncol=4,bbox_to_anchor=(legend_x_pos, -0.3)) 101 | plt.setp(ax.get_xticklabels(), fontsize=18) 102 | plt.setp(ax.get_yticklabels(), fontsize=18) 103 | return fig,ax -------------------------------------------------------------------------------- /src/automated_series_classification/utilsStructureEval.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python3 2 | # -*- coding: utf-8 -*- 3 | """ 4 | Created on Mon Jan 27 16:29:23 2020 5 | 6 | @author: krugefr1 7 | """ 8 | from rdkit import Chem 9 | from rdkit.Chem import rdFMCS 10 | from rdkit.Chem import rdSubstructLibrary 11 | import pickle 12 | try: 13 | import arthor 14 | except ImportError: 15 | arthor = None 16 | 17 | 18 | def MCSFromMollist(mollist,chembldb,Nchembl,onlyCompleteRings=False): 19 | MCSSmarts2=rdFMCS.FindMCS(mollist,atomCompare=rdFMCS.AtomCompare.CompareAny,bondCompare=rdFMCS.BondCompare.CompareOrderExact,ringMatchesRingOnly=onlyCompleteRings,completeRingsOnly=onlyCompleteRings,timeout=1).smartsString 20 | MCSSmarts=rdFMCS.FindMCS(mollist,atomCompare=rdFMCS.AtomCompare.CompareElements,bondCompare=rdFMCS.BondCompare.CompareOrder,ringMatchesRingOnly=onlyCompleteRings,completeRingsOnly=onlyCompleteRings,timeout=1).smartsString 21 | if MCSSmarts2=='': fChembl2=1 22 | else: fChembl2=getFChembl(MCSSmarts2,chembldb,Nchembl) 23 | if MCSSmarts=='': fChembl=1 24 | else:fChembl=getFChembl(MCSSmarts,chembldb,Nchembl) 25 | if fChembl2