tensor_stream 0.4.1 → 0.5.0

data/lib/tensor_stream/graph.rb

@@ -43,6 +43,19 @@ module TensorStream
       end
     end
 
+    ##
+    # Returns a context manager that specifies the default device to use.
+    def device(device_name)
+      Thread.current["ts_graph_#{object_id}"] ||= {}
+      Thread.current["ts_graph_#{object_id}"][:default_device] ||= []
+      Thread.current["ts_graph_#{object_id}"][:default_device] << device_name
+      begin
+        yield
+      ensure
+        Thread.current["ts_graph_#{object_id}"][:default_device].pop
+      end
+    end
+
     def self.get_default_graph
       Thread.current[:tensor_stream_current_graph] || create_default
     end
@@ -69,6 +82,7 @@ module TensorStream
                     node.name
                   end
 
+      node.device = get_device_scope
       @nodes[node.name] = node
       @constants[node.name] = node if node.is_const
       node.send(:propagate_outputs)
@@ -159,11 +173,17 @@ module TensorStream
 
     def get_name_scope
       graph_thread_storage = Thread.current["ts_graph_#{object_id}"]
-      return nil if graph_thread_storage.nil?
+      return nil if graph_thread_storage.nil? || graph_thread_storage[:current_scope].nil?
 
       graph_thread_storage[:current_scope].join('/')
     end
 
+    def get_device_scope
+      graph_thread_storage = Thread.current["ts_graph_#{object_id}"]
+      return :default if graph_thread_storage.nil? || graph_thread_storage[:default_device].nil?
+      graph_thread_storage[:default_device].last
+    end
+
     def as_graph_def
       TensorStream::Pbtext.new.get_string(self)
     end

data/lib/tensor_stream/graph_serializers/graphml.rb

@@ -134,73 +134,73 @@ module TensorStream
         add_to_group(groups, "program/#{tensor.name}", node_buf)
       end
 
-      tensor.items.each do |item|
-        next unless item
-        next if added[item.name]
-
-        next to_graph_ml(item, arr_buf, added, groups) if item.is_a?(Operation)
-
-        added[item.name] = true
-        item_buf = []
-        if item.is_a?(Variable)
-          item_buf << "<node id=\"#{_gml_string(item.name)}\">"
-          item_buf << "<data key=\"d0\">#{item.name}</data>"
-          item_buf << "<data key=\"d2\">green</data>"
-          if @last_session_context[item.name]
-            item_buf << "<data key=\"d3\">#{_val(tensor)}</data>"
+      tensor.inputs.each do |input|
+        next unless input
+        next if added[input.name]
+
+        next to_graph_ml(input, arr_buf, added, groups) if input.is_a?(Operation)
+
+        added[input.name] = true
+        input_buf = []
+        if input.is_a?(Variable)
+          input_buf << "<node id=\"#{_gml_string(input.name)}\">"
+          input_buf << "<data key=\"d0\">#{input.name}</data>"
+          input_buf << "<data key=\"d2\">green</data>"
+          if @last_session_context[input.name]
+            input_buf << "<data key=\"d3\">#{_val(tensor)}</data>"
           end
-          item_buf << "<data key=\"d9\">"
-          item_buf << "<y:ShapeNode>"
-          item_buf << "  <y:Fill color=\"#33CCCC\" transparent=\"false\"/>"
-          item_buf << "  <y:NodeLabel alignment=\"center\">#{item.name}</y:NodeLabel>"
-          item_buf << "</y:ShapeNode>"
-          item_buf << "</data>"
-          item_buf << "</node>"
-        elsif item.is_a?(Placeholder)
-          item_buf << "<node id=\"#{_gml_string(item.name)}\">"
-          item_buf << "<data key=\"d9\">"
-          item_buf << "<y:ShapeNode>"
-          item_buf << "  <y:Fill color=\"#FFCC00\" transparent=\"false\"/>"
-          item_buf << "  <y:NodeLabel alignment=\"center\">#{item.name}</y:NodeLabel>"
-          item_buf << "</y:ShapeNode>"
-          item_buf << "</data>"
-          if @last_session_context[item.name]
-            item_buf << "<data key=\"d3\">#{_val(tensor)}</data>"
+          input_buf << "<data key=\"d9\">"
+          input_buf << "<y:ShapeNode>"
+          input_buf << "  <y:Fill color=\"#33CCCC\" transparent=\"false\"/>"
+          input_buf << "  <y:NodeLabel alignment=\"center\">#{input.name}</y:NodeLabel>"
+          input_buf << "</y:ShapeNode>"
+          input_buf << "</data>"
+          input_buf << "</node>"
+        elsif input.is_a?(Placeholder)
+          input_buf << "<node id=\"#{_gml_string(input.name)}\">"
+          input_buf << "<data key=\"d9\">"
+          input_buf << "<y:ShapeNode>"
+          input_buf << "  <y:Fill color=\"#FFCC00\" transparent=\"false\"/>"
+          input_buf << "  <y:NodeLabel alignment=\"center\">#{input.name}</y:NodeLabel>"
+          input_buf << "</y:ShapeNode>"
+          input_buf << "</data>"
+          if @last_session_context[input.name]
+            input_buf << "<data key=\"d3\">#{_val(tensor)}</data>"
           end
