tensor_stream 0.9.8 → 0.9.9

data/lib/tensor_stream/evaluator/ruby/nn_ops.rb

@@ -7,21 +7,22 @@ module TensorStream
           target_var, learning_rate, delta = inputs
           assign = tensor.inputs[0] || tensor
 
-          assign.value = process_vector_math_op(tensor, target_var, delta, context, ->(t, u) { t - u * learning_rate })
-          assign.value
+          assign.container = process_vector_math_op(tensor, target_var, delta, context, ->(t, u) { t - u * learning_rate })
+          assign.container
         end
 
-        register_op :apply_momentum do |context, tensor, inputs|
+        register_op :apply_momentum do |_context, tensor, inputs|
           target_var, momentum_var, learning_rate, grad, momentum = inputs
           assign = tensor.inputs[0] || tensor
           assign_acc = tensor.inputs[1]
-          assign_acc.value = multi_array_op(->(t, u) { t * momentum + u }, momentum_var, grad)
-          assign.value = if tensor.options[:use_nesterov]
-                           multi_array_op(->(v, g, acc) { v - (g * learning_rate + acc * momentum * learning_rate) }, target_var, grad, momentum_var)
-                         else
-                           multi_array_op(->(v, acc) { v - acc * learning_rate }, target_var, momentum_var)
-                         end
-          assign.value
+          assign_acc.container = multi_array_op(->(t, u) { t * momentum + u }, momentum_var, grad)
+          assign.container = if tensor.options[:use_nesterov]
+                               multi_array_op(->(v, g, acc) { v - (g * learning_rate + acc * momentum * learning_rate) }, target_var, grad, momentum_var)
+                             else
+                               multi_array_op(->(v, acc) { v - acc * learning_rate }, target_var, momentum_var)
+                             end
+
+          assign.container
         end
 
         register_op :apply_adadelta do |_context, tensor, inputs|
@@ -29,19 +30,19 @@ module TensorStream
           assign = tensor.inputs[0] || tensor
           assign_acc = tensor.inputs[1]
           assign_acc_update = tensor.inputs[2]
-          assign_acc.value = multi_array_op(->(acc_t, grad_t) { acc_t * rho + (grad_t * grad_t) * (1.0 - rho) }, accum, grad)
-          update = multi_array_op(->(acc_update_t, acc_t, grad_t) { Math.sqrt(acc_update_t + epsilon) * (1.0 / Math.sqrt(acc_t + epsilon)) * grad_t }, accum_update, assign_acc.value, grad)
-          assign.value = multi_array_op(->(v, u) { v - (u * lr) }, target_var, update)
-          assign_acc_update.value = multi_array_op(->(acc_update_t, u) { acc_update_t * rho + (u * u) * (1.0 - rho) }, accum_update, update)
+          assign_acc.container = multi_array_op(->(acc_t, grad_t) { acc_t * rho + (grad_t * grad_t) * (1.0 - rho) }, accum, grad)
+          update = multi_array_op(->(acc_update_t, acc_t, grad_t) { Math.sqrt(acc_update_t + epsilon) * (1.0 / Math.sqrt(acc_t + epsilon)) * grad_t }, accum_update, assign_acc.container, grad)
+          assign.container = multi_array_op(->(v, u) { v - (u * lr) }, target_var, update)
+          assign_acc_update.container = multi_array_op(->(acc_update_t, u) { acc_update_t * rho + (u * u) * (1.0 - rho) }, accum_update, update)
 
-          assign.value
+          assign.container
         end
 
         register_op :apply_adagrad do |_context, tensor, inputs|
           target_var, accum, lr, grad = inputs
           assign = tensor.inputs[0] || tensor
-          assign.value = multi_array_op(->(v, a, g) { v - (g * lr * (1.0 / Math.sqrt(a))) }, target_var, accum, grad)
-          assign.value
+          assign.container = multi_array_op(->(v, a, g) { v - (g * lr * (1.0 / Math.sqrt(a))) }, target_var, accum, grad)
+          assign.container
         end
 
         register_op :apply_adam do |_context, tensor, inputs|
@@ -51,10 +52,10 @@ module TensorStream
           assign_m = tensor.inputs[1]
           assign_v = tensor.inputs[2]
 
