BenevolentAI · joergkurtwegner · Apr 23, 2019 · Apr 28, 2019 · May 17, 2019 · May 17, 2019
diff --git a/.flake8 b/.flake8
diff --git a/.gitignore b/.gitignore
diff --git a/.travis.yml b/.travis.yml
diff --git a/LICENSE b/LICENSE
diff --git a/MANIFEST.in b/MANIFEST.in
diff --git a/README.md b/README.md
diff --git a/dockers/Dockerfile b/dockers/Dockerfile
diff --git a/guacamol/__init__.py b/guacamol/__init__.py
diff --git a/guacamol/assess_distribution_learning.py b/guacamol/assess_distribution_learning.py
diff --git a/guacamol/assess_goal_directed_generation.py b/guacamol/assess_goal_directed_generation.py
diff --git a/guacamol/benchmark_suites.py b/guacamol/benchmark_suites.py
diff --git a/guacamol/common_scoring_functions.py b/guacamol/common_scoring_functions.py
@@ -55,6 +55,18 @@ def score_mol(self, mol: Chem.Mol) -> float:
         fp = get_fingerprint(mol, self.fp_type)
         return TanimotoSimilarity(fp, self.ref_fp)
 
+    def __hash__(self):
+        return hash(self.__repr__())
+
+    def __repr__(self):
+        return self.__class__.__name__+"("+self.__str__()+")"
+
+    def __str__(self):
+        reprList=[]
+        reprList.append(str(self._score_modifier.__repr__()))
+        reprList.append(str(self.target))
+        reprList.append(str(self.fp_type))
+        return ",".join(reprList)
 
 class CNS_MPO_ScoringFunction(ScoringFunctionBasedOnRdkitMol):
     """
@@ -84,6 +96,21 @@ def score_mol(self, mol: Chem.Mol) -> float:
 
         return 0.2 * (o1 + o2 + o3 + o4 + o5)
 
+    def __hash__(self):
+        return hash(self.__repr__())
+
+    def __repr__(self):
+        return self.__class__.__name__+"("+self.__str__()+")"
+
+    def __str__(self):
+        reprList=[]
+        reprList.append(str(self._score_modifier.__repr__()))
+        reprList.append(self.logP_gauss.__repr__())
+        reprList.append(self.molW_gauss.__repr__())
+        reprList.append(self.tpsa_maxgauss.__repr__())
+        reprList.append(self.tpsa_mingauss.__repr__())
+        reprList.append(self.hbd_gauss.__repr__())
+        return ",".join(reprList)
 
 class IsomerScoringFunction(MoleculewiseScoringFunction):
     """
@@ -106,6 +133,7 @@ def __init__(self, molecular_formula: str, mean_function='geometric') -> None:
         """
         super().__init__()
 
+        self.molecular_formula=molecular_formula
         self.mean_function = self.determine_mean_function(mean_function)
         self.scoring_functions = self.determine_scoring_functions(molecular_formula)
 
@@ -141,6 +169,18 @@ def raw_score(self, smiles: str) -> float:
             return self.corrupt_score
         return self.mean_function(scores)
 
+    def __hash__(self):
+        return hash(self.__repr__())
+
+    def __repr__(self):
+        return self.__class__.__name__+"("+self.__str__()+")"
+
+    def __str__(self):
+        reprList=[]
+        reprList.append(str(self._score_modifier.__repr__()))
+        reprList.append(self.mean_function)
+        reprList.append(self.molecular_formula)
+        return ",".join(reprList)
 
 class SMARTSScoringFunction(ScoringFunctionBasedOnRdkitMol):
     """
@@ -177,3 +217,16 @@ def score_mol(self, mol: Chem.Mol) -> float:
                 return 1.0
             else:
                 return 0.0