-          item_buf << "</node>"
-        elsif item.is_a?(Tensor)
-          item_buf << "<node id=\"#{_gml_string(item.name)}\">"
-          item_buf << "<data key=\"d0\">#{item.name}</data>"
-          item_buf << "<data key=\"d2\">black</data>"
-          item_buf << "<data key=\"d9\">"
-          item_buf << "<y:ShapeNode>"
-
-          if item.internal?
-            item_buf << "  <y:Fill color=\"#C0C0C0\" transparent=\"false\"/>"
+          input_buf << "</node>"
+        elsif input.is_a?(Tensor)
+          input_buf << "<node id=\"#{_gml_string(input.name)}\">"
+          input_buf << "<data key=\"d0\">#{input.name}</data>"
+          input_buf << "<data key=\"d2\">black</data>"
+          input_buf << "<data key=\"d9\">"
+          input_buf << "<y:ShapeNode>"
+
+          if input.internal?
+            input_buf << "  <y:Fill color=\"#C0C0C0\" transparent=\"false\"/>"
           else
-            item_buf << "  <y:Fill color=\"#FFFFFF\" transparent=\"false\"/>"
+            input_buf << "  <y:Fill color=\"#FFFFFF\" transparent=\"false\"/>"
           end
 
 
-          item_buf << "  <y:NodeLabel alignment=\"center\">#{item.name}</y:NodeLabel>"
+          input_buf << "  <y:NodeLabel alignment=\"center\">#{input.name}</y:NodeLabel>"
 
-          item_buf << "</y:ShapeNode>"
-          item_buf << "</data>"
-          item_buf << "</node>"
+          input_buf << "</y:ShapeNode>"
+          input_buf << "</data>"
+          input_buf << "</node>"
         end
 
-        if !add_to_group(groups, item.name, item_buf)
-          if item.is_a?(Variable)
-            add_to_group(groups, "variable/#{item.name}", item_buf)
+        if !add_to_group(groups, input.name, input_buf)
+          if input.is_a?(Variable)
+            add_to_group(groups, "variable/#{input.name}", input_buf)
           else
-            add_to_group(groups, "program/#{item.name}", item_buf)
+            add_to_group(groups, "program/#{input.name}", input_buf)
           end
         end
       end
 
-      tensor.items.each_with_index do |item, index|
-        next unless item
-        output_edge(item, tensor, arr_buf, index)
+      tensor.inputs.each_with_index do |input, index|
+        next unless input
+        output_edge(input, tensor, arr_buf, index)
       end
     end
 
@@ -208,20 +208,20 @@ module TensorStream
       str.gsub('/','-')
     end
 
-    def output_edge(item, tensor, arr_buf, index = 0)
+    def output_edge(input, tensor, arr_buf, index = 0)
       target_name = tensor.is_a?(Tensor) ? tensor.name : tensor
-      arr_buf << "<edge source=\"#{_gml_string(item.name)}\" target=\"#{_gml_string(target_name)}\">"
+      arr_buf << "<edge source=\"#{_gml_string(input.name)}\" target=\"#{_gml_string(target_name)}\">"
       arr_buf << "<data key=\"d13\">"
 
       arr_buf << "<y:PolyLineEdge>"
       arr_buf << "<y:EdgeLabel >"
       if !@last_session_context.empty?
-        arr_buf << "<![CDATA[  #{_val(item)}  ]]>"
+        arr_buf << "<![CDATA[  #{_val(input)}  ]]>"
       else
-        if item.shape.shape.nil?
-          arr_buf << "<![CDATA[ #{item.data_type.to_s} ? ]]>"
+        if input.shape.shape.nil?
+          arr_buf << "<![CDATA[ #{input.data_type.to_s} ? ]]>"
         else