-          assign_m.value = multi_array_op(->(u_d , g) { u_d + (g - u_d) * (1.0 - beta1_t) }, m, grad)
-          assign_v.value = multi_array_op(->(u_d , v_d) { u_d + (v_d**2 - u_d) * (1.0 - beta2_t)},  v, grad)
-          assign.value = multi_array_op(->(t, m_d , v_d) { t - ((m_d * alpha) / (Math.sqrt(v_d) + epsilon_t)) }, target_var, assign_m.value, assign_v.value)
-          assign.value
+          assign_m.container = multi_array_op(->(u_d , g) { u_d + (g - u_d) * (1.0 - beta1_t) }, m, grad)
+          assign_v.container = multi_array_op(->(u_d , v_d) { u_d + (v_d**2 - u_d) * (1.0 - beta2_t)},  v, grad)
+          assign.container = multi_array_op(->(t, m_d , v_d) { t - ((m_d * alpha) / (Math.sqrt(v_d) + epsilon_t)) }, target_var, assign_m.container, assign_v.container)
+          assign.container
         end
 
         register_op :apply_rms_prop do |_context, tensor, inputs|
@@ -62,9 +63,9 @@ module TensorStream
           assign = tensor.inputs[0]
           assign_ms = tensor.inputs[1]
           assign_mom = tensor.inputs[2]
-          assign_ms.value = multi_array_op(->(g, m) { m + (g * g - m) * (1.0 - rho)}, grad, ms)
-          assign_mom.value = multi_array_op(->(mom_t, g, m) { mom_t * momentum + (g * lr) / Math.sqrt(m + epsilon)}, mom, grad, assign_ms.value)
-          assign.value = multi_array_op(->(v, m) { v - m }, var, assign_mom.value)
+          assign_ms.container = multi_array_op(->(g, m) { m + (g * g - m) * (1.0 - rho)}, grad, ms)
+          assign_mom.container = multi_array_op(->(mom_t, g, m) { mom_t * momentum + (g * lr) / Math.sqrt(m + epsilon)}, mom, grad, assign_ms.container)
+          assign.container = multi_array_op(->(v, m) { v - m }, var, assign_mom.container)
         end
 
         register_op :apply_centered_rms_prop do |_context, tensor, inputs|
@@ -74,11 +75,11 @@ module TensorStream
           assign_ms = tensor.inputs[2]
           assign_mom = tensor.inputs[3]
 
-          assign_ms.value = multi_array_op(->(g, m) { m + (g * g - m) * (1.0 - rho) }, grad, ms)
-          assign_mg.value = multi_array_op(->(g, mg_t) {  (g - mg_t) * (1.0 - rho) }, grad, mg)
-          denom =  multi_array_op(->(s, mg_t) { (s - mg_t * mg_t) + epsilon }, assign_ms.value, mg)
-          assign_mom.value = multi_array_op(->(mom_t, g, d) { mom_t * momentum + (g * lr) / Math.sqrt(d)}, mom, grad, denom)
-          assign.value = multi_array_op(->(v, m) { v - m }, var, assign_mom.value)
+          assign_ms.container = multi_array_op(->(g, m) { m + (g * g - m) * (1.0 - rho) }, grad, ms)
+          assign_mg.container = multi_array_op(->(g, mg_t) {  (g - mg_t) * (1.0 - rho) }, grad, mg)
+          denom =  multi_array_op(->(s, mg_t) { (s - mg_t * mg_t) + epsilon }, assign_ms.container, mg)
+          assign_mom.container = multi_array_op(->(mom_t, g, d) { mom_t * momentum + (g * lr) / Math.sqrt(d)}, mom, grad, denom)
+          assign.container = multi_array_op(->(v, m) { v - m }, var, assign_mom.container)
         end
 
         register_op %i[softmax_cross_entropy_with_logits_v2 softmax_cross_entropy_with_logits] do |_context, tensor, inputs|
@@ -103,7 +104,7 @@ module TensorStream
           else
             losses = []
             backprobs = []
-            arr = last_dimen_list.zip(labels).each do |list, label|
+            last_dimen_list.zip(labels).each do |list, label|
               loss, prob = func.call(list, label)
               losses << loss
               backprobs << prob

data/lib/tensor_stream/evaluator/ruby/random_ops.rb

@@ -54,9 +54,9 @@ module TensorStream
           random = _get_randomizer(tensor, seed)
           generator = -> { r.rand }
           shape = inputs[0] || tensor.shape.shape
