latest changes for compatibility with reinvent.v3.2

Author: GuoJeff

README.md

@@ -18,9 +18,9 @@ $ conda activate reinvent_scoring
 ## Run tests
 The tests use the `unittest` package testing framework.  Before you can run the tests make sure that you have created a
 `config.json`file in the `reinvent_scoring/configs` directory.  There is an example config in the same directory, which 
-you can base your own config off of. The easiest way is to make a copy of the example config and name it `config.json`.
-Make sure that you set `MAIN_TEST_PATH` in the `config.json` to a non-existent directory; it is where temporary files will be
-written during the tests; if it is set to an existing directory, that directory will be removed once the tests have finished.
+you can base your own config off of.  Make sure that you set `MAIN_TEST_PATH` to a non-existent directory; it is where 
+temporary files will be written during the tests; if it is set to an existing directory, that directory will be removed 
+once the tests have finished.
 
 Some tests require a proprietary OpenEye license; you have to set up a few things to make the tests read your
 license.  The simple way is to just set the `OE_LICENSE` environment variable to the path of the file containing the
@@ -50,15 +50,21 @@ unset OE_LICENSE
 Once you have created the files, deactivate and re-activate the environment, and `echo $OE_LICENSE` should output the
 path to the license file.
 
-Once you have created a config file and configured your environment, you can run the tests, located in the 
-`unittest_reinvent` directory, by running
+Once you have created and configured your environment, you can run unittests by running
 
+```bash
+python main_test.py --unittests
 ```
-$ python main_test.py
+
+If you have a valid Open eye license and other dependencie configured, like Icolos and AZDOCK - 
+you can also run integration tests, by running command (remember to submit this configuration, since the default one is test):
+
+```bash
+python main_test.py --integration --base_config <path to your configuration>
 ```
 
 # Building
 - Building: `python setup.py sdist bdist_wheel`
-- Upload build to test: `$python -m twine upload --repository testpypi dist/*`
+- Upload build to test: `python -m twine upload --repository testpypi dist/*`
 - Upload build: `python -m twine upload dist/*`
 

environment.yml

@@ -211,10 +211,9 @@ dependencies:
     - markdown==3.2.1
     - opt-einsum==3.2.0
     - protobuf==3.11.3
-    - reinvent-chemistry==0.0.40
-    - reinvent-models==0.0.12
+    - reinvent-chemistry==0.0.50
     - tensorboard==1.15.0
     - tensorflow==1.15.2
     - tensorflow-estimator==1.15.1
     - termcolor==1.1.0
-    - werkzeug==1.0.0
+    - werkzeug==1.0.0

main_test.py

@@ -1,11 +1,32 @@
 #!/usr/bin/env python
 #  coding=utf-8
+import pytest
+import argparse
 
-import unittest
 
-from unittest_reinvent.scoring_tests import *
-from unittest_reinvent.diversity_filter_tests import *
+TESTS_FOLDER = 'unittest_reinvent'
+
+
+parser = argparse.ArgumentParser(description='Run reinvent_scoring tests')
+parser.add_argument(
+    '--unittests', action='store_true',
+    help='Only run unittests (Please indicate either integration or unittests flag)'
+)
+parser.add_argument(
+    '--integration', action='store_true',
+    help='Only run integration tests (Please indicate either integration or unittests flag)'
+)
+
+args, _ = parser.parse_known_args()
+
+
+if args.unittests:
+    pytest_args = ['-m', 'not integration', TESTS_FOLDER]
+elif args.integration:
+    pytest_args = ['-m', 'integration', TESTS_FOLDER]
+else:
+    raise Exception('Please provide either --unittests or --integration flag.')
 
 
 if __name__ == '__main__':
-    unittest.main()
+    pytest.main(pytest_args)

reinvent_scoring/configs/__init__.py

@@ -0,0 +1,30 @@
+import argparse
+import json
+import os
+from pathlib import Path
+
+
+DEFAULT_BASE_CONFIG_PATH = (Path(__file__).parent / 'test_config.json').resolve()
+
+parser = argparse.ArgumentParser(description='Reinvent Scoring configuration parser')
+parser.add_argument(
+    '--base_config', type=str, default=DEFAULT_BASE_CONFIG_PATH,
+    help='Path to basic configuration for Reinvent Scoring environment.'
+)
+
+
+def read_json_file(path):
+    with open(path) as f:
+        json_input = f.read().replace('\r', '').replace('\n', '')
+    try:
+        return json.loads(json_input)
+    except (ValueError, KeyError, TypeError) as e:
+        print(f"JSON format error in file ${path}: \n ${e}")
+
+
+args, _ = parser.parse_known_args()
+
+reinvent_scoring_config = read_json_file(args.base_config)
+
+for key, value in reinvent_scoring_config['ENVIRONMENTAL_VARIABLES'].items():
+    os.environ[key] = value