-          arr_buf << "<![CDATA[ #{item.data_type.to_s} #{item.shape.shape.empty? ? 'scalar' : item.shape.shape.to_json}  ]]>"
+          arr_buf << "<![CDATA[ #{input.data_type.to_s} #{input.shape.shape.empty? ? 'scalar' : input.shape.shape.to_json}  ]]>"
         end
       end
       arr_buf << "</y:EdgeLabel >"

data/lib/tensor_stream/graph_serializers/pbtext.rb

@@ -11,7 +11,7 @@ module TensorStream
         @lines << "  name: #{node.name.to_json}"
         if node.is_a?(TensorStream::Operation)
           @lines << "  op: #{camelize(node.operation.to_s).to_json}"
-          node.items.each do |input|
+          node.inputs.each do |input|
             next unless input
             @lines << "  input: #{input.name.to_json}"
           end

data/lib/tensor_stream/helpers/op_helper.rb

@@ -33,8 +33,12 @@ module TensorStream
       arr
     end
 
-    def dtype_eval(rank, value)
-      dtype = Tensor.detect_type(value[0])
+    def dtype_eval(rank, value, data_type = nil)
+      dtype = if data_type.nil?
+        Tensor.detect_type(value[0])
+      else
+       data_type
+      end
 
       rank += 1 if dtype == :array
 

data/lib/tensor_stream/math_gradients.rb

@@ -38,22 +38,22 @@ module TensorStream
         computed_op.each_with_index do |op_grad, index|
           next if op_grad.nil?
 
-          if nodes_to_compute.include?(tensor.items[index].name)
-            partials << _propagate(op_grad, tensor.items[index], stop_tensor, nodes_to_compute, stop_gradients)
+          if nodes_to_compute.include?(tensor.inputs[index].name)
+            partials << _propagate(op_grad, tensor.inputs[index], stop_tensor, nodes_to_compute, stop_gradients)
           end
         end
 
         partials.reduce(:+)
       else
         return tf.zeros_like(stop_tensor) if computed_op.nil?
-        _propagate(computed_op, tensor.items[0], stop_tensor, nodes_to_compute, stop_gradients)
+        _propagate(computed_op, tensor.inputs[0], stop_tensor, nodes_to_compute, stop_gradients)
       end
     end
 
     def self._compute_derivative(node, grad)
       node.graph.name_scope("#{node.name}_grad") do
-        x = node.items[0] if node.items[0]
-        y = node.items[1] if node.items[1]
+        x = node.inputs[0] if node.inputs[0]
+        y = node.inputs[1] if node.inputs[1]
 
         case node.operation
         when :add
@@ -221,8 +221,8 @@ module TensorStream
 
     def self._min_or_max_grad(op, grad)
       y = op
-      indicators = tf.cast(tf.equal(y, op.items[0]), grad.data_type)
-      num_selected = tf.reduce_sum(indicators, op.items[1])
+      indicators = tf.cast(tf.equal(y, op.inputs[0]), grad.data_type)
+      num_selected = tf.reduce_sum(indicators, op.inputs[1])
       _safe_shape_div(indicators, num_selected) * grad
     end
 

data/lib/tensor_stream/operation.rb

@@ -1,7 +1,7 @@
 module TensorStream
   # TensorStream class that defines an operation
   class Operation < Tensor
-    attr_accessor :name, :operation, :items, :rank, :options
+    attr_accessor :name, :operation, :inputs, :rank, :options
     attr_reader :outputs
 
     def initialize(operation, input_a, input_b, options = {})
@@ -15,7 +15,7 @@ module TensorStream
 
       @options = options
 
-      @items = [input_a, input_b].map { |i| options[:preserve_params_type] ? i : TensorStream.convert_to_tensor(i) }
+      @inputs = [input_a, input_b].map { |i| options[:preserve_params_type] ? i : TensorStream.convert_to_tensor(i) }
       @data_type = set_data_type(options[:data_type])
       @is_const = infer_const
       @shape = TensorShape.new(infer_shape)
@@ -30,16 +30,16 @@ module TensorStream
       {
         op: operation,
         name: name,
-        operands: hashify_tensor(items)
+        operands: hashify_tensor(inputs)
       }
     end
 
     def self.empty_matrix?(input)
       if input.is_a?(Array)