+
+    def __hash__(self):
+        return hash(self.__repr__())
+
+    def __repr__(self):
+        return self.__class__.__name__+"("+self.__str__()+")"
+
+    def __str__(self):
+        reprList=[]
+        reprList.append(str(self._score_modifier.__repr__()))
+        reprList.append(self.smarts)
+        reprList.append(str(self.inverse))
+        return ",".join(reprList)
diff --git a/guacamol/data/__init__.py b/guacamol/data/__init__.py
diff --git a/guacamol/data/get_data.py b/guacamol/data/get_data.py
diff --git a/guacamol/data/holdout_set_gcm_v1.smiles b/guacamol/data/holdout_set_gcm_v1.smiles
diff --git a/guacamol/distribution_learning_benchmark.py b/guacamol/distribution_learning_benchmark.py
diff --git a/guacamol/distribution_matching_generator.py b/guacamol/distribution_matching_generator.py
diff --git a/guacamol/frechet_benchmark.py b/guacamol/frechet_benchmark.py
diff --git a/guacamol/goal_directed_benchmark.py b/guacamol/goal_directed_benchmark.py
diff --git a/guacamol/goal_directed_generator.py b/guacamol/goal_directed_generator.py
diff --git a/guacamol/goal_directed_score_contributions.py b/guacamol/goal_directed_score_contributions.py
diff --git a/guacamol/py.typed b/guacamol/py.typed
diff --git a/guacamol/score_modifier.py b/guacamol/score_modifier.py
@@ -22,6 +22,10 @@ def __call__(self, x):
             float or np.array (depending on the type of x) after application of the distance function.
         """
 
+    def __hash__(self):
+        raise NotImplementedError
+        #return hash((self.__class__.__name__))
+
 
 class ChainedModifier(ScoreModifier):
     """
@@ -43,6 +47,18 @@ def __call__(self, x):
             score = modifier(score)
         return score
 
+    def __hash__(self):
+        return hash(self.__repr__())
+
+    def __repr__(self):
+        return self.__class__.__name__+"("+self.__str__()+")"
+
+    def __str__(self):
+        reprList=[]
+        for modifier in self.modifiers:
+            mrepr = modifier.__repr__()
+            reprList.append(mrepr)
+        return ",".join(reprList)
 
 class LinearModifier(ScoreModifier):
     """
@@ -55,6 +71,15 @@ def __init__(self, slope=1.0):
     def __call__(self, x):
         return self.slope * x
 
+    def __hash__(self):
+        return hash(self.__repr__())
+
+    def __repr__(self):
+        return self.__class__.__name__+"("+self.__str__()+")"
+
+    def __str__(self):
+        return str(self.slope)
+
 
 class SquaredModifier(ScoreModifier):
     """
@@ -69,6 +94,18 @@ def __init__(self, target_value: float, coefficient=1.0) -> None:
     def __call__(self, x):
         return 1.0 - self.coefficient * np.square(self.target_value - x)
 
+    def __hash__(self):
+        return hash(self.__repr__())
+
+    def __repr__(self):
+        return self.__class__.__name__+"("+self.__str__()+")"
+
+    def __str__(self):
+        reprList=[]
+        reprList.append(str(self.target_value))
+        reprList.append(str(self.coefficient))
+        return ",".join(reprList)
+
 
 class AbsoluteScoreModifier(ScoreModifier):
     """
@@ -82,6 +119,16 @@ def __init__(self, target_value: float) -> None:
     def __call__(self, x):
         return 1. - np.abs(self.target_value - x)
 
+    def __hash__(self):
+        return hash(self.__repr__())
+
+    def __repr__(self):
+        return self.__class__.__name__+"("+self.__str__()+")"
+
+    def __str__(self):
+        reprList=[]
+        reprList.append(str(self.target_value))
+        return ",".join(reprList)
 
 class GaussianModifier(ScoreModifier):
     """
@@ -95,6 +142,17 @@ def __init__(self, mu: float, sigma: float) -> None:
     def __call__(self, x):
         return np.exp(-0.5 * np.power((x - self.mu) / self.sigma, 2.))
 