-          random_values = Array.new(shape.reduce(:*) || 1) {
+          random_values = Array.new(shape.reduce(:*) || 1) do
             generator.call
-          }
+          end
           mean = random_values.reduce(:+) / random_values.size
 
           # standard deviation
@@ -80,20 +80,20 @@ module TensorStream
           cutoff = 2.0 * Math.exp( 0.5 + (norm_min * (norm_min - sqrt_factor)) / 4.0 ) / (norm_min + sqrt_factor)
           diff = norm_max - norm_min;
 
-          val = random_values.map { |v|
+          val = random_values.map do |v|
             iterations = 0
             pick = v
-            while ( (pick > norm_max) || (pick < norm_min) )
+            while (pick > norm_max) || (pick < norm_min)
               pick = generator.call
               iterations += 1
-              if iterations > 100
+              if iterations > max_iterations
                 pick = v
                 break
               end
             end
 
             pick 
-          }
+          end
 
           TensorShape.reshape(val, shape)
         end

data/lib/tensor_stream/evaluator/ruby_evaluator.rb

@@ -50,14 +50,10 @@ module TensorStream
         child_context = execution_context.dup
         res = if tensor.is_a?(Operation)
                 eval_operation(tensor, child_context)
-              elsif tensor.is_a?(Variable)
-                eval_variable(tensor, child_context)
-              elsif tensor.is_a?(Placeholder)
-                resolve_placeholder(tensor, child_context)
-              elsif tensor.is_a?(OutputGroup)
-                tensor.outputs[0]
+              elsif !tensor.is_a?(Tensor)
+                tensor
               else
-                eval_tensor(tensor, child_context)
+                tensor.op
               end
         execution_context.deep_merge!(returns: child_context[:returns])
         res
@@ -88,7 +84,6 @@ module TensorStream
 
       def prepare_input(tensor, context, options = {})
         return nil unless tensor
-        tensor = resolve_placeholder(tensor)
         if options[:noop]
           tensor
         elsif options[:no_eval]
@@ -98,27 +93,16 @@ module TensorStream
         end
       end
 
-      def eval_variable(tensor, child_context)
-        value = tensor.read_value
-        raise "variable #{tensor.name} not initalized" if value.nil?
-
-        eval_tensor(value, child_context).tap do |val|
-          child_context[:returns] ||= {}
-          child_context[:returns][:vars] ||= []
-          child_context[:returns][:vars] << { name: tensor.name, val: val }
-        end
-      end
-
       register_op(:no_op, no_eval: true) do |_context, _tensor, inputs|
         inputs
       end
 
-      register_op(:const) do |_context, _tensor, inputs|
-        inputs[0]
+      register_op(:const) do |_context, tensor, _inputs|
+        tensor.options[:value]
       end
 
       register_op(:cast) do |context, tensor, inputs|
-        call_op(tensor, inputs[0], context, ->(t, _b) { Tensor.cast_dtype(t, tensor.data_type) })
+        call_op(inputs[0], context, ->(t, _b) { Tensor.cast_dtype(t, tensor.data_type) })
       end
 
       register_op(:sign) do |context, tensor, inputs|
@@ -134,7 +118,7 @@ module TensorStream
           end
         }
 
-        call_op(tensor, inputs[0], context, func)
+        call_op(inputs[0], context, func)
       end
 
       register_op(:logical_and) do |context, tensor, inputs|
@@ -149,14 +133,33 @@ module TensorStream
         call_vector_op(tensor, :not_equal, inputs[0], inputs[1], context, ->(t, u) { t != u })
       end
 
-      def merge_dynamic_stitch(merged, indexes, data)
-        indexes.each_with_index do |ind, m|
-          if ind.is_a?(Array)
-            merge_dynamic_stitch(merged, ind, data[m])
-          else
-            merged[ind] = data[m]
+      register_op :placeholder, no_eval: true do |context, tensor, _inputs|
+        ph = @context[tensor.name.to_sym].tap do |c|
+          raise TensorStream::ValueError, "missing placeholder #{tensor.name}" if c.nil?
+
+          if tensor.shape.shape
+            value_shape = shape_eval(c)
+            placeholder_shape = tensor.shape.shape
+            placeholder_shape.zip(value_shape).each do |p_shape, v_shape|
+              next if p_shape.nil?
+              raise TensorStream::ValueError, "placeholder expects #{placeholder_shape}, got #{value_shape}" if p_shape != v_shape
+            end
           end
         end