reinvent_scoring/configs/config.py

@@ -14,15 +14,14 @@
       "DOCKSTREAM_ENV_PATH": "/<your_path>/miniconda3/envs/DockStream/bin/python",
       "DOCKSTREAM_DEBUG": true
     },
-    "AZGARD": {
-      "AZGARD_EXECUTOR_SCRIPT_PATH": "/<your_path>/executor.py",
-      "AZGARD_ENV_PATH": "/<your_path>/miniconda3/envs/AZgard/bin/python",
-      "AZGARD_DEBUG": true
+    "ICOLOS": {
+      "ICOLOS_EXECUTOR_PATH": "/<your_path>/miniconda3/envs/icolosprod/bin/icolos",
+      "ICOLOS_DEBUG": true
     }
   },
   "ENVIRONMENTAL_VARIABLES": {
     "PIP_URL": "<confidential info>",
-    "PIP_KEY": "<confidential info>",
-    "PIP_GET_RESULTS": "<relevant only for batching implemented in BasePiPModelBatchingComponent>"
+    "PIP_KEY": "<contact Atanas>",
+    "PIP_GET_RESULTS": "<relevant only for batching implemented in BasePiPModelBatchingComponent>",
   }
 }

reinvent_scoring/configs/example.config.json

@@ -0,0 +1,25 @@
+{
+  "DEVELOPMENT_ENVIRONMENT": true,
+  "MAIN_TEST_PATH": "tmp_test_folder",
+  "COMPONENT_SPECIFIC": {
+    "AZDOCK": {
+      "AZDOCK_DOCKER_SCRIPT_PATH": "/opt/scp/services/reinvent/docking/azdock/docker.py",
+      "AZDOCK_ENV_PATH": "/opt/scp/services/reinvent/miniconda3/envs/AZdock/bin/python",
+      "AZDOCK_DEBUG": true
+    },
+    "DOCKSTREAM": {
+      "DOCKSTREAM_DOCKER_SCRIPT_PATH": "/opt/scp/services/reinvent/docking/azdock/docker.py",
+      "DOCKSTREAM_ENV_PATH": "/opt/scp/services/reinvent/miniconda3/envs/AZdock/bin/python",
+      "DOCKSTREAM_DEBUG": true
+    },
+    "ICOLOS": {
+      "ICOLOS_EXECUTOR_PATH": "/<your_path>/miniconda3/envs/icolosprod/bin/icolos",
+      "ICOLOS_DEBUG": true
+    }
+  },
+  "ENVIRONMENTAL_VARIABLES": {
+    "PIP_URL": "https://pip.dummy.net/bapi/{}/predict",
+    "PIP_KEY": "something-secret",
+    "PIP_GET_RESULTS": "https://pip.dummy.net"
+  }
+}

reinvent_scoring/configs/test_config.json

@@ -6,4 +6,4 @@
 from reinvent_scoring.scoring.score_summary import FinalSummary, ComponentSummary, LoggableComponent
 from reinvent_scoring.scoring.score_transformations import TransformationFactory
 from reinvent_scoring.scoring.scoring_function_factory import ScoringFunctionFactory
-from reinvent_scoring.scoring.scoring_function_parameters import ScoringFunctionParameters, ScoringFuncionParameters
+from reinvent_scoring.scoring.scoring_function_parameters import ScoringFunctionParameters

reinvent_scoring/scoring/__init__.py

@@ -1,4 +1,3 @@
-from typing import List
 from dataclasses import dataclass
 
 
@@ -7,6 +6,4 @@ class ComponentParameters:
     component_type: str
     name: str
     weight: float
-    smiles: List[str]
-    model_path: str
     specific_parameters: dict = None

reinvent_scoring/scoring/component_parameters.py

@@ -0,0 +1,3 @@
+from reinvent_scoring.scoring.diversity_filters.curriculum_learning.diversity_filter_memory import DiversityFilterMemory
+from reinvent_scoring.scoring.diversity_filters.curriculum_learning.diversity_filter_parameters import \
+    DiversityFilterParameters