+    def __hash__(self):
+        return hash(self.__repr__())
+
+    def __repr__(self):
+        return self.__class__.__name__+"("+self.__str__()+")"
+
+    def __str__(self):
+        reprList=[]
+        reprList.append(str(self.mu))
+        reprList.append(str(self.sigma))
+        return ",".join(reprList)
 
 class MinMaxGaussianModifier(ScoreModifier):
     """
@@ -116,6 +174,18 @@ def __call__(self, x):
             mod_x = np.minimum(x, self.mu)
         return self._full_gaussian(mod_x)
 
+    def __hash__(self):
+        return hash(self.__repr__())
+
+    def __repr__(self):
+        return self.__class__.__name__+"("+self.__str__()+")"
+
+    def __str__(self):
+        reprList=[]
+        reprList.append(str(self.mu))
+        reprList.append(str(self.sigma))
+        reprList.append(str(self.minimize))
+        return ",".join(reprList)
 
 MinGaussianModifier = partial(MinMaxGaussianModifier, minimize=True)
 MaxGaussianModifier = partial(MinMaxGaussianModifier, minimize=False)
@@ -160,6 +230,19 @@ def __call__(self, x):
         y = self.slope * x + self.intercept
         return np.clip(y, self.low_score, self.high_score)
 
+    def __hash__(self):
+        return hash(self.__repr__())
+
+    def __repr__(self):
+        return self.__class__.__name__+"("+self.__str__()+")"
+
+    def __str__(self):
+        reprList=[]
+        reprList.append(str(self.upper_x))
+        reprList.append(str(self.lower_x))
+        reprList.append(str(self.high_score))
+        reprList.append(str(self.low_score))
+        return ",".join(reprList)
 
 class SmoothClippedScoreModifier(ScoreModifier):
     """
@@ -192,6 +275,19 @@ def __init__(self, upper_x: float, lower_x=0.0, high_score=1.0, low_score=0.0) -
     def __call__(self, x):
         return self.low_score + self.L / (1 + np.exp(-self.k * (x - self.middle_x)))
 
+    def __hash__(self):
+        return hash(self.__repr__())
+
+    def __repr__(self):
+        return self.__class__.__name__+"("+self.__str__()+")"
+
+    def __str__(self):
+        reprList=[]
+        reprList.append(str(self.upper_x))
+        reprList.append(str(self.lower_x))
+        reprList.append(str(self.high_score))
+        reprList.append(str(self.low_score))
+        return ",".join(reprList)
 
 class ThresholdedLinearModifier(ScoreModifier):
     """
@@ -203,3 +299,14 @@ def __init__(self, threshold: float) -> None:
 
     def __call__(self, x):
         return np.minimum(x, self.threshold) / self.threshold
+
+    def __hash__(self):
+        return hash(self.__repr__())
+
+    def __repr__(self):
+        return self.__class__.__name__+"("+self.__str__()+")"
+
+    def __str__(self):
+        reprList=[]
+        reprList.append(str(self.threshold))
+        return ",".join(reprList)
diff --git a/guacamol/scoring_function.py b/guacamol/scoring_function.py
@@ -65,6 +65,8 @@ def score_list(self, smiles_list: List[str]) -> List[float]:
         """
         raise NotImplementedError
 
+    def __hash__(self):
+        raise NotImplementedError
 
 class MoleculewiseScoringFunction(ScoringFunction):
     """
@@ -104,6 +106,16 @@ def raw_score(self, smiles: str) -> float:
         """
         raise NotImplementedError
 
+    def __hash__(self):
+        return hash(self.__repr__())
+
+    def __repr__(self):
+        return self.__class__.__name__+"("+self.__str__()+")"
+
+    def __str__(self):
+        reprList=[]
+        reprList.append(str(self._score_modifier.__repr__()))
+        return ",".join(reprList)
 
 class BatchScoringFunction(ScoringFunction):
     """
@@ -147,6 +159,16 @@ def raw_score_list(self, smiles_list: List[str]) -> List[float]:
         """
         raise NotImplementedError
 