+        if ph.is_a?(Tensor)
+          raise TensorStream::ValueError, "placeholder expects type #{tensor.data_type}, got #{ph.data_type}" if ph.data_type != tensor.data_type
+
+          global_eval(tensor, ph, context)
+        else
+          global_eval(tensor, Tensor.cast_dtype(ph, dtype: tensor.data_type), context)
+        end
+      end
+
+      register_op :variable_v2, no_eval: true do |_context, tensor, _inputs|
+        value = tensor.options[:container].read_value
+        raise "variable #{tensor.options[:container].name} not initalized" if value.nil?
+
+        value
       end
 
       register_op :stop_gradient, no_eval: true do |_context, _tensor, inputs|
@@ -165,38 +168,22 @@ module TensorStream
 
       register_op :assign, noop: true do |context, tensor, _inputs|
         assign = tensor.inputs[0] || tensor
-        assign.value = global_eval(tensor, tensor.inputs[1], context)
-        assign.value
+        assign.container = global_eval(tensor, tensor.inputs[1], context)
+        assign.container
       end
 
       register_op :assign_add, noop: true do |context, tensor, _inputs|
-        tensor.inputs[0].value = process_vector_math_op(tensor, tensor.inputs[0], tensor.inputs[1], context, ->(t, u) { t + u })
-        tensor.inputs[0].value
-      end
+        assign = tensor.inputs[0] || tensor
 
-      register_op :variable, noop: true do |_context, tensor, _inputs|
-        tensor.inputs[0].value
+        assign.container = process_vector_math_op(tensor, tensor.inputs[0], tensor.inputs[1], context, ->(t, u) { t + u })
+        assign.container
       end
 
       register_op :assign_sub, noop: true do |context, tensor, _inputs|
-        tensor.inputs[0].value = process_vector_math_op(tensor, tensor.inputs[0], tensor.inputs[1], context, ->(t, u) { t - u })
-        tensor.inputs[0].value
-      end
-
-      register_op :transpose do |_context, _tensor, inputs|
-        shape = shape_eval(inputs[0])
-        rank = get_rank(inputs[0])
-        perm = inputs[1] || (0...rank).to_a.reverse
-        if rank == 2 && perm.nil? # use native transpose for general case
-          inputs[0].transpose
-        else
-          arr = inputs[0].flatten
+        assign = tensor.inputs[0] || tensor
 
-          new_shape = perm.map { |p| shape[p] }
-          new_arr = Array.new(shape.reduce(:*)) { 0 }
-          transpose_with_perm(arr, new_arr, shape, new_shape, perm)
-          TensorShape.reshape(new_arr, new_shape)
-        end
+        assign.container = process_vector_math_op(tensor, tensor.inputs[0], tensor.inputs[1], context, ->(t, u) { t - u })
+        assign.container
       end
 
       register_op :less do |context, tensor, inputs|
@@ -277,7 +264,7 @@ module TensorStream
           raise TensorStream::InvalidArgumentError, "#{message} Invalid argument" if t.nan? || t.infinite?
           t
         }
-        call_op(tensor, inputs[0], context, f)
+        call_op(inputs[0], context, f)
       end
 
       def eval_operation(tensor, child_context)
@@ -289,14 +276,13 @@ module TensorStream
           # assertions to make sure inferred shapes == actual evaluated shapes
           if tensor.shape.known? && (result.is_a?(Array) || result.is_a?(Float) || result.is_a?(Integer))
             if shape_eval(result) != tensor.shape.shape
-
               raise "assert error #{tensor.name} #{shape_eval(result)} != #{tensor.shape.shape}"
             end
           end
 
           if tensor.breakpoint
-            a = resolve_placeholder(tensor.inputs[0], child_context) if tensor.inputs && tensor.inputs[0]
-            b = resolve_placeholder(tensor.inputs[1], child_context) if tensor.inputs && tensor.inputs[1]
+            a = tensor.inputs[0] if tensor.inputs && tensor.inputs[0]
+            b = tensor.inputs[1] if tensor.inputs && tensor.inputs[1]
             a = complete_eval(a, child_context)
             b = complete_eval(b, child_context)
             tensor.breakpoint.call(tensor, a, b, complete_eval(result, child_context))
