Merge pull request #347 from ATOMScience-org/1.6.2

1.6.2

Author: mauvais2

README.md

@@ -10,12 +10,12 @@ An open-source, end-to-end software pipeline for data curation, model building,
 <img src="atomsci/ddm/docs/ATOM_cymatics_black_wordmark.jpg" width="370" height="100" class="center"></img>
 
 
-![Static Badge](https://img.shields.io/badge/Announcement-1.6.1-blue)![Static Badge](https://img.shields.io/badge/Announcement-1.6.1-blue)![Static Badge](https://img.shields.io/badge/Announcement-1.6.1-blue)![Static Badge](https://img.shields.io/badge/Announcement-1.6.1-blue)![Static Badge](https://img.shields.io/badge/Announcement-1.6.1-blue)![Static Badge](https://img.shields.io/badge/Announcement-1.6.1-blue)
+The ATOM Modeling PipeLine (AMPL) extends the functionality of DeepChem and supports an array of machine learning and molecular featurization tools to predict key potency, safety and pharmacokinetic-relevant parameters. AMPL has been benchmarked on a large collection of pharmaceutical datasets covering a wide range of parameters. This is a living software project with active development. Check back for continued updates. Feedback is welcomed and appreciated, and the project is open to contributions! An [article describing the AMPL project](https://pubs.acs.org/doi/abs/10.1021/acs.jcim.9b01053) was published in JCIM. For those without access to JCIM, a preprint of the article is available on [ArXiv](http://arxiv.org/abs/1911.05211). [Documentation is available here.](https://ampl.readthedocs.io/en/latest/pipeline.html)
 
-## Check out our new tutorial series that walks through AMPL's end-to-end modeling pipeline to build a machine learning model! View them in our [docs](https://ampl.readthedocs.io/en/latest/) or as Jupyter notebooks in our [repo](https://github.com/ATOMScience-org/AMPL/tree/master/atomsci/ddm/examples/tutorials).
 
-The ATOM Modeling PipeLine (AMPL) extends the functionality of DeepChem and supports an array of machine learning and molecular featurization tools to predict key potency, safety and pharmacokinetic-relevant parameters. AMPL has been benchmarked on a large collection of pharmaceutical datasets covering a wide range of parameters. This is a living software project with active development. Check back for continued updates. Feedback is welcomed and appreciated, and the project is open to contributions! An [article describing the AMPL project](https://pubs.acs.org/doi/abs/10.1021/acs.jcim.9b01053) was published in JCIM. For those without access to JCIM, a preprint of the article is available on [ArXiv](http://arxiv.org/abs/1911.05211). [Documentation is available here.](https://ampl.readthedocs.io/en/latest/pipeline.html)
+![Static Badge](https://img.shields.io/badge/Announcement-1.6.1-blue)
 
+Check out our new tutorial series that walks through AMPL's end-to-end modeling pipeline to build a machine learning model! View them in our [docs](https://ampl.readthedocs.io/en/latest/) or as Jupyter notebooks in our [repo](https://github.com/ATOMScience-org/AMPL/tree/master/atomsci/ddm/examples/tutorials).
 
 ---
 ## Table of contents

VERSION

@@ -1 +1 @@
-1.6.1
+1.6.2

atomsci/ddm/pipeline/model_pipeline.py

@@ -728,9 +728,11 @@ def predict_on_smiles(self, smiles, verbose=False, AD_method=None, k=5, dist_met
             the featurizer may not be able to featurize all of them.
         """
 
+        logger = logging.getLogger('ATOM')
+        orig_log_level = logger.getEffectiveLevel()
+        logger.setLevel(orig_log_level)
         if not verbose:
             os.environ['TF_CPP_MIN_LOG_LEVEL'] = '1'
-            logger = logging.getLogger('ATOM')
             logger.setLevel(logging.CRITICAL)
             sys.stdout = io.StringIO()
             import warnings
@@ -747,6 +749,7 @@ def predict_on_smiles(self, smiles, verbose=False, AD_method=None, k=5, dist_met
         res = self.predict_on_dataframe(df, AD_method=AD_method, k=k, dist_metric=dist_metric)
 
         sys.stdout = sys.__stdout__
+        logger.setLevel(orig_log_level)
 
         return res
 
@@ -1258,6 +1261,7 @@ def create_prediction_pipeline(params, model_uuid, collection_name=None, featuri
     pipeline.model_wrapper = model_wrapper.create_model_wrapper(pipeline.params, featurization,
                                                                 pipeline.ds_client)
 
+    orig_log_level = pipeline.log.getEffectiveLevel()
     if params.verbose:
         pipeline.log.setLevel(logging.DEBUG)
     else:
@@ -1275,6 +1279,7 @@ def create_prediction_pipeline(params, model_uuid, collection_name=None, featuri
     # Reload the saved model training state
     pipeline.model_wrapper.reload_model(pipeline.model_wrapper.model_dir)
 
+    pipeline.log.setLevel(orig_log_level)
     return pipeline
 
 
@@ -1371,6 +1376,7 @@ def create_prediction_pipeline_from_file(params, reload_dir, model_path=None, mo
     # Create the ModelWrapper object.
     pipeline.model_wrapper = model_wrapper.create_model_wrapper(pipeline.params, featurization)
 
+    orig_log_level = pipeline.log.getEffectiveLevel()
     if verbose:
         pipeline.log.setLevel(logging.DEBUG)
     else:
@@ -1382,6 +1388,7 @@ def create_prediction_pipeline_from_file(params, reload_dir, model_path=None, mo
     # If that worked, reload the saved model training state
     pipeline.model_wrapper.reload_model(model_dir)
 
+    pipeline.log.setLevel(orig_log_level)
     return pipeline
 
 

atomsci/ddm/pipeline/model_wrapper.py

@@ -1072,23 +1072,39 @@ def generate_predictions(self, dataset):
             self.log.warning("Warning: DeepChem neural net models support uncertainty for regression only.")
 
         if self.params.uncertainty and self.params.prediction_type == 'regression':
-            # For multitask, predict_uncertainty returns a list of (pred, std) tuples, one for each task.
-            # For singletask, it returns one tuple. Convert the result into a pair of ndarrays of shape (ncmpds, ntasks, nclasses).
+            # For the models we use, predict_uncertainty returns a tuple (not a list of tuples) for both singletask and multitask. 
+            # A list is only returned if we request multiple *outputs* (e.g., predictions and embeddings), which are not the same thing as tasks.
+
+            # Fully connected NN models return predictions and uncertainties as arrays with shape (num_cmpds, num_tasks, num_classes), with
+            # num_classes = 1 for regression models. GraphConv regression models omit the num_classes dimension.
             pred_std = self.model.predict_uncertainty(dataset)
             if type(pred_std) == tuple:
-                #JEA
-                #ntasks = 1
-                ntasks = len(pred_std[0][0])
                 pred, std = pred_std
-                pred = pred.reshape((pred.shape[0], 1, pred.shape[1]))
+                ncmpds = pred.shape[0]
+                ntasks = pred.shape[1]
+                if len(pred.shape) > 2:
+                    nclasses = pred.shape[2]
+                else:
+                    nclasses = 1
+                self.log.debug(f"generate_predictions: input pred shape = {pred.shape}, std shape = {std.shape}")
+                # Reshape to 3 dimensions for consistency
+                pred = pred.reshape((ncmpds, ntasks, nclasses))
                 std = std.reshape(pred.shape)
+                self.log.debug(f"After reshaping: pred shape = {pred.shape}")
             else:
-                ntasks = len(pred_std)
-                pred0, std0 = pred_std[0]
-                ncmpds = pred0.shape[0]
-                nclasses = pred0.shape[1]
-                pred = np.concatenate([p.reshape((ncmpds, 1, nclasses)) for p, s in pred_std], axis=1)
-                std = np.concatenate([s.reshape((ncmpds, 1, nclasses)) for p, s in pred_std], axis=1)
+                # ksm: I don't think this code block will never get run, but just in case, take the first output
+                # as the actual predictions
+                num_outputs = len(pred_std)
+                pred, std = pred_std[0]
+                ncmpds = pred.shape[0]
+                ntasks = pred.shape[1]
+                if len(pred.shape) > 2:
+                    nclasses = pred.shape[2]
+                else:
+                    nclasses = 1
+                self.log.info(f"generate_predictions returned {num_outputs} outputs: ntasks={ntasks}, ncmpds={ncmpds}, nclasses={nclasses}")
+                pred = pred.reshape((ncmpds, ntasks, nclasses))
+                std = std.reshape(pred.shape)
 
             if self.params.transformers and self.transformers is not None:
                   # Transform the standard deviations, if we can. This is a bit of a hack, but it works for
@@ -1103,13 +1119,15 @@ def generate_predictions(self, dataset):
                     std = std / y_stds
                 pred = dc.trans.undo_transforms(pred, self.transformers)
         else:
+            # Classification models and regression models without uncertainty are handled here
             txform = [] if (not self.params.transformers or self.transformers is None) else self.transformers
             pred = self.model.predict(dataset, txform)
             if self.params.prediction_type == 'regression':
                 if type(pred) == list and len(pred) == 0:
                     # DeepChem models return empty list if no valid predictions
                     pred = np.array([]).reshape((0,0,1))
                 else:
+                    # Reshape graphconv predictions to 3D array; others already have this shape
                     pred = pred.reshape((pred.shape[0], pred.shape[1], 1))
         return pred, std