Remove verbose argument

Author: colin

docs/source/notebooks/NUTS_scaling_using_ADVI.ipynb

@@ -490,7 +490,7 @@
    ],
    "source": [
     "with mdl:\n",
-    "    v_params = pm.variational.advi(n=100000, verbose=False) \n",
+    "    v_params = pm.variational.advi(n=100000) \n",
     "\n",
     "_ = plt.plot(-np.log10(-v_params.elbo_vals))"
    ]

pymc3/model.py

@@ -169,25 +169,16 @@ def logpt(self):
 
 
 class Model(Context, Factor):
-    """Encapsulates the variables and likelihood factors of a model.
+    """Encapsulates the variables and likelihood factors of a model."""
 
-    Parameters
-    ----------
-    verbose : int
-        Model verbosity setting, determining how much feedback various
-        operations provide. Normal verbosity is verbose=1 (default), silence
-        is verbose=0, high is any value greater than 1.
-    """
-
-    def __init__(self, verbose=1):
+    def __init__(self):
         self.named_vars = {}
         self.free_RVs = []
         self.observed_RVs = []
         self.deterministics = []
         self.potentials = []
         self.missing_values = []
         self.model = self
-        self.verbose = verbose
 
     @property
     @memoize
@@ -288,7 +279,7 @@ def Var(self, name, dist, data=None):
                 var = TransformedRV(name=name, distribution=dist, model=self,
                                     transform=dist.transform)
                 pm._log.debug('Applied {transform}-transform to {name}'
-                             ' and added transformed {orig_name} to model.'.format(
+                              ' and added transformed {orig_name} to model.'.format(
                                 transform=dist.transform.name,
                                 name=name,
                                 orig_name='{}_{}_'.format(name, dist.transform.name)))
@@ -623,8 +614,8 @@ def __init__(self, name, data, distribution, model):
         self.data = {name: as_tensor(data, name, model, distribution)
                      for name, data in data.items()}
 
-        self.missing_values = [data.missing_values for data in self.data.values()
-                               if data.missing_values is not None]
+        self.missing_values = [datum.missing_values for datum in self.data.values()
+                               if datum.missing_values is not None]
         self.logp_elemwiset = distribution.logp(**self.data)
         self.model = model
         self.distribution = distribution

pymc3/sampling.py

@@ -69,8 +69,7 @@ def assign_step_methods(model, step=None, methods=(NUTS, HamiltonianMC, Metropol
     for var in model.free_RVs:
         if var not in assigned_vars:
             selected = max(methods, key=lambda method: method._competence(var))
-            if model.verbose:
-                pm._log.info('Assigned {0} to {1}'.format(selected.__name__, var))
+            pm._log.info('Assigned {0} to {1}'.format(selected.__name__, var))
             selected_steps[selected].append(var)
 
     # Instantiate all selected step methods

pymc3/tests/test_advi.py

@@ -95,7 +95,7 @@ def create_minibatches():
 
             with self.assertRaises(ValueError):
                 advi_minibatch(n=10, minibatch_RVs=[disasters], minibatch_tensors=[disaster_data_t],
-                               minibatches=create_minibatches(), verbose=False)
+                               minibatches=create_minibatches())
 
     def test_advi(self):
         n = 1000
@@ -201,7 +201,7 @@ def create_minibatches(data):
             mu_ = Normal('mu', mu=mu0, sd=sd0, testval=0)
             x = Normal('x', mu=mu_, sd=sd, observed=data_t)
             advi_fit = advi_minibatch(
-                n=1000, minibatch_tensors=[data_t], encoder_params=[], 
+                n=1000, minibatch_tensors=[data_t], encoder_params=[],
                 minibatch_RVs=[x], minibatches=create_minibatches(data),
                 total_size=n, learning_rate=1e-1)
             np.testing.assert_allclose(advi_fit.means['mu'], mu_post, rtol=0.1)

pymc3/tuning/starting.py

@@ -55,9 +55,7 @@ def find_MAP(start=None, vars=None, fmin=None, return_raw=False,
 
     disc_vars = list(typefilter(vars, discrete_types))
 
-    kwargs["disp"] = model.verbose > 1
-
-    if disc_vars and kwargs["disp"]:
+    if disc_vars:
         pm._log.warning("Warning: vars contains discrete variables. MAP " +
                         "estimates may not be accurate for the default " +
                         "parameters. Defaulting to non-gradient minimization " +

pymc3/variational/advi.py

@@ -36,8 +36,7 @@ def gen_random_state():
 
 
 def advi(vars=None, start=None, model=None, n=5000, accurate_elbo=False,
-         optimizer=None, learning_rate=.001, epsilon=.1, random_seed=None,
-         verbose=1):
+         optimizer=None, learning_rate=.001, epsilon=.1, random_seed=None):
     """Perform automatic differentiation variational inference (ADVI).
 
     This function implements the meanfield ADVI, where the variational
@@ -142,29 +141,21 @@ def advi(vars=None, start=None, model=None, n=5000, accurate_elbo=False,
     # Optimization loop
     elbos = np.empty(n)
     try:
-        for i in range(n):
+        progress = trange(n)
+        for i in progress:
             uw_i, e = f()
             elbos[i] = e
-            if verbose and not i % (n // 10):
-                if not i:
-                    print('Iteration {0} [{1}%]: ELBO = {2}'.format(
-                        i, 100 * i // n, e.round(2)))
-                else:
-                    avg_elbo = elbos[i - n // 10:i].mean()
-                    print('Iteration {0} [{1}%]: Average ELBO = {2}'.format(
-                        i, 100 * i // n, avg_elbo.round(2)))
+            if i % (n // 10) == 0 and i > 0:
+                avg_elbo = elbos[i - n // 10:i].mean()
+                progress.set_description('Average ELBO = {:,.2f}'.format(avg_elbo))
     except KeyboardInterrupt:
-        if verbose:
-            elbos = elbos[:i]
-            avg_elbo = elbos[i - n // 10:].mean()
-            print('Interrupted at {0} [{1}%]: Average ELBO = {2}'.format(
-                i, 100 * i // n, avg_elbo.round(2)))
+        elbos = elbos[:i]
+        avg_elbo = elbos[i - n // 10:].mean()
+        pm._log.info('Interrupted at {:,d} [{:.0f}%]: Average ELBO = {:,.2f}'.format(
+            i, 100 * i // n, avg_elbo))
     else:
-        if verbose:
-            avg_elbo = elbos[-n // 10:].mean()
-            print(
-                'Finished [100%]: Average ELBO = {}'.format(avg_elbo.round(2))
-            )
+        avg_elbo = elbos[-n // 10:].mean()
+        pm._log.info('Finished [100%]: Average ELBO = {:,.2f}'.format(avg_elbo))
 
     # Estimated parameters
     l = int(uw_i.size / 2)
@@ -360,7 +351,7 @@ def rvs(x):
 
     range_ = trange(draws) if progressbar else range(draws)
 
-    for i in range_:
+    for _ in range_:
         # 'point' is like {'var1': np.array(0.1), 'var2': np.array(0.2), ...}
         point = {varname: value for varname, value in zip(varnames, f())}
         trace.record(point)

pymc3/variational/advi_minibatch.py

@@ -4,11 +4,11 @@
 import theano
 import theano.tensor as tt
 from theano.sandbox.rng_mrg import MRG_RandomStreams
+import tqdm
 
-from pymc3 import modelcontext, ArrayOrdering, DictToArrayBijection
+import pymc3 as pm
 from pymc3.theanof import reshape_t, inputvars
-from .advi import check_discrete_rvs, ADVIFit, adagrad_optimizer, \
-                  gen_random_state
+from .advi import check_discrete_rvs, ADVIFit, adagrad_optimizer, gen_random_state
 
 __all__ = ['advi_minibatch']
 
@@ -68,7 +68,7 @@ def _get_rvss(
 
 def _init_uw_global_shared(start, global_RVs, global_order):
     start = {v.name: start[v.name] for v in global_RVs}
-    bij = DictToArrayBijection(global_order, start)
+    bij = pm.DictToArrayBijection(global_order, start)
     u_start = bij.map(start)
     w_start = np.zeros_like(u_start)
     uw_start = np.concatenate([u_start, w_start]).astype(floatX_str)
@@ -207,8 +207,7 @@ def advi_minibatch(vars=None, start=None, model=None, n=5000, n_mcsamples=1,
                    minibatch_RVs=None, minibatch_tensors=None,
                    minibatches=None, local_RVs=None, observed_RVs=None,
                    encoder_params=[], total_size=None, optimizer=None,
-                   learning_rate=.001, epsilon=.1, random_seed=None,
-                   verbose=1):
+                   learning_rate=.001, epsilon=.1, random_seed=None):
     """Perform mini-batch ADVI.
 
     This function implements a mini-batch ADVI with the meanfield
@@ -261,12 +260,12 @@ def advi_minibatch(vars=None, start=None, model=None, n=5000, n_mcsamples=1,
     model : Model
         Probabilistic model.
     n : int
-        Number of interations updating parameters.
+        Number of iterations updating parameters.
     n_mcsamples : int
         Number of Monte Carlo samples to approximate ELBO.
     minibatch_RVs : list of ObservedRVs
         Random variables in the model for which mini-batch tensors are set.
-        When this argument is given, both of arguments local_RVs and 
+        When this argument is given, both of arguments local_RVs and
         observed_RVs must be None.
     minibatch_tensors : list of (tensors or shared variables)
         Tensors used to create ObservedRVs in minibatch_RVs.
@@ -306,7 +305,7 @@ def advi_minibatch(vars=None, start=None, model=None, n=5000, n_mcsamples=1,
     """
     theano.config.compute_test_value = 'ignore'
 
-    model = modelcontext(model)
+    model = pm.modelcontext(model)
     vars = inputvars(vars if vars is not None else model.vars)
     start = start if start is not None else model.test_point
     check_discrete_rvs(vars)
@@ -335,8 +334,8 @@ def get_transformed(v):
     global_RVs = list(set(vars) - set(list(local_RVs) + list(observed_RVs)))
 
     # Ordering for concatenation of random variables
-    global_order = ArrayOrdering([v for v in global_RVs])
-    local_order = ArrayOrdering([v for v in local_RVs])
+    global_order = pm.ArrayOrdering([v for v in global_RVs])
+    local_order = pm.ArrayOrdering([v for v in local_RVs])
 
     # ELBO wrt variational parameters
     inarray_g, uw_g, replace_g = _join_global_RVs(global_RVs, global_order)
@@ -387,20 +386,15 @@ def is_shared(t):
 
     # Optimization loop
     elbos = np.empty(n)
-    for i in range(n):
+    progress = tqdm.trange(n)
+    for i in progress:
         e = f(*next(minibatches))
         elbos[i] = e
-        if verbose and not i % (n // 10):
-            if not i:
-                print('Iteration {0} [{1}%]: ELBO = {2}'.format(
-                    i, 100 * i // n, e.round(2)))
-            else:
-                avg_elbo = elbos[i - n // 10:i].mean()
-                print('Iteration {0} [{1}%]: Average ELBO = {2}'.format(
-                    i, 100 * i // n, avg_elbo.round(2)))
-
-    if verbose:
-        print('Finished [100%]: ELBO = {}'.format(elbos[-1].round(2)))
+        if i % (n // 10) == 0 and i > 0:
+            avg_elbo = elbos[i - n // 10:i].mean()
+            progress.set_description('Average ELBO = {:,.2f}'.format(avg_elbo))
+
+    pm._log.info('Finished minibatch ADVI: ELBO = {:,.2f}'.format(elbos[-1]))
 
     # Variational parameters of global RVs
     if 0 < len(global_RVs):