Merge branch 'develop' of https://github.com/stan-dev/cmdstanpy into develop

Author: mitzimorris

cmdstanpy/cmdstan_args.py

@@ -132,7 +132,7 @@ def validate(self, chains: int) -> None:
                 )
         if self.step_size is not None:
             if isinstance(self.step_size, Real):
-                if self.step_size < 0:
+                if self.step_size <= 0:
                     raise ValueError(
                         'step_size must be > 0, found {}'.format(self.step_size)
                     )
@@ -336,7 +336,7 @@ def validate(self, chains=None) -> None:  # pylint: disable=unused-argument
                     'init_alpha must not be set when algorithm is Newton'
                 )
             if isinstance(self.init_alpha, Real):
-                if self.init_alpha < 0:
+                if self.init_alpha <= 0:
                     raise ValueError('init_alpha must be greater than 0')
             else:
                 raise ValueError('init_alpha must be type of float')
@@ -350,8 +350,7 @@ def validate(self, chains=None) -> None:  # pylint: disable=unused-argument
 
     # pylint: disable=unused-argument
     def compose(self, idx: int, cmd: List) -> str:
-        """compose command string for CmdStan for non-default arg values.
-        """
+        """compose command string for CmdStan for non-default arg values."""
         cmd.append('method=optimize')
         if self.algorithm:
             cmd.append('algorithm={}'.format(self.algorithm.lower()))
