Deprecate Model.update_start_vals method

Author: michaelosthege

pymc/model.py

@@ -1522,25 +1522,10 @@ def update_start_vals(self, a: Dict[str, np.ndarray], b: Dict[str, np.ndarray]):
         conditional on the values of `b` and stored in `b`.
 
         """
-        # TODO FIXME XXX: If we're going to incrementally update transformed
-        # variables, we should do it in topological order.
-        for a_name, a_value in tuple(a.items()):
-            # If the name is a random variable, get its value variable and
-            # potentially transform it
-            var = self.named_vars.get(a_name, None)
-            value_var = self.rvs_to_values.get(var, None)
-            if value_var:
-                transform = getattr(value_var.tag, "transform", None)
-                if transform:
-                    fval_graph = transform.forward(var, a_value)
-                    (fval_graph,), _ = rvs_to_value_vars((fval_graph,), apply_transforms=True)
-                    fval_graph_inputs = {i: b[i.name] for i in inputvars(fval_graph) if i.name in b}
-                    rv_var_value = fval_graph.eval(fval_graph_inputs)
-                    # Why are these transformed values stored in `b`?  They're
-                    # not going to be used to update `a`.
-                    b[value_var.name] = rv_var_value
-
-        a.update({k: v for k, v in b.items() if k not in a})
+        raise DeprecationWarning(
+            "The `Model.update_start_vals` method was removed."
+            " To change initial values you may set the items of `Model.initial_values` directly."
+        )
 
     def eval_rv_shapes(self) -> Dict[str, Tuple[int, ...]]:
         """Evaluates shapes of untransformed AND transformed free variables.

pymc/tests/test_model.py

@@ -533,68 +533,6 @@ def test_point_logps():
     assert "a" in logp_vals.keys()
 
 
-class TestUpdateStartVals(SeededTest):
-    def setup_method(self):
-        super().setup_method()
-
-    def test_soft_update_all_present(self):
-        model = pm.Model()
-        start = {"a": 1, "b": 2}
-        test_point = {"a": 3, "b": 4}
-        model.update_start_vals(start, test_point)
-        assert start == {"a": 1, "b": 2}
-
-    def test_soft_update_one_missing(self):
-        model = pm.Model()
-        start = {
-            "a": 1,
-        }
-        test_point = {"a": 3, "b": 4}
-        model.update_start_vals(start, test_point)
-        assert start == {"a": 1, "b": 4}
-
-    def test_soft_update_empty(self):
-        model = pm.Model()
-        start = {}
-        test_point = {"a": 3, "b": 4}
-        model.update_start_vals(start, test_point)
-        assert start == test_point
-
-    def test_soft_update_transformed(self):
-        with pm.Model() as model:
-            pm.Exponential("a", 1)
-        start = {"a": 2.0}
-        test_point = {"a_log__": 0}
-        model.update_start_vals(start, test_point)
-        assert_almost_equal(np.exp(start["a_log__"]), start["a"])
-
-    def test_soft_update_parent(self):
-        with pm.Model() as model:
-            a = pm.Uniform("a", lower=0.0, upper=1.0)
-            b = pm.Uniform("b", lower=2.0, upper=3.0)
-            pm.Uniform("lower", lower=a, upper=3.0)
-            pm.Uniform("upper", lower=0.0, upper=b)
-            pm.Uniform("interv", lower=a, upper=b)
-
-        initial_point = {
-            "a_interval__": np.array(0.0, dtype=aesara.config.floatX),
-            "b_interval__": np.array(0.0, dtype=aesara.config.floatX),
-            "lower_interval__": np.array(0.0, dtype=aesara.config.floatX),
-            "upper_interval__": np.array(0.0, dtype=aesara.config.floatX),
-            "interv_interval__": np.array(0.0, dtype=aesara.config.floatX),
-        }
-        start = {"a": 0.3, "b": 2.1, "lower": 1.4, "upper": 1.4, "interv": 1.4}
-        test_point = {
-            "lower_interval__": -0.3746934494414109,
-            "upper_interval__": 0.693147180559945,
-            "interv_interval__": 0.4519851237430569,
-        }
-        model.update_start_vals(start, initial_point)
-        assert_almost_equal(start["lower_interval__"], test_point["lower_interval__"])
-        assert_almost_equal(start["upper_interval__"], test_point["upper_interval__"])
-        assert_almost_equal(start["interv_interval__"], test_point["interv_interval__"])
-
-
 class TestShapeEvaluation:
     def test_eval_rv_shapes(self):
         with pm.Model(
@@ -626,17 +564,21 @@ def test_valid_start_point(self):
             a = pm.Uniform("a", lower=0.0, upper=1.0)
             b = pm.Uniform("b", lower=2.0, upper=3.0)
 
-        start = {"a": 0.3, "b": 2.1}
-        model.update_start_vals(start, model.initial_point)
+        start = {
+            "a_interval__": model.rvs_to_values[a].tag.transform.forward(a, 0.3).eval(),
+            "b_interval__": model.rvs_to_values[b].tag.transform.forward(b, 2.1).eval(),
+        }
         model.check_start_vals(start)
 
     def test_invalid_start_point(self):
         with pm.Model() as model:
             a = pm.Uniform("a", lower=0.0, upper=1.0)
             b = pm.Uniform("b", lower=2.0, upper=3.0)
 
-        start = {"a": np.nan, "b": np.nan}
-        model.update_start_vals(start, model.initial_point)
+        start = {
+            "a_interval__": np.nan,
+            "b_interval__": model.rvs_to_values[b].tag.transform.forward(b, 2.1).eval(),
+        }
         with pytest.raises(pm.exceptions.SamplingError):
             model.check_start_vals(start)
 
@@ -645,8 +587,11 @@ def test_invalid_variable_name(self):
             a = pm.Uniform("a", lower=0.0, upper=1.0)
             b = pm.Uniform("b", lower=2.0, upper=3.0)
 
-        start = {"a": 0.3, "b": 2.1, "c": 1.0}
-        model.update_start_vals(start, model.initial_point)
+        start = {
+            "a_interval__": model.rvs_to_values[a].tag.transform.forward(a, 0.3).eval(),
+            "b_interval__": model.rvs_to_values[b].tag.transform.forward(b, 2.1).eval(),
+            "c": 1.0,
+        }
         with pytest.raises(KeyError):
             model.check_start_vals(start)