-        input.each do |item|
-          if item.is_a?(Array)
-            return false unless empty_matrix?(item)
-          elsif item != 0 || item != 0.0
+        input.each do |input|
+          if input.is_a?(Array)
+            return false unless empty_matrix?(input)
+          elsif input != 0 || input != 0.0
             return false
           end
         end
@@ -54,7 +54,7 @@ module TensorStream
       when :random_normal, :random_uniform, :glorot_uniform, :print
         false
       else
-        non_const = @items.compact.find { |item| !item.is_const }
+        non_const = @inputs.compact.find { |input| !input.is_const }
         non_const ? false : true
       end
     end
@@ -68,23 +68,23 @@ module TensorStream
       when :random_normal, :random_uniform, :glorot_uniform
         passed_data_type || :float32
       when :index
-        if @items[0].is_a?(ControlFlow)
+        if @inputs[0].is_a?(ControlFlow)
 
-          if @items[1].is_const
-            @items[0].items[@items[1].value].data_type
+          if @inputs[1].is_const
+            @inputs[0].inputs[@inputs[1].value].data_type
           else
             :unknown
           end
         else
-          @items[0].data_type
+          @inputs[0].data_type
         end
       else
         return passed_data_type if passed_data_type
 
-        if @items[0]
-          @items[0].data_type
-        elsif @items[1]
-          @items[1].data_type
+        if @inputs[0]
+          @inputs[0].data_type
+        elsif @inputs[1]
+          @inputs[1].data_type
         else
           :unknown
         end
@@ -94,119 +94,119 @@ module TensorStream
     def to_math(name_only = false, max_depth = 99, _cur_depth = 0)
       return @name if max_depth.zero?
 
-      sub_item = auto_math(items[0], name_only, max_depth - 1, _cur_depth + 1)
-      sub_item2 = auto_math(items[1], name_only, max_depth - 1, _cur_depth + 1) if items[1]
+      sub_input = auto_math(inputs[0], name_only, max_depth - 1, _cur_depth + 1)
+      sub_input2 = auto_math(inputs[1], name_only, max_depth - 1, _cur_depth + 1) if inputs[1]
 
       out = case operation
       when :argmax
-        "argmax(#{sub_item},#{options[:axis]})"
+        "argmax(#{sub_input},#{options[:axis]})"
       when :negate
-        "-#{sub_item}"
+        "-#{sub_input}"
       when :index
-        "#{sub_item}[#{sub_item2}]"
+        "#{sub_input}[#{sub_input2}]"
       when :slice
-        "#{sub_item}[#{sub_item2}]"
+        "#{sub_input}[#{sub_input2}]"
       when :assign_sub
-        "(#{items[0] ? items[0].name : 'self'} -= #{auto_math(items[1], name_only, 1)})"
+        "(#{inputs[0] ? inputs[0].name : 'self'} -= #{auto_math(inputs[1], name_only, 1)})"
       when :assign_add
-        "(#{items[0] ? items[0].name : 'self'} += #{auto_math(items[1], name_only, 1)})"
+        "(#{inputs[0] ? inputs[0].name : 'self'} += #{auto_math(inputs[1], name_only, 1)})"
       when :assign
-        "(#{items[0] ? items[0].name : 'self'} = #{auto_math(items[1], name_only, 1)})"
+        "(#{inputs[0] ? inputs[0].name : 'self'} = #{auto_math(inputs[1], name_only, 1)})"
       when :sin, :cos, :tanh
-        "#{operation}(#{sub_item})"
+        "#{operation}(#{sub_input})"
       when :add
-        "(#{sub_item} + #{sub_item2})"
+        "(#{sub_input} + #{sub_input2})"
       when :sub
-        "(#{sub_item} - #{sub_item2})"
+        "(#{sub_input} - #{sub_input2})"
       when :pow
-        "(#{sub_item}^#{sub_item2})"
+        "(#{sub_input}^#{sub_input2})"
       when :div
-        "(#{sub_item} / #{sub_item2})"
+        "(#{sub_input} / #{sub_input2})"
       when :mul
-        if auto_math(items[0]) == 1
-          sub_item2
-        elsif auto_math(items[1]) == 1
-          sub_item
+        if auto_math(inputs[0]) == 1
+          sub_input2
+        elsif auto_math(inputs[1]) == 1
+          sub_input
         else
-          "(#{sub_item} * #{sub_item2})"
+          "(#{sub_input} * #{sub_input2})"
         end
       when :sum
-        "sum(|#{sub_item}|,  axis=#{sub_item2})"
+        "sum(|#{sub_input}|,  axis=#{sub_input2})"
       when :mean