@@ -403,6 +402,7 @@ def __init__(
         elbo_samples: int = None,
         eta: Real = None,
         adapt_iter: int = None,
+        adapt_engaged: bool = True,
         tol_rel_obj: Real = None,
         eval_elbo: int = None,
         output_samples: int = None,
@@ -413,6 +413,7 @@ def __init__(
         self.elbo_samples = elbo_samples
         self.eta = eta
         self.adapt_iter = adapt_iter
+        self.adapt_engaged = adapt_engaged
         self.tol_rel_obj = tol_rel_obj
         self.eval_elbo = eval_elbo
         self.output_samples = output_samples
@@ -453,19 +454,19 @@ def validate(self, chains=None) -> None:  # pylint: disable=unused-argument
                     ' found {}'.format(self.elbo_samples)
                 )
         if self.eta is not None:
-            if self.eta < 1 or not isinstance(self.eta, (Integral, Real)):
+            if self.eta < 0 or not isinstance(self.eta, (Integral, Real)):
                 raise ValueError(
                     'eta must be a non-negative number,'
                     ' found {}'.format(self.eta)
                 )
         if self.adapt_iter is not None:
-            if self.adapt_iter < 1 or not isinstance(self.eta, Integral):
+            if self.adapt_iter < 1 or not isinstance(self.adapt_iter, Integral):
                 raise ValueError(
                     'adapt_iter must be a positive integer,'
                     ' found {}'.format(self.adapt_iter)
                 )
         if self.tol_rel_obj is not None:
-            if self.tol_rel_obj < 1 or not isinstance(
+            if self.tol_rel_obj <= 0 or not isinstance(
                 self.tol_rel_obj, (Integral, Real)
             ):
                 raise ValueError(
@@ -503,9 +504,13 @@ def compose(self, idx: int, cmd: List) -> str:
             cmd.append('elbo_samples={}'.format(self.elbo_samples))
         if self.eta is not None:
             cmd.append('eta={}'.format(self.eta))
-        if self.adapt_iter is not None:
-            cmd.append('adapt')
-            cmd.append('iter={}'.format(self.adapt_iter))
+        cmd.append('adapt')
+        if self.adapt_engaged:
+            cmd.append('engaged=1')
+            if self.adapt_iter is not None:
+                cmd.append('iter={}'.format(self.adapt_iter))
+        else:
+            cmd.append('engaged=0')
         if self.tol_rel_obj is not None:
             cmd.append('tol_rel_obj={}'.format(self.tol_rel_obj))
         if self.eval_elbo is not None:
@@ -591,12 +596,12 @@ def validate(self) -> None:
                     self._logger.info(
                         'created output directory: %s', self.output_dir
                     )
-                except (RuntimeError, PermissionError):
+                except (RuntimeError, PermissionError) as exc:
                     raise ValueError(
                         'invalid path for output files, no such dir: {}'.format(
                             self.output_dir
                         )
-                    )
+                    ) from exc
             if not os.path.isdir(self.output_dir):
                 raise ValueError(
                     'specified output_dir not a directory: {}'.format(
@@ -608,11 +613,11 @@ def validate(self) -> None:
                 with open(testpath, 'w+'):
                     pass
                 os.remove(testpath)  # cleanup
-            except Exception:
+            except Exception as exc:
                 raise ValueError(
                     'invalid path for output files,'
                     ' cannot write to dir: {}'.format(self.output_dir)
-                )
+                ) from exc
 
         if self.seed is None:
             rng = RandomState()

cmdstanpy/model.py

@@ -850,13 +850,13 @@ def generate_quantities(
                 runset._csv_files = sample_csv_files
                 sample_fit = CmdStanMCMC(runset)
                 sample_drawset = sample_fit.draws_as_dataframe()
-        except ValueError as e:
+        except ValueError as exc:
             raise ValueError(
                 'Invalid mcmc_sample, error:\n\t{}\n\t'
                 ' while processing files\n\t{}'.format(
-                    repr(e), '\n\t'.join(sample_csv_files)
+                    repr(exc), '\n\t'.join(sample_csv_files)
                 )
-            )
+            ) from exc
 
         generate_quantities_args = GenerateQuantitiesArgs(
             csv_files=sample_csv_files
@@ -900,10 +900,12 @@ def variational(
         grad_samples: int = None,
         elbo_samples: int = None,
         eta: Real = None,
+        adapt_engaged: bool = True,
         adapt_iter: int = None,
         tol_rel_obj: Real = None,
         eval_elbo: int = None,
         output_samples: int = None,
+        require_converged: bool = True,
     ) -> CmdStanVB:
         """
         Run CmdStan's variational inference algorithm to approximate
@@ -961,6 +963,8 @@ def variational(
 
         :param eta: Stepsize scaling parameter.
 
+        :param adapt_engaged: Whether eta adaptation is engaged.
+
         :param adapt_iter: Number of iterations for eta adaptation.
 
         :param tol_rel_obj: Relative tolerance parameter for convergence.
@@ -970,6 +974,9 @@ def variational(
         :param output_samples: Number of approximate posterior output draws
             to save.
 
+        :param require_converged: Whether or not to raise an error if stan
+            reports that "The algorithm may not have converged".
+
         :return: CmdStanVB object
         """
         variational_args = VariationalArgs(
@@ -978,6 +985,7 @@ def variational(
             grad_samples=grad_samples,
             elbo_samples=elbo_samples,
             eta=eta,
+            adapt_engaged=adapt_engaged,
             adapt_iter=adapt_iter,
             tol_rel_obj=tol_rel_obj,
             eval_elbo=eval_elbo,
@@ -1010,7 +1018,7 @@ def variational(
             errors = re.findall(pat, contents)
             if len(errors) > 0:
                 valid = False
-        if not valid:
+        if require_converged and not valid:
             raise RuntimeError('The algorithm may not have converged.')
         if not runset._check_retcodes():
             msg = 'Error during variational inference.\n{}'.format(

cmdstanpy/stanfit.py

@@ -261,8 +261,8 @@ def save_csvfiles(self, dir: str = None) -> None:
             with open(test_path, 'w'):
                 pass
             os.remove(test_path)  # cleanup
-        except (IOError, OSError, PermissionError):
-            raise Exception('cannot save to path: {}'.format(dir))
+        except (IOError, OSError, PermissionError) as exc:
+            raise Exception('cannot save to path: {}'.format(dir)) from exc
 
         for i in range(self.chains):
             if not os.path.exists(self._csv_files[i]):
@@ -658,7 +658,12 @@ def summary(self, percentiles: List[int] = None) -> pd.DataFrame:
         do_command(cmd, logger=self.runset._logger)
         with open(tmp_csv_path, 'rb') as fd:
             summary_data = pd.read_csv(
-                fd, delimiter=',', header=0, index_col=0, comment='#'
+                fd,
+                delimiter=',',
+                header=0,
+                index_col=0,
+                comment='#',
+                float_precision='high',
             )
         mask = [x == 'lp__' or not x.endswith('__') for x in summary_data.index]
         return summary_data[mask]
@@ -971,7 +976,11 @@ def _assemble_generated_quantities(self) -> None:
         drawset_list = []
         for chain in range(self.runset.chains):
             drawset_list.append(
-                pd.read_csv(self.runset.csv_files[chain], comment='#')
+                pd.read_csv(
+                    self.runset.csv_files[chain],
+                    comment='#',
+                    float_precision='high',
+                )
             )
         self._generated_quantities = pd.concat(drawset_list).values
 

cmdstanpy/utils.py

@@ -387,9 +387,9 @@ def rdump(path: str, data: Dict) -> None:
 
 def rload(fname: str) -> dict:
     """Parse data and parameter variable values from an R dump format file.
-       This parser only supports the subset of R dump data as described
-       in the "Dump Data Format" section of the CmdStan manual, i.e.,
-       scalar, vector, matrix, and array data types.
+    This parser only supports the subset of R dump data as described
+    in the "Dump Data Format" section of the CmdStan manual, i.e.,
+    scalar, vector, matrix, and array data types.
     """
     data_dict = {}
     with open(fname, 'r') as fd:
@@ -420,8 +420,8 @@ def rload(fname: str) -> dict:
 
 def parse_rdump_value(rhs: str) -> Union[int, float, np.array]:
     """Process right hand side of Rdump variable assignment statement.
-       Value is either scalar, vector, or multi-dim structure.
-       Use regex to capture structure values, dimensions.
+    Value is either scalar, vector, or multi-dim structure.
+    Use regex to capture structure values, dimensions.
     """
     pat = re.compile(
         r'structure\(\s*c\((?P<vals>[^)]*)\)'
@@ -444,8 +444,8 @@ def parse_rdump_value(rhs: str) -> Union[int, float, np.array]:
             val = float(rhs)
         else:
             val = int(rhs)
-    except TypeError:
-        raise ValueError('bad value in Rdump file: {}'.format(rhs))
+    except TypeError as exc:
+        raise ValueError('bad value in Rdump file: {}'.format(rhs)) from exc
     return val
 
 
@@ -553,27 +553,26 @@ def scan_variational_csv(path: str) -> Dict:
         lineno = scan_column_names(fd, dict, lineno)
         line = fd.readline().lstrip(' #\t').rstrip()
         lineno += 1
-        if not line.startswith('Stepsize adaptation complete.'):
-            raise ValueError(
-                'line {}: expecting adaptation msg, found:\n\t "{}"'.format(
-                    lineno, line
-                )
-            )
-        line = fd.readline().lstrip(' #\t\n')
-        lineno += 1
-        if not line.startswith('eta = 1'):
-            raise ValueError(
-                'line {}: expecting eta = 1, found:\n\t "{}"'.format(
-                    lineno, line
+        if line.startswith('Stepsize adaptation complete.'):
+            line = fd.readline().lstrip(' #\t\n')
+            lineno += 1
+            if not line.startswith('eta'):
+                raise ValueError(
+                    'line {}: expecting eta, found:\n\t "{}"'.format(
+                        lineno, line
+                    )
                 )
-            )
-        line = fd.readline().lstrip(' #\t\n')
-        lineno += 1
+            line = fd.readline().lstrip(' #\t\n')
+            lineno += 1
         xs = line.split(',')
         variational_mean = [float(x) for x in xs]
         dict['variational_mean'] = variational_mean
         dict['variational_sample'] = pd.read_csv(
-            path, comment='#', skiprows=lineno, header=None
+            path,
+            comment='#',
+            skiprows=lineno,
+            header=None,
+            float_precision='high',
         )
     return dict
 
@@ -691,10 +690,10 @@ def scan_metric(fd: TextIO, config_dict: Dict, lineno: int) -> int:
         )
     try:
         float(stepsize.strip())
-    except ValueError:
+    except ValueError as exc:
         raise ValueError(
             'line {}: invalid stepsize: {}'.format(lineno, stepsize)
-        )
+        ) from exc
     line = fd.readline().strip()
     lineno += 1
     if not (