@@ -318,9 +304,7 @@ module TensorStream
       rescue TensorStreamError => e
         raise e, "error #{e.message} while evaluating #{tensor.name}  defined at #{tensor.source}"
       rescue StandardError => e
-        # a = resolve_placeholder(tensor.inputs[0], child_context) if tensor.inputs && tensor.inputs[0]
-        # b = resolve_placeholder(tensor.inputs[1], child_context) if tensor.inputs && tensor.inputs[1]
-        puts e.message
+         puts e.message
         puts e.backtrace.join("\n")
         # shape_a = a.shape.shape if a
         # shape_b = b.shape.shape if b
@@ -338,25 +322,6 @@ module TensorStream
         raise EvaluatorExcecutionException.new(e, tensor), "error #{e.message} while evaluating #{tensor.name} : #{tensor.to_math(true, 1)} defined at #{tensor.source}"
       end
 
-      def eval_tensor(tensor, child_context)
-        return tensor unless tensor.is_a?(Tensor)
-
-        cache_key = "#{tensor.graph.object_id}_ruby_#{tensor.name}"
-        return @context[cache_key] if @context.key?(cache_key)
-        return @context[:_cache][cache_key] if @context[:_cache] && @context[:_cache].key?(tensor.name)
-
-        if tensor.value.is_a?(Array)
-          tensor.value.collect do |input|
-            input.is_a?(Tensor) ? run(input, child_context) : input
-          end
-        else
-          tensor.value.is_a?(Tensor) ? run(tensor.value, child_context) : tensor.value
-        end.tap do |result|
-          @context[cache_key] = result
-          @context[:_cache][cache_key] = result if @context[:_cache] && tensor.is_const
-        end
-      end
-
       def convert_from_buffer(_tensor, result)
         result.buffer
       end
@@ -377,14 +342,7 @@ module TensorStream
         end
       end
 
-      def reduction(child_context, tensor, func)
-        val = global_eval(tensor, tensor.inputs[0], child_context)
-        axis = global_eval(tensor, tensor.inputs[1], child_context)
-        keep_dims = global_eval(tensor, tensor.options[:keepdims], child_context)
-        reduce(val, axis, keep_dims, func)
-      end
-
-      def call_op(op, a, child_context, func)
+      def call_op(a, child_context, func)
         a = complete_eval(a, child_context)
         process_function_op(a, func)
       end
@@ -419,7 +377,7 @@ module TensorStream
       def multi_array_op(func, *args)
         elem = args[0]
         if (elem.is_a?(Array))
-          elem.each_with_index.collect do |item, index|
+          elem.each_with_index.collect do |_item, index|
             indexed_args = args.collect { |a| a[index] }
             multi_array_op(func, *indexed_args)
           end
@@ -452,29 +410,6 @@ module TensorStream
         end
       end
 
-      def resolve_placeholder(placeholder, _execution_context = {})
-        return nil if placeholder.nil?
-
-        var = if placeholder.is_a?(Placeholder)
-                @context[placeholder.name.to_sym].tap do |c|
-                  raise TensorStream::ValueError, "missing placeholder #{placeholder.name}" if c.nil?
-                  if placeholder.shape.shape
-                    value_shape = shape_eval(c)
-                    placeholder_shape = placeholder.shape.shape
-                    placeholder_shape.zip(value_shape).each do |p_shape, v_shape|
-                      next if p_shape.nil?
-                      raise TensorStream::ValueError, "placeholder expects #{placeholder_shape}, got #{value_shape}" if p_shape != v_shape
-                    end
-                  end
-                end
-              else
-                placeholder
-              end
-
-        return var unless placeholder.is_a?(Tensor)
-        Tensor.cast_dtype(var, placeholder.data_type)
-      end
-
       # handle 3 tensor math operations
       def call_3way_vector_op(v_a, v_b, v_c, child_context, op = ->(a, b, c) { a + b + c })
         return op.call(v_a, v_b, v_c) unless v_a.is_a?(Array)

data/lib/tensor_stream/graph.rb

@@ -1,7 +1,10 @@
 module TensorStream
   # A class that defines a TensorStream graph
   class Graph