-        "mean(|#{sub_item}|, axis=#{sub_item2})"
+        "mean(|#{sub_input}|, axis=#{sub_input2})"
       when :prod
-        "prod(|#{sub_item}|,  axis=#{sub_item2})"
+        "prod(|#{sub_input}|,  axis=#{sub_input2})"
       when :gradients
-        "gradient(#{sub_item})"
+        "gradient(#{sub_input})"
       when :stop_gradient
-        sub_item
+        sub_input
       when :matmul
-        "#{sub_item}.matmul(#{sub_item2})"
+        "#{sub_input}.matmul(#{sub_input2})"
       when :eye
-        "eye(#{sub_item})"
+        "eye(#{sub_input})"
       when :transpose
-        "transpose(#{sub_item})"
+        "transpose(#{sub_input})"
       when :shape
-        "#{sub_item}.shape"
+        "#{sub_input}.shape"
       when :exp
-        "e^#{sub_item})"
+        "e^#{sub_input})"
       when :ones
-        "ones(#{sub_item})"
+        "ones(#{sub_input})"
       when :ones_like
-        "ones_like(#{sub_item})"
+        "ones_like(#{sub_input})"
       when :flow_group
-        "flow_group(#{items.collect { |i| auto_math(i, name_only, max_depth - 1, _cur_depth) }.join(',')})"
+        "flow_group(#{inputs.collect { |i| auto_math(i, name_only, max_depth - 1, _cur_depth) }.join(',')})"
       when :zeros
-        "zeros(#{sub_item})"
+        "zeros(#{sub_input})"
       when :reshape
-        "reshape(#{sub_item},#{sub_item2})"
+        "reshape(#{sub_input},#{sub_input2})"
       when :rank
-        "#{sub_item}.rank"
+        "#{sub_input}.rank"
       when :cond
-        "(#{auto_math(options[:pred], name_only, max_depth - 1, _cur_depth)} ? #{sub_item} : #{sub_item2})"
+        "(#{auto_math(options[:pred], name_only, max_depth - 1, _cur_depth)} ? #{sub_input} : #{sub_input2})"
       when :less
-        "#{sub_item} < #{sub_item2}"
+        "#{sub_input} < #{sub_input2}"
       when :less_equal
-        "#{sub_item} <= #{sub_item2}"
+        "#{sub_input} <= #{sub_input2}"
       when :greater
-        "#{sub_item} > #{sub_item2}"
+        "#{sub_input} > #{sub_input2}"
       when :greater_equal
-        "#{sub_item} >= #{sub_item2}"
+        "#{sub_input} >= #{sub_input2}"
       when :square
-        "#{sub_item}\u00B2"
+        "#{sub_input}\u00B2"
       when :log
-        "log(#{sub_item})"
+        "log(#{sub_input})"
       when :identity
-        "identity(#{sub_item})"
+        "identity(#{sub_input})"
       when :print
-        "print(#{sub_item})"
+        "print(#{sub_input})"
       when :pad
-        "pad(#{sub_item},#{auto_math(options[:paddings])})"
+        "pad(#{sub_input},#{auto_math(options[:paddings])})"
       when :equal
-        "#{sub_item} == #{sub_item2}"
+        "#{sub_input} == #{sub_input2}"
       when :not_equal
-        "#{sub_item} != #{sub_item2}"
+        "#{sub_input} != #{sub_input2}"
       when :logical_and
-        "#{sub_item} && #{sub_item2}"
+        "#{sub_input} && #{sub_input2}"
       when :sqrt
-        "sqrt(#{sub_item})"
+        "sqrt(#{sub_input})"
       when :log1p
-        "log1p(#{sub_item})"
+        "log1p(#{sub_input})"
       when :zeros_like
-        "zeros_like(#{sub_item})"
+        "zeros_like(#{sub_input})"
       when :where
-        "where(#{auto_math(options[:pred], name_only, max_depth - 1, _cur_depth)}, #{sub_item}, #{sub_item2})"
+        "where(#{auto_math(options[:pred], name_only, max_depth - 1, _cur_depth)}, #{sub_input}, #{sub_input2})"
       when :max
-        "max(#{sub_item},#{sub_item2})"
+        "max(#{sub_input},#{sub_input2})"
       when :cast
-        "cast(#{sub_item}, #{data_type})"
+        "cast(#{sub_input}, #{data_type})"
       when :broadcast_transform
