Rename theano.scan.utils.clone to theano.graph.basic.clone_replace

doc/library/index.txt

@@ -58,6 +58,6 @@ There are also some top-level imports that you might find more convenient:
 
     Works like :func:`tensor.dot` for both sparse and dense matrix products
 
-.. autofunction:: theano.clone
+.. autofunction:: theano.clone_replace
 
 .. autofunction:: theano.sparse_grad

tests/sandbox/linalg/test_linalg.py

@@ -52,7 +52,7 @@ def test_rop_lop():
 
     raised = False
     try:
-        theano.gradient.Rop(theano.clone(y, replace={mx: break_op(mx)}), mx, mv)
+        theano.gradient.Rop(theano.clone_replace(y, replace={mx: break_op(mx)}), mx, mv)
     except ValueError:
         raised = True
     if not raised:

tests/scan/test_basic.py

@@ -37,6 +37,7 @@ from theano.gradient import (
     hessian,
     jacobian,
 )
+from theano.graph.basic import clone_replace
 from theano.misc.safe_asarray import _asarray
 from theano.scan.basic import scan
 from theano.scan.op import Scan
@@ -1065,7 +1066,7 @@ class TestScan:
         x0[0] = vx0
         x0 = tt.constant(x0)
         to_replace = outputs[0].owner.inputs[0].owner.inputs[1]
-        outputs = theano.clone(outputs, replace=[(to_replace, x0)])
+        outputs = clone_replace(outputs, replace=[(to_replace, x0)])
         mode = get_mode(None).including("inplace")
         f9 = theano.function([], outputs, updates=updates, mode=mode)
         scan_node = [x for x in f9.maker.fgraph.toposort() if isinstance(x.op, Scan)]
@@ -1981,7 +1982,7 @@ class TestScan:
         z = theano.shared(0.25)
 
         f1 = z * (x + y) ** 2 + 5
-        f2 = theano.clone(f1, replace=None, strict=True, share_inputs=True)
+        f2 = clone_replace(f1, replace=None, strict=True, share_inputs=True)
         f2_inp = theano.graph.basic.graph_inputs([f2])
 
         assert z in f2_inp
@@ -1997,7 +1998,7 @@ class TestScan:
         z = theano.shared(0.25)
 
         f1 = z * (x + y) ** 2 + 5
-        f2 = theano.clone(f1, replace=None, strict=True, share_inputs=False)
+        f2 = clone_replace(f1, replace=None, strict=True, share_inputs=False)
         f2_inp = theano.graph.basic.graph_inputs([f2])
 
         assert z not in f2_inp
@@ -2014,7 +2015,7 @@ class TestScan:
         z = theano.shared(0.25)
 
         f1 = z * (x + y) ** 2 + 5