-    attr_accessor :nodes, :node_keys, :collections, :eager_execution, :random_seed, :constants
+    include OpHelper
+
+    attr_accessor :nodes, :collections, :eager_execution, :random_seed, :constants
+    attr_reader :node_keys
 
     def initialize
       @eager_execution = false
@@ -30,8 +33,12 @@ module TensorStream
     end
 
     def as_default
+      Thread.current[:tensor_stream_current_graph_queue] ||= []
+      Thread.current[:tensor_stream_current_graph_queue] << Graph.get_default_graph
+
       Thread.current[:tensor_stream_current_graph] = self
       yield(self) if block_given?
+      Thread.current[:tensor_stream_current_graph] = Thread.current[:tensor_stream_current_graph_queue].pop
       self
     end
 
@@ -77,24 +84,24 @@ module TensorStream
       @collections[collection_name.to_sym] << val
     end
 
-    def add_node(node)
+    def add_node(node, name = nil)
       raise 'Placeholder cannot be used when eager_execution is enabled' if @eager_execution && node.is_a?(Placeholder)
 
-      node.name = if @nodes[node.name]
-                    uniqunify(node.name)
-                  else
-                    node.name
-                  end
+      if name.nil?
+        node.name = if @nodes[node.name]
+                      uniqunify(node.name)
+                    else
+                      node.name
+                    end
+      end
 
       node.device = get_device_scope
       @node_keys << node.name
       @nodes[node.name] = node
       @constants[node.name] = node if node.is_const
-      # puts "adding node"
+
       node.send(:propagate_outputs)
       node.send(:propagate_consumer, node)
-      # puts "#{node.name}"
-      node.value = node.eval if @eager_execution
     end
 
     def node_added?(name)
@@ -107,6 +114,7 @@ module TensorStream
 
     def get_tensor_by_name(name)
       raise TensorStream::KeyError, "#{name} not found" unless @nodes.key?(name)
+
       get_node(name)
     end
 
@@ -115,6 +123,39 @@ module TensorStream
       node
     end
 
+    def add_op(operation, *args)
+      options = if args.last.is_a?(Hash)
+                  args.pop
+                else
+                  {}
+                end
+
+      inputs = args.map { |i| TensorStream.convert_to_tensor(i) }.map { |i| i ? i.op : nil }
+
+      new_op = Operation.new(self, inputs: inputs, options: options)
+      new_op.source = format_source(caller_locations)
+      new_op.operation = operation
+      new_op.shape = TensorShape.new(TensorStream::InferShape.infer_shape(new_op))
+      new_op.rank = new_op.shape.rank
+      new_op.name = options[:internal_name] || [get_name_scope, options[:name] || set_operation_name(new_op)].compact.reject(&:empty?).join('/')
+      new_op.internal = options[:internal]
+
+      new_op.data_type = new_op.set_data_type(options[:data_type])
+      new_op.is_const = new_op.infer_const
+
+      new_op.given_name = new_op.name
+
+      new_op
+    end
+
+    def add_op!(operation, *args)
+      add_op(operation, *args).tap { |node| add_node(node) }
+    end
+
+    def set_operation_name(op)
+      op.operation.to_s
+    end
+
     def add_variable(node, options = {})
       scope = _variable_scope
 
@@ -129,13 +170,21 @@ module TensorStream
 
       add_to_collection(GraphKeys::GLOBAL_VARIABLES, node)
       add_to_collection(GraphKeys::TRAINABLE_VARIABLES, node) if node.trainable?
-      add_node(node)
+
+      node
+    end
+
+    def add_variable!(node, options = {})
+      node = add_variable(node, options)
+      op = Graph.get_default_graph.add_op!(:variable_v2, container: node, internal_name: node.name, shape: options[:shape], data_type: options[:data_type])
+      node.name = op.name
+      op
     end
 
     def control_dependencies(control_inputs = [])
       Thread.current["ts_graph_#{object_id}"] ||= {}
       Thread.current["ts_graph_#{object_id}"][:control_dependencies] ||= []
-      Thread.current["ts_graph_#{object_id}"][:control_dependencies] << Operation.new(:no_op, *control_inputs)
+      Thread.current["ts_graph_#{object_id}"][:control_dependencies] << Graph.get_default_graph.add_op!(:no_op, *control_inputs)
       begin
         yield
       ensure