-        "broadcast_transform(#{sub_item},#{sub_item2})"
+        "broadcast_transform(#{sub_input},#{sub_input2})"
       when :broadcast_gradient_args
-        "broadcast_transform(#{sub_item},#{sub_item2})"
+        "broadcast_transform(#{sub_input},#{sub_input2})"
       else
-        "#{operation}(#{sub_item})" if sub_item
-        "#{operation}(#{sub_item}, #{sub_item2})" if sub_item && sub_item2
+        "#{operation}(#{sub_input})" if sub_input
+        "#{operation}(#{sub_input}, #{sub_input2})" if sub_input && sub_input2
       end
       ["\n",(_cur_depth + 1).times.collect { ' ' }, out].flatten.join
     end
@@ -224,47 +224,47 @@ module TensorStream
     def infer_shape
       case operation
       when :index
-        item_shape = items[0].shape.shape
-        return nil if item_shape.nil?
-        return item_shape[1, item_shape.size]
+        input_shape = inputs[0].shape.shape
+        return nil if input_shape.nil?
+        return input_shape[1, input_shape.size]
       when :mean, :prod, :sum
-        return [] if items[1].nil?
-        return nil if items[0].nil?
-        item_shape = items[0].shape.shape
-        return nil if item_shape.nil?
-        return nil if items[1].is_a?(Tensor) && items[1].value.nil?
+        return [] if inputs[1].nil?
+        return nil if inputs[0].nil?
+        input_shape = inputs[0].shape.shape
+        return nil if input_shape.nil?
+        return nil if inputs[1].is_a?(Tensor) && inputs[1].value.nil?
 
-        axis = items[1].is_a?(Tensor) ? items[1].value : items[1]
+        axis = inputs[1].is_a?(Tensor) ? inputs[1].value : inputs[1]
 
         axis = [ axis ] unless axis.is_a?(Array)
-        return item_shape.each_with_index.map do |s, index|
+        return input_shape.each_with_index.map do |s, index|
           next nil if axis.include?(index)
           s
         end.compact
       when :reshape
-        new_shape = items[1] && items[1].value ? items[1].value : nil
+        new_shape = inputs[1] && inputs[1].value ? inputs[1].value : nil
         return nil if new_shape.nil?
 
-        item_shape = items[0].shape.shape
-        return new_shape if item_shape.nil?
+        input_shape = inputs[0].shape.shape
+        return new_shape if input_shape.nil?
 
-        return TensorShape.fix_inferred_elements(new_shape, item_shape.reduce(:*))
+        return TensorShape.fix_inferred_elements(new_shape, input_shape.reduce(:*))
       when :flow_group
         return []
       when :zeros, :ones
-        return items[0] ? items[0].value : options[:shape]
+        return inputs[0] ? inputs[0].value : options[:shape]
       when :zeros_like, :ones_like
-        items[0].shape.shape
+        inputs[0].shape.shape
       when :shape
-        return items[0].shape.shape ? [items[0].shape.shape.size] : nil
+        return inputs[0].shape.shape ? [inputs[0].shape.shape.size] : nil
       when :matmul
-        shape1 = items[0].shape.shape.nil? ? nil : items[0].shape.shape[0]
-        shape2 = items[1].shape.shape.nil? ? nil : items[1].shape.shape[1]
+        shape1 = inputs[0].shape.shape.nil? ? nil : inputs[0].shape.shape[0]
+        shape2 = inputs[1].shape.shape.nil? ? nil : inputs[1].shape.shape[1]
         return [shape1, shape2]
       else
-        return items[0].shape.shape if items.size == 1
-        if items.size == 2 && items[0] && items[1]
-          return TensorShape.infer_shape(items[0].shape.shape, items[1].shape.shape)
+        return inputs[0].shape.shape if inputs.size == 1
+        if inputs.size == 2 && inputs[0] && inputs[1]
+          return TensorShape.infer_shape(inputs[0].shape.shape, inputs[1].shape.shape)
         end
       end
 
@@ -273,14 +273,14 @@ module TensorStream
 
     def propagate_consumer(consumer)
       super
-      @items.compact.each do |item|
-        item.send(:propagate_consumer, consumer) if item.name != name
+      @inputs.compact.each do |input|
+        input.send(:propagate_consumer, consumer) if input.name != name
       end
     end
 
     def propagate_outputs
-      @items.compact.each do |item|
-        item.send(:setup_output, self) if item.name != self.name
+      @inputs.compact.each do |input|
+        input.send(:setup_output, self) if input.name != self.name
       end
     end