reinvent_scoring/scoring/diversity_filters/curriculum_learning/__init__.py

@@ -0,0 +1,63 @@
+import abc
+
+import numpy as np
+import pandas as pd
+from reinvent_chemistry.conversions import Conversions
+
+from reinvent_scoring.scoring.diversity_filters.curriculum_learning import DiversityFilterParameters, \
+    DiversityFilterMemory
+from reinvent_scoring.scoring.diversity_filters.curriculum_learning.loggable_data_dto import UpdateLoggableDataDTO
+from reinvent_scoring.scoring.diversity_filters.curriculum_learning.memory_record_dto import MemoryRecordDTO
+from reinvent_scoring.scoring.diversity_filters.curriculum_learning.update_diversity_filter_dto import \
+    UpdateDiversityFilterDTO
+
+
+class BaseDiversityFilter(abc.ABC):
+
+    @abc.abstractmethod
+    def __init__(self, parameters: DiversityFilterParameters):
+        self.parameters = parameters
+        self._diversity_filter_memory = DiversityFilterMemory()
+        self._chemistry = Conversions()
+
+    @abc.abstractmethod
+    def update_score(self, update_dto: UpdateDiversityFilterDTO) -> np.array:
+        raise NotImplementedError("The method 'update_score' is not implemented!")
+
+    def get_memory_as_dataframe(self) -> pd.DataFrame:
+        return self._diversity_filter_memory.get_memory()
+
+    def set_memory_from_dataframe(self, memory: pd.DataFrame):
+        self._diversity_filter_memory.set_memory(memory)
+
+    def number_of_smiles_in_memory(self) -> int:
+        return self._diversity_filter_memory.number_of_smiles()
+
+    def number_of_scaffold_in_memory(self) -> int:
+        return self._diversity_filter_memory.number_of_scaffolds()
+
+    def update_bucket_size(self, bucket_size: int):
+        self.parameters.bucket_size = bucket_size
+
+    def _calculate_scaffold(self, smile):
+        raise NotImplementedError
+
+    def _smiles_exists(self, smile):
+        return self._diversity_filter_memory.smiles_exists(smile)
+
+    def _add_to_memory(self, memory_dto: MemoryRecordDTO):
+        self._diversity_filter_memory.update(memory_dto)
+
+    def _penalize_score(self, scaffold, score):
+        """Penalizes the score if the scaffold bucket is full"""
+        if self._diversity_filter_memory.scaffold_instances_count(scaffold) > self.parameters.bucket_size:
+            score = 0.
+        return score
+
+    def _compose_loggable_data(self, dto: UpdateLoggableDataDTO):
+        prior_likelihood = f'{dto.prior_likelihood}|' if dto.prior_likelihood else ''
+        likelihood =  f'{dto.likelihood}|' if dto.likelihood else ''
+        input =  f'{dto.input}|' if dto.input else ''
+        output = f'{dto.output}' if dto.output else ''
+        loggable_data = f'{prior_likelihood}{likelihood}{input}{output}'
+        return loggable_data

reinvent_scoring/scoring/diversity_filters/curriculum_learning/base_diversity_filter.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class ColumnNamesEnum:
+    STEP: str = "Step"
+    SCAFFOLD: str = "Scaffold"
+    SMILES: str = "SMILES"
+    METADATA: str = "Metadata"

reinvent_scoring/scoring/diversity_filters/curriculum_learning/column_names_enum.py

@@ -0,0 +1,22 @@
+from reinvent_scoring.scoring.diversity_filters.curriculum_learning import DiversityFilterParameters
+from reinvent_scoring.scoring.diversity_filters.curriculum_learning.base_diversity_filter import BaseDiversityFilter
+from reinvent_scoring.scoring.diversity_filters.curriculum_learning.identical_murcko_scaffold import \
+    IdenticalMurckoScaffold
+from reinvent_scoring.scoring.diversity_filters.curriculum_learning.identical_topological_scaffold import \
+    IdenticalTopologicalScaffold
+from reinvent_scoring.scoring.diversity_filters.curriculum_learning.no_filter import NoFilter
+from reinvent_scoring.scoring.diversity_filters.curriculum_learning.no_filter_with_penalty import NoFilterWithPenalty
+from reinvent_scoring.scoring.diversity_filters.curriculum_learning.scaffold_similarity import ScaffoldSimilarity
+
+
+class DiversityFilter:
+
+    def __new__(cls, parameters: DiversityFilterParameters) -> BaseDiversityFilter:
+        all_filters = dict(IdenticalMurckoScaffold=IdenticalMurckoScaffold,
+                           NoFilterWithPenalty=NoFilterWithPenalty,
+                           IdenticalTopologicalScaffold=IdenticalTopologicalScaffold,
+                           ScaffoldSimilarity=ScaffoldSimilarity,
+                           NoFilter=NoFilter
+                           )
+        div_filter = all_filters.get(parameters.name, KeyError(f"Invalid filter name: `{parameters.name}'"))
+        return div_filter(parameters)