+    def __hash__(self):
+        return hash(self.__repr__())
+
+    def __repr__(self):
+        return self.__class__.__name__+"("+self.__str__()+")"
+
+    def __str__(self):
+        reprList=[]
+        reprList.append(str(self._score_modifier.__repr__()))
+        return ",".join(reprList)
 
 class ScoringFunctionBasedOnRdkitMol(MoleculewiseScoringFunction):
     """
@@ -204,6 +226,19 @@ def raw_score_list(self, smiles_list: List[str]) -> List[float]:
 
         return list(scores)
 
+    def __hash__(self):
+        return hash(self.__repr__())
+
+    def __repr__(self):
+        return self.__class__.__name__+"("+self.__str__()+")"
+
+    def __str__(self):
+        reprList=[]
+        reprList.append(str(self._score_modifier.__repr__()))
+        for scoring, weight in zip(self.scoring_functions, self.weights):
+            reprList.append(str(weight))
+            reprList.append(str(scoring.__repr__()))
+        return ",".join(reprList)
 
 class GeometricMeanScoringFunction(MoleculewiseScoringFunction):
     """
@@ -226,6 +261,19 @@ def raw_score(self, smiles: str) -> float:
 
         return geometric_mean(partial_scores)
 
+    def __hash__(self):
+        return hash(self.__repr__())
+
+    def __repr__(self):
+        return self.__class__.__name__ + "(" + self.__str__() + ")"
+
+    def __str__(self):
+        reprList = []
+        reprList.append(str(self._score_modifier.__repr__()))
+        for scoring in self.scoring_functions:
+            reprList.append(str(scoring.__repr__()))
+        return ",".join(reprList)
+
 
 class ScoringFunctionWrapper(ScoringFunction):
     """
@@ -250,3 +298,14 @@ def _increment_evaluation_count(self, n: int):
         # However, adding a threading.Lock member variable makes the class non-pickle-able, which prevents any multithreading.
         # Therefore, in the current implementation there cannot be a guarantee that self.evaluations will be calculated correctly.
         self.evaluations += n
+
+    def __hash__(self):
+        return hash(self.__repr__())
+
+    def __repr__(self):
+        return self.__class__.__name__ + "(" + self.__str__() + ")"
+
+    def __str__(self):
+        reprList = []
+        reprList.append(str(self.scoring_function.__repr__()))
+        return ",".join(reprList)
diff --git a/guacamol/standard_benchmarks.py b/guacamol/standard_benchmarks.py
diff --git a/guacamol/utils/__init__.py b/guacamol/utils/__init__.py
diff --git a/guacamol/utils/chemistry.py b/guacamol/utils/chemistry.py
diff --git a/guacamol/utils/data.py b/guacamol/utils/data.py
diff --git a/guacamol/utils/descriptors.py b/guacamol/utils/descriptors.py
diff --git a/guacamol/utils/fingerprints.py b/guacamol/utils/fingerprints.py
diff --git a/guacamol/utils/helpers.py b/guacamol/utils/helpers.py
diff --git a/guacamol/utils/math.py b/guacamol/utils/math.py
diff --git a/guacamol/utils/sampling_helpers.py b/guacamol/utils/sampling_helpers.py
diff --git a/mypy.ini b/mypy.ini
diff --git a/requirements.txt b/requirements.txt
diff --git a/setup.py b/setup.py
diff --git a/tests/__init__.py b/tests/__init__.py
diff --git a/tests/mock_generator.py b/tests/mock_generator.py
diff --git a/tests/test_distribution_learning_benchmarks.py b/tests/test_distribution_learning_benchmarks.py
diff --git a/tests/test_goal_directed_benchmark.py b/tests/test_goal_directed_benchmark.py
diff --git a/tests/test_sampling_helpers.py b/tests/test_sampling_helpers.py
diff --git a/tests/test_score_modifier.py b/tests/test_score_modifier.py
diff --git a/tests/test_scoring_functions.py b/tests/test_scoring_functions.py
diff --git a/tests/utils/test_chemistry.py b/tests/utils/test_chemistry.py
diff --git a/tests/utils/test_data.py b/tests/utils/test_data.py
diff --git a/tests/utils/test_descriptors.py b/tests/utils/test_descriptors.py