-        f2 = theano.clone(
+        f2 = clone_replace(
             f1, replace=OrderedDict([(y, y2)]), strict=True, share_inputs=True
         )
         f2_inp = theano.graph.basic.graph_inputs([f2])
@@ -2032,7 +2033,7 @@ class TestScan:
         z = theano.shared(0.25)
 
         f1 = z * (x + y) ** 2 + 5
-        f2 = theano.clone(
+        f2 = clone_replace(
             f1, replace=OrderedDict([(y, y2)]), strict=False, share_inputs=True
         )
         f2_inp = theano.graph.basic.graph_inputs([f2])
@@ -2050,7 +2051,7 @@ class TestScan:
         z = theano.shared(0.25)
 
         f1 = z * (x + y) ** 2 + 5
-        f2 = theano.clone(f1, replace=[(y, y2)], strict=True, share_inputs=False)
+        f2 = clone_replace(f1, replace=[(y, y2)], strict=True, share_inputs=False)
         f2_inp = theano.graph.basic.graph_inputs([f2])
         assert z not in f2_inp
         assert x not in f2_inp
@@ -2066,7 +2067,7 @@ class TestScan:
         z = theano.shared(0.25)
 
         f1 = z * (x + y) ** 2 + 5
-        f2 = theano.clone(f1, replace=[(y, y2)], strict=False, share_inputs=False)
+        f2 = clone_replace(f1, replace=[(y, y2)], strict=False, share_inputs=False)
         f2_inp = theano.graph.basic.graph_inputs([f2])
         assert z not in f2_inp
         assert x not in f2_inp
@@ -4260,7 +4261,7 @@ class TestScan:
                 d = 0.1 + 0 * y
             else:
                 d = 0.1
-            out = theano.clone(y, replace={x: x + d})
+            out = clone_replace(y, replace={x: x + d})
             # theano.printing.debugprint(out)
             return theano.function([], out)()
 

tests/scan/test_opt.py

@@ -94,7 +94,7 @@ class TestGaussNewton:
         # during certain iterations of CG in the HF algorithm. There,
         # it's in fact `pi + current update proposal`.  For simplicity,
         # I just multiply by 2 here.
-        cost_ = theano.clone(cost, replace={pi: 2 * pi for pi in params})
+        cost_ = theano.clone_replace(cost, replace={pi: 2 * pi for pi in params})
 
         # Compute Gauss-Newton-Matrix times some vector `v` which is `p` in CG,
         # but for simplicity, I just take the parameters vector because it's

tests/tensor/test_elemwise.py

@@ -1302,7 +1302,7 @@ def test_gt_grad():
     W = theano.shared(value=W_values, name="weights")
     correct_score = tt.dot(input_, W)
     wrong_input = vector(dtype=floatX)
-    wrong_score = theano.clone(correct_score, {input_: wrong_input})
+    wrong_score = theano.clone_replace(correct_score, {input_: wrong_input})
     # Hinge loss
     scores = tt.ones_like(correct_score) - correct_score + wrong_score
     cost = (scores * (scores > 0)).sum()

tests/test_rop.py

@@ -119,7 +119,9 @@ class RopLopChecker:
 
         assert np.allclose(v1, v2), f"ROP mismatch: {v1} {v2}"
 
-        self.check_nondiff_rop(theano.clone(y, replace={self.mx: break_op(self.mx)}))
+        self.check_nondiff_rop(
+            theano.clone_replace(y, replace={self.mx: break_op(self.mx)})
+        )
 
         vv = np.asarray(self.rng.uniform(size=out_shape), theano.config.floatX)
         yv = Lop(y, self.mx, self.v)
@@ -157,7 +159,11 @@ class RopLopChecker:
         assert np.allclose(v1, v2), f"ROP mismatch: {v1} {v2}"
 
         try:
-            Rop(theano.clone(y, replace={self.x: break_op(self.x)}), self.x, self.v)
+            Rop(
+                theano.clone_replace(y, replace={self.x: break_op(self.x)}),
+                self.x,
+                self.v,
+            )
         except ValueError:
             pytest.skip(
                 "Rop does not handle non-differentiable inputs "

theano/__init__.py

@@ -147,7 +147,10 @@ def sparse_grad(var):
 
 
 import theano.tensor.random.var
-from theano.scan import checkpoints, clone, foldl, foldr, map, reduce, scan
+from theano.graph.basic import clone_replace
+from theano.scan import checkpoints
+from theano.scan.basic import scan
+from theano.scan.views import foldl, foldr, map, reduce
 
 
 # Some config variables are registered by submodules. Only after all those imports

theano/compile/builders.py

@@ -781,12 +781,12 @@ class OpFromGraph(Op):
         # Clone the output shape so that shape are computed from outer inputs.
         # Note:
         # Here we can do it more simply like:
-        #      ret = [theano.clone(shp, replace=repl) for shp in out_shp]
+        #      ret = [theano.clone_replace(shp, replace=repl) for shp in out_shp]
         # But  doing it multiple time could duplicate common subgraph between
         # each shape call. Theano optimizer will clean this up later, but this
         # will ask extra work to the optimizer.
         repl = dict(zip(self.local_inputs, node.inputs))
-        cloned = theano.clone(reduce(tuple.__add__, out_shp), replace=repl)
+        cloned = theano.clone_replace(reduce(tuple.__add__, out_shp), replace=repl)
         ret = []
         used = 0
         for i in range(len(out_shp)):
@@ -824,7 +824,7 @@ def inline_ofg_expansion(fgraph, node):
         return False
     if not op.is_inline:
         return False
-    return theano.clone(
+    return theano.clone_replace(
         op.local_outputs, {u: v for u, v in zip(node.op.local_inputs, node.inputs)}
     )
 

theano/compile/function/pfunc.py

@@ -454,9 +454,9 @@ def pfunc(
                 "has no effect. One way to modify an input `x` to a function "
                 "evaluating f(x) is to define a new input `y` and use "
                 "`theano.function([y], f(x), givens={x: g(y)})`. Another "
-                "solution consists in using `theano.clone`, e.g. like this: "
+                "solution consists in using `theano.clone_replace`, e.g. like this: "
                 "`theano.function([x], "
-                "theano.clone(f(x), replace={x: g(x)}))`."
+                "theano.clone_replace(f(x), replace={x: g(x)}))`."
             )
 
     # Extend the outputs with the updates on input variables so they are also

theano/gpuarray/opt.py

@@ -151,7 +151,7 @@ from theano.gpuarray.type import (
     move_to_gpu,
 )
 from theano.graph import toolbox
-from theano.graph.basic import Constant, Variable, applys_between
+from theano.graph.basic import Constant, Variable, applys_between, clone_replace
 from theano.graph.fg import FunctionGraph
 from theano.graph.opt import (
     GlobalOptimizer,
@@ -165,7 +165,6 @@ from theano.link.c.basic import CLinker
 from theano.misc.ordered_set import OrderedSet
 from theano.scalar.basic import Cast, Pow, Scalar, log, neg, true_div
 from theano.scalar.basic_scipy import Erfcinv, Erfinv
-from theano.scan import utils
 from theano.scan.op import Scan
 from theano.scan.opt import ScanInplaceOptimizer
 from theano.tensor.basic import (
@@ -2661,7 +2660,7 @@ def gpu_reconstruct_graph(inputs, outputs, tag=None):
     givens = {}
     for nw_x, x in zip(nw_inputs, inputs):
         givens[x] = nw_x
-    nw_outputs = utils.clone(outputs, replace=givens)
+    nw_outputs = clone_replace(outputs, replace=givens)
     return (nw_inputs, nw_outputs)
 
 
@@ -2689,7 +2688,7 @@ def local_gpua_scan_to_gpua(fgraph, op, context_name, inputs, outputs):
         scan_outs += [op.outputs[-1]]
     else:
         scan_outs = [safe_to_gpu(x, context_name) for x in op.outputs]
-    scan_outs = utils.clone(
+    scan_outs = clone_replace(
         scan_outs, replace=list(zip(op.inputs, (safe_to_cpu(x) for x in scan_ins)))
     )
 

theano/graph/basic.py

@@ -16,6 +16,7 @@ from typing import (
     Optional,
     Sequence,
     Set,
+    Tuple,
     TypeVar,
     Union,
 )
@@ -863,7 +864,12 @@ def applys_between(
     )
 
 
-def clone(inputs, outputs, copy_inputs=True, copy_orphans=None):
+def clone(
+    inputs: Collection[Variable],
+    outputs: Collection[Variable],
+    copy_inputs: bool = True,
+    copy_orphans: Optional[bool] = None,
+) -> Tuple[Collection[Variable], Collection[Variable]]:
     """Copies the sub-graph contained between inputs and outputs.
 
     Parameters
@@ -898,7 +904,13 @@ def clone(inputs, outputs, copy_inputs=True, copy_orphans=None):
     return [equiv[input] for input in inputs], [equiv[output] for output in outputs]
 
 
-def clone_get_equiv(inputs, outputs, copy_inputs=True, copy_orphans=True, memo=None):
+def clone_get_equiv(
+    inputs: Collection[Variable],
+    outputs: Collection[Variable],
+    copy_inputs: bool = True,
+    copy_orphans: bool = True,
+    memo: Optional[Dict[Variable, Variable]] = None,
+):
     """
     Return a dictionary that maps from Variable and Apply nodes in the
     original graph to a new node (a clone) in a new graph.
@@ -960,6 +972,60 @@ def clone_get_equiv(inputs, outputs, copy_inputs=True, copy_orphans=True, memo=N
     return memo
 
 
+def clone_replace(
+    output: Collection[Variable],
+    replace: Optional[Dict[Variable, Variable]] = None,
+    strict: bool = True,
+    share_inputs: bool = True,
+) -> Collection[Variable]:
+    """Clone a graph and replace subgraphs within it.
+
+    It returns a copy of the initial subgraph with the corresponding
+    substitutions.
+
+    Parameters
+    ----------
+    output : Theano Variables (or Theano expressions)
+        Theano expression that represents the computational graph.
+    replace : dict
+        Dictionary describing which subgraphs should be replaced by what.
+    share_inputs : bool
+        If True, use the same inputs (and shared variables) as the original
+        graph. If False, clone them. Note that cloned shared variables still
+        use the same underlying storage, so they will always have the same
+        value.
+
+    """
+    from theano.compile.function.pfunc import rebuild_collect_shared
+
+    if isinstance(replace, dict):
+        items = list(replace.items())
+    elif isinstance(replace, (list, tuple)):
+        items = replace
+    elif replace is None:
+        items = []
+    else:
+        raise ValueError(
+            (
+                "replace is neither a dictionary, list, "
+                f"tuple or None ! The value provided is {replace},"
+                f"of type {type(replace)}"
+            )
+        )
+    tmp_replace = [(x, x.type()) for x, y in items]
+    new_replace = [(x, y) for ((_, x), (_, y)) in zip(tmp_replace, items)]
+    _, _outs, _ = rebuild_collect_shared(
+        output, [], tmp_replace, [], strict, share_inputs
+    )
+
+    # TODO Explain why we call it twice ?!
+    _, outs, _ = rebuild_collect_shared(
+        _outs, [], new_replace, [], strict, share_inputs
+    )
+
+    return outs
+
+
 def general_toposort(
     outputs: Iterable[T],
     deps: Callable[[T], Union[OrderedSet, List[T]]],

theano/ifelse.py

@@ -19,10 +19,9 @@ import numpy as np
 import theano.tensor
 from theano.compile import optdb
 from theano.configdefaults import config
-from theano.graph.basic import Apply, Variable, is_in_ancestors
+from theano.graph.basic import Apply, Variable, clone_replace, is_in_ancestors
 from theano.graph.op import _NoPythonOp
 from theano.graph.opt import GlobalOptimizer, local_optimizer
-from theano.scan.utils import clone
 from theano.tensor import opt
 from theano.tensor.type import TensorType
 
@@ -540,8 +539,8 @@ def ifelse_lift_single_if_through_acceptable_ops(fgraph, main_node):
             false_ins.append(x)
     true_eval = mop(*true_ins, **dict(return_list=True))
     false_eval = mop(*false_ins, **dict(return_list=True))
-    # true_eval  = clone(outs, replace = dict(zip(node.outputs, ts)))
-    # false_eval = clone(outs, replace = dict(zip(node.outputs, fs)))
+    # true_eval  = clone_replace(outs, replace = dict(zip(node.outputs, ts)))
+    # false_eval = clone_replace(outs, replace = dict(zip(node.outputs, fs)))
 
     nw_outs = ifelse(node.inputs[0], true_eval, false_eval, return_list=True)
     return nw_outs
@@ -641,7 +640,7 @@ class CondMerge(GlobalOptimizer):
                 )
                 print("here")
                 new_outs = new_ifelse(*new_ins, **dict(return_list=True))
-                new_outs = [clone(x) for x in new_outs]
+                new_outs = [clone_replace(x) for x in new_outs]
                 old_outs = []
                 if type(merging_node.outputs) not in (list, tuple):
                     old_outs += [merging_node.outputs]
@@ -752,7 +751,7 @@ def cond_merge_random_op(fgraph, main_node):
             else:
                 old_outs += proposal.outputs
             pairs = list(zip(old_outs, new_outs))
-            main_outs = clone(main_node.outputs, replace=pairs)
+            main_outs = clone_replace(main_node.outputs, replace=pairs)
             return main_outs
 
 

theano/scan/__init__.py

@@ -43,9 +43,9 @@ __authors__ = (
     "James Bergstra "
     "Pascal Lamblin "
     "Arnaud Bergeron "
+    "PyMC Developers "
 )
 __copyright__ = "(c) 2010, Universite de Montreal"
-__contact__ = "Razvan Pascanu <r.pascanu@gmail>"
 
 from theano import configdefaults
 
@@ -55,5 +55,5 @@ configdefaults.add_scan_configvars()
 from theano.scan import opt
 from theano.scan.basic import scan
 from theano.scan.checkpoints import scan_checkpoints
-from theano.scan.utils import clone, until
+from theano.scan.utils import until
 from theano.scan.views import foldl, foldr, map, reduce

theano/scan/basic.py

@@ -19,7 +19,7 @@ from theano.compile import SharedVariable, ops
 from theano.compile.function import function
 from theano.compile.mode import Mode
 from theano.configdefaults import config
-from theano.graph.basic import Constant, Variable, graph_inputs
+from theano.graph.basic import Constant, Variable, clone_replace, graph_inputs
 from theano.graph.fg import MissingInputError
 from theano.graph.op import get_test_value
 from theano.graph.utils import TestValueError
@@ -798,7 +798,7 @@ def scan(
     if condition is not None:
         outputs.append(condition)
     fake_nonseqs = [x.type() for x in non_seqs]
-    fake_outputs = utils.clone(
+    fake_outputs = clone_replace(
         outputs, replace=OrderedDict(zip(non_seqs, fake_nonseqs))
     )
     all_inputs = filter(
@@ -1025,7 +1025,7 @@ def scan(
     else:
         new_givens = givens
 
-    new_outs = utils.clone(inner_outs, replace=new_givens)
+    new_outs = clone_replace(inner_outs, replace=new_givens)
 
     ##
     # Step 7. Create the Scan Op

theano/scan/op.py

@@ -65,6 +65,7 @@ from theano.graph.basic import (
     Apply,
     Constant,
     Variable,
+    clone_replace,
     equal_computations,
     graph_inputs,
     io_connection_pattern,
@@ -75,13 +76,7 @@ from theano.graph.toolbox import NoOutputFromInplace
 from theano.link.c.basic import CLinker
 from theano.link.c.exceptions import MissingGXX
 from theano.link.utils import raise_with_op
-from theano.scan.utils import (
-    Validator,
-    clone,
-    forced_replace,
-    hash_listsDictsTuples,
-    safe_new,
-)
+from theano.scan.utils import Validator, forced_replace, hash_listsDictsTuples, safe_new
 from theano.tensor.basic import as_tensor_variable
 from theano.tensor.opt import Shape_i
 from theano.tensor.type import TensorType, integer_dtypes
@@ -2485,7 +2480,7 @@ class Scan(Op):
                         replacement = inner_inp_mitmot[-replacement_idx]
 
                         self.tap_array[idx]
-                        new_inner_out_mitmot = clone(
+                        new_inner_out_mitmot = clone_replace(
                             new_inner_out_mitmot, replace=[(to_replace, replacement)]
                         )
 

theano/scan/opt.py

@@ -66,6 +66,7 @@ from theano.configdefaults import config
 from theano.graph.basic import (
     Constant,
     Variable,
+    clone_replace,
     equal_computations,
     graph_inputs,
     io_toposort,
@@ -78,7 +79,6 @@ from theano.graph.optdb import EquilibriumDB, SequenceDB
 from theano.graph.toolbox import ReplaceValidate
 from theano.scan.op import Scan
 from theano.scan.utils import (
-    clone,
     compress_outs,
     expand_empty,
     reconstruct_graph,
@@ -231,7 +231,7 @@ def remove_constants_and_unused_inputs_scan(fgraph, node):
     nw_outer.extend(nw_outer_nonseq)
 
     if len(nw_inner) != len(op_ins):
-        op_outs = clone(op_outs, replace=givens)
+        op_outs = clone_replace(op_outs, replace=givens)
         nw_info = copy.deepcopy(op.info)
         nw_info["n_seqs"] = nw_n_seqs
         # DEBUG CHECK
@@ -403,7 +403,7 @@ class PushOutNonSeqScan(GlobalOptimizer):
                     nw_outer.append(repl_out)
                 givens[to_repl] = repl_in
 
-            op_outs = clone(clean_outputs, replace=givens)
+            op_outs = clone_replace(clean_outputs, replace=givens)
             op_ins = clean_inputs + nw_inner
 
             # Reconstruct node
@@ -662,7 +662,7 @@ class PushOutSeqScan(GlobalOptimizer):
 
                 givens[to_repl] = repl_in
 
-            op_outs = clone(clean_outputs, replace=givens)
+            op_outs = clone_replace(clean_outputs, replace=givens)
             op_ins = nw_inner + clean_inputs
 
             # Reconstruct node
@@ -2005,7 +2005,7 @@ def scan_merge_inouts(fgraph, node):
         outer_inputs = a.outer_inputs
         info = a.info
         a_inner_outs = a.inner_outputs
-        inner_outputs = clone(a_inner_outs, replace=inp_equiv)
+        inner_outputs = clone_replace(a_inner_outs, replace=inp_equiv)
 
         op = Scan(inner_inputs, inner_outputs, info)
         outputs = op(*outer_inputs)

theano/scan/utils.py

@@ -7,9 +7,9 @@ __authors__ = (
     "James Bergstra "
     "Pascal Lamblin "
     "Arnaud Bergeron"
+    "PyMC Developers"
 )
 __copyright__ = "(c) 2010, Universite de Montreal"
-__contact__ = "Razvan Pascanu <r.pascanu@gmail>"
 
 
 import copy
@@ -21,9 +21,14 @@ import numpy as np
 
 from theano import scalar as ts
 from theano import tensor as tt
-from theano.compile.function.pfunc import rebuild_collect_shared
 from theano.configdefaults import config
-from theano.graph.basic import Constant, Variable, equal_computations, graph_inputs
+from theano.graph.basic import (
+    Constant,
+    Variable,
+    clone_replace,
+    equal_computations,
+    graph_inputs,
+)
 from theano.graph.fg import FunctionGraph
 from theano.graph.op import get_test_value
 from theano.graph.opt import TopoOptimizer, local_optimizer
@@ -180,54 +185,6 @@ def hash_listsDictsTuples(x):
     return hash_value
 
 
-def clone(output, replace=None, strict=True, share_inputs=True):
-    """
-    Function that allows replacing subgraphs of a computational graph.
-
-    It returns a copy of the initial subgraph with the corresponding
-    substitutions.
-
-    Parameters
-    ----------
-    output : Theano Variables (or Theano expressions)
-        Theano expression that represents the computational graph.
-    replace : dict
-        Dictionary describing which subgraphs should be replaced by what.
-    share_inputs : bool
-        If True, use the same inputs (and shared variables) as the original
-        graph. If False, clone them. Note that cloned shared variables still
-        use the same underlying storage, so they will always have the same
-        value.
-
-    """
-    if isinstance(replace, dict):
-        items = list(replace.items())
-    elif isinstance(replace, (list, tuple)):
-        items = replace
-    elif replace is None:
-        items = []
-    else:
-        raise ValueError(
-            (
-                "replace is neither a dictionary, list, "
-                f"tuple or None ! The value provided is {replace},"
-                f"of type {type(replace)}"
-            )
-        )
-    tmp_replace = [(x, x.type()) for x, y in items]
-    new_replace = [(x, y) for ((_, x), (_, y)) in zip(tmp_replace, items)]
-    _, _outs, _ = rebuild_collect_shared(
-        output, [], tmp_replace, [], strict, share_inputs
-    )
-
-    # TODO Explain why we call it twice ?!
-    _, outs, _ = rebuild_collect_shared(
-        _outs, [], new_replace, [], strict, share_inputs
-    )
-
-    return outs
-
-
 def map_variables(replacer, graphs, additional_inputs=None):
     """Construct new graphs based on 'graphs' with some variables replaced
     according to 'replacer'.
@@ -285,7 +242,7 @@ def map_variables(replacer, graphs, additional_inputs=None):
         for input_, new_input in zip(inputs_, new_inputs)
         if new_input is not input_
     ]
-    graphs = clone(graphs, share_inputs=True, replace=replacements)
+    graphs = clone_replace(graphs, share_inputs=True, replace=replacements)
     inputs_ = list(set(list(graph_inputs(graphs)) + list(additional_inputs)))
 
     fg = FunctionGraph(inputs_, graphs, clone=False)
@@ -426,7 +383,9 @@ def _map_variables_inner(
 
         replacements.extend(outer_to_inner.items())
 
-        (new_graph,) = clone([new_graph], share_inputs=True, replace=replacements)
+        (new_graph,) = clone_replace(
+            [new_graph], share_inputs=True, replace=replacements
+        )
         return new_graph
 
     new_inner_outputs = map_variables(inner_replacer, inner_outputs)
@@ -908,7 +867,7 @@ def reconstruct_graph(inputs, outputs, tag=None):
         if isinstance(inp, Constant):
             givens[inp] = inp.clone()
 
-    nw_outputs = clone(outputs, replace=givens)
+    nw_outputs = clone_replace(outputs, replace=givens)
     return (nw_inputs, nw_outputs)
 
 
@@ -1187,4 +1146,4 @@ def forced_replace(out, x, y):
 
     if len(to_replace) == 0:
         return out
-    return clone(out, replace=to_replace)
+    return clone_replace(out, replace=to_replace)