reinvent_scoring/scoring/diversity_filters/curriculum_learning/diversity_filter.py

@@ -0,0 +1,67 @@
+from typing import List, Dict
+
+import pandas as pd
+
+from reinvent_scoring.scoring.diversity_filters.curriculum_learning.column_names_enum import ColumnNamesEnum
+from reinvent_scoring.scoring.diversity_filters.curriculum_learning.memory_record_dto import MemoryRecordDTO
+from reinvent_scoring.scoring.score_summary import ComponentSummary
+from reinvent_scoring.scoring.enums.scoring_function_component_enum import ScoringFunctionComponentNameEnum
+
+
+class DiversityFilterMemory:
+
+    def __init__(self):
+        self._sf_component_name = ScoringFunctionComponentNameEnum()
+        self._column_name = ColumnNamesEnum()
+        df_dict = {self._column_name.STEP: [], self._column_name.SCAFFOLD: [], self._column_name.SMILES: [],
+                   self._column_name.METADATA: []}
+        self._memory_dataframe = pd.DataFrame(df_dict)
+
+    def update(self, dto: MemoryRecordDTO):
+        component_scores = {c.parameters.name: float(c.total_score[dto.id]) for c in dto.components}
+        component_scores = self._include_raw_score(dto.id, component_scores, dto.components)
+        component_scores[self._sf_component_name.TOTAL_SCORE] = float(dto.score)
+        if not self.smiles_exists(dto.smile): self._add_to_memory_dataframe(dto, component_scores)
+
+    def _add_to_memory_dataframe(self, dto: MemoryRecordDTO, component_scores: Dict):
+        data = []
+        headers = []
+        for name, score in component_scores.items():
+            headers.append(name)
+            data.append(score)
+        headers.append(self._column_name.STEP)
+        data.append(dto.step)
+        headers.append(self._column_name.SCAFFOLD)
+        data.append(dto.scaffold)
+        headers.append(self._column_name.SMILES)
+        data.append(dto.smile)
+        headers.append(self._column_name.METADATA)
+        data.append(dto.loggable_data)
+        new_data = pd.DataFrame([data], columns=headers)
+        self._memory_dataframe = pd.concat([self._memory_dataframe, new_data], ignore_index=True, sort=False)
+
+    def get_memory(self) -> pd.DataFrame:
+        return self._memory_dataframe
+
+    def set_memory(self, memory: pd.DataFrame):
+        self._memory_dataframe = memory
+
+    def smiles_exists(self, smiles: str):
+        if len(self._memory_dataframe) == 0:
+            return False
+        return smiles in self._memory_dataframe[self._column_name.SMILES].values
+
+    def scaffold_instances_count(self, scaffold: str):
+        return (self._memory_dataframe[self._column_name.SCAFFOLD].values == scaffold).sum()
+
+    def number_of_scaffolds(self):
+        return len(set(self._memory_dataframe[self._column_name.SCAFFOLD].values))
+
+    def number_of_smiles(self):
+        return len(set(self._memory_dataframe[self._column_name.SMILES].values))
+
+    def _include_raw_score(self, indx: int, component_scores: dict, components: List[ComponentSummary]):
+        raw_scores = {f'raw_{c.parameters.name}': float(c.raw_score[indx]) for c in components if
+                      c.raw_score is not None}
+        all_scores = {**component_scores, **raw_scores}
+        return all_scores

reinvent_scoring/scoring/diversity_filters/curriculum_learning/diversity_filter_memory.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class DiversityFilterParameters:
+    name: str
+    minscore: float = 0.4
+    bucket_size: int = 25
+    minsimilarity: float = 0.4
+    penalty_multiplier: float = 0.5