tensor_stream 0.9.8 → 0.9.9

data/lib/tensor_stream/graph_builder.rb

@@ -27,11 +27,11 @@ module TensorStream
           rank = dimension.size
           options[:value] = value
           options[:const] = true
-          TensorStream::Tensor.new(options[:dtype] || options[:T], rank, dimension, options)
+          TensorStream::Constant.new(options[:dtype] || options[:T], rank, dimension, options)
         when 'VariableV2'
           # evaluate options
           shape = options[:shape]
-          TensorStream::Variable.new(options[:dtype] || options[:T], nil, shape, nil, options)
+          i_var(options[:dtype] || options[:T], nil, shape, nil, options)
         when 'Placeholder'
           shape = options[:shape]
           TensorStream::Placeholder.new(options[:dtype] || options[:T], nil, shape, options)
@@ -57,7 +57,7 @@ module TensorStream
           end
 
           options[:data_type] = options.delete(:T)
-          TensorStream::Operation.new(op, *inputs, options)
+          Graph.get_default_graph.add_op!(op, *inputs, options)
         end
       end
 

data/lib/tensor_stream/graph_deserializers/yaml_loader.rb

@@ -0,0 +1,38 @@
+module TensorStream
+  class YamlLoader
+    def initialize(graph = nil)
+      @graph = graph || TensorStream.get_default_graph
+    end
+
+    def load_from_string(buffer)
+      serialized_ops = YAML.safe_load(buffer, [Symbol])
+      serialized_ops.each do |op_def|
+        inputs = op_def[:inputs].map { |i| @graph.get_tensor_by_name(i) }
+        options = {}
+
+        if op_def.dig(:attrs, :container)
+          new_var = Variable.new(op_def.dig(:attrs, :data_type))
+          var_shape = op_def.dig(:attrs, :container, :shape)
+          var_options = op_def.dig(:attrs, :container, :options)
+          var_options[:name] = op_def[:name]
+
+          new_var.prepare(var_shape.size, var_shape, TensorStream.get_variable_scope, var_options)
+          options[:container] = new_var
+
+          @graph.add_variable(new_var, var_options)
+        end
+
+        new_op = Operation.new(@graph, inputs: inputs, options: op_def[:attrs].merge(options))
+        new_op.operation = op_def[:op].to_sym
+        new_op.name = op_def[:name]
+        new_op.shape = TensorShape.new(TensorStream::InferShape.infer_shape(new_op))
+        new_op.rank = new_op.shape.rank
+        new_op.data_type = new_op.set_data_type(op_def.dig(:attrs, :data_type))
+        new_op.is_const = new_op.infer_const
+        new_op.given_name = new_op.name
+
+        @graph.add_node(new_op)
+      end
+    end
+  end
+end

data/lib/tensor_stream/graph_serializers/packer.rb

@@ -22,6 +22,14 @@ module TensorStream
                      value.pack('C*')
                    when :boolean
                      value.map { |v| v ? 1 : 0 }.pack('C*')
+                   when :string
+                     if value.is_a?(Array)
+                      value.to_yaml
+                     else
+                      value
+                     end
+                   else
+                    raise "unknown type #{data_type}"
                    end
 
       byte_value

data/lib/tensor_stream/graph_serializers/pbtext.rb

@@ -4,11 +4,19 @@ module TensorStream
     include TensorStream::StringHelper
     include TensorStream::OpHelper
 
-    def get_string(tensor_or_graph, session = nil)
+    def get_string(tensor_or_graph, session = nil, graph_keys = nil)
       graph = tensor_or_graph.is_a?(Tensor) ? tensor_or_graph.graph : tensor_or_graph
       @lines = []
-      graph.node_keys.each do |k|
-        node = graph.get_tensor_by_name(k)
+
+      node_keys = graph_keys.nil? ? graph.node_keys : graph.node_keys.select { |k| graph_keys.include?(k) }
+
+      node_keys.each do |k|
+        node = if block_given?
+                 yield graph, k
+               else
+                 graph.get_tensor_by_name(k)
+               end
+
         @lines << "node {"
         @lines << "  name: #{node.name.to_json}"
         if node.is_a?(TensorStream::Operation)
@@ -20,16 +28,13 @@ module TensorStream
           end
           # type
           pb_attr('T', "type: #{sym_to_protobuf_type(node.data_type)}")
-          process_options(node)
-        elsif node.is_a?(TensorStream::Tensor) && node.is_const
-          @lines << "  op: \"Const\""
-          # type
-          pb_attr('T', "type: #{sym_to_protobuf_type(node.data_type)}")
-          pb_attr('value', tensor_value(node))
-        elsif node.is_a?(TensorStream::Variable)
-          @lines << "  op: \"VariableV2\""
-          pb_attr('T', "type: #{sym_to_protobuf_type(node.data_type)}")
-          pb_attr('shape', shape_buf(node, 'shape'))
+
+          case node.operation.to_s
+          when 'const'
+            pb_attr('value', tensor_value(node))
+          when 'variable_v2'
+            pb_attr('shape', shape_buf(node, 'shape'))
+          end
           process_options(node)
         end
         @lines << "}"
@@ -44,23 +49,53 @@ module TensorStream
 
     def process_options(node)
       return if node.options.nil?
-      node.options.each do |k, v|
-        next if %w[name].include?(k.to_s) || k.to_s.start_with?('__')
+      node.options.reject { |_k, v| v.nil? }.each do |k, v|
+        next if %w[name internal_name data_type].include?(k.to_s) || k.to_s.start_with?('__')
         @lines << "  attr {"
         @lines << "    key: \"#{k}\""
         @lines << "    value {"
-        if v.is_a?(TrueClass) || v.is_a?(FalseClass)
-          @lines << "      b: #{v}"
-        elsif v.is_a?(Integer)
-          @lines << "      int_val: #{v}"
-        elsif v.is_a?(Float)
-          @lines << "      float_val: #{v}"
-        end
+        attr_value(v, 6)
         @lines << "    }"
         @lines << "  }"
       end
     end
 
+    def attr_value(val, indent = 0)
+      spaces = " " * indent
+      case val.class.to_s
+      when 'TrueClass', 'FalseClass'
+        @lines << "#{spaces}b: #{val}"
+      when 'Integer'
+        @lines << "#{spaces}i: #{val}"
+      when 'String',
+        @lines << "#{spaces}s: #{val}"
+      when 'Float'
+        @lines << "#{spaces}f: #{val}"
+      when 'Symbol'
+        @lines << "#{spaces}sym: #{val}"
+      when 'Array'
+        @lines << "#{spaces}list {"
+        val.each do |v_item|
+          attr_value(v_item, indent + 2)
+        end
+        @lines << "#{spaces}}"
+      when 'TensorStream::TensorShape'
+        @lines << "#{spaces}shape {"
+        if val.shape
+          val.shape.each do |dim|
+            @lines << "#{spaces}  dim {"
+            @lines << "#{spaces}    size: #{dim}"
+            @lines << "#{spaces}  }"
+          end
+        end
+        @lines << "#{spaces}}"
+      when 'TensorStream::Variable'
+      else
+        binding.pry
+        raise "unknown type #{val.class}"
+      end
+    end
+
     def pack_arr_float(float_arr)
       float_arr.flatten.pack('f*').bytes.map { |b| b.chr =~ /[^[:print:]]/ ? "\\#{sprintf("%o", b).rjust(3, '0')}" : b.chr }.join
     end
@@ -92,17 +127,17 @@ module TensorStream
 
       if tensor.rank > 0
         if TensorStream::Ops::FLOATING_POINT_TYPES.include?(tensor.data_type)
-          packed = pack_arr_float(tensor.value)
+          packed = pack_arr_float(tensor.const_value)
           arr << "  tensor_content: \"#{packed}\""
         elsif TensorStream::Ops::INTEGER_TYPES.include?(tensor.data_type)
-          packed = pack_arr_int(tensor.value)
+          packed = pack_arr_int(tensor.const_value)
           arr << "  tensor_content: \"#{packed}\""
         elsif tensor.data_type == :string
-          tensor.value.each do |v|
+          tensor.const_value.each do |v|
             arr << "  string_val: #{v.to_json}"
           end
         else
-          arr << "  tensor_content: #{tensor.value.flatten}"
+          arr << "  tensor_content: #{tensor.const_value.flatten}"
         end
       else
         val_type = if TensorStream::Ops::INTEGER_TYPES.include?(tensor.data_type)
@@ -114,7 +149,7 @@ module TensorStream
                    else
                      "val"
                    end
-        arr << "  #{val_type}: #{tensor.value.to_json}"
+        arr << "  #{val_type}: #{tensor.const_value.to_json}"
       end
       arr << "}"
       arr

data/lib/tensor_stream/graph_serializers/serializer.rb

@@ -1,7 +1,7 @@
 module TensorStream
   class Serializer
-    def serialize(filename, tensor, session = nil)
-      File.write(filename, get_string(tensor, session))
+    def serialize(filename, tensor, session = nil, graph_keys = nil)
+      File.write(filename, get_string(tensor, session, graph_keys = nil))
     end
 
     def get_string(tensor, session = nil); end

data/lib/tensor_stream/graph_serializers/yaml.rb

@@ -0,0 +1,27 @@
+module TensorStream
+  # Parses pbtext files and loads it as a graph
+  class Yaml < TensorStream::Serializer
+    include TensorStream::StringHelper
+    include TensorStream::OpHelper
+
+    def get_string(tensor_or_graph, session = nil, graph_keys = nil)
+      graph = tensor_or_graph.is_a?(Tensor) ? tensor_or_graph.graph : tensor_or_graph
+      serialized_arr = []
+
+      node_keys = graph_keys.nil? ? graph.node_keys : graph.node_keys.select { |k| graph_keys.include?(k) }
+
+      node_keys.each do |k|
+        node = if block_given?
+                 yield graph, k
+               else
+                 graph.get_tensor_by_name(k)
+               end
+        next unless node.is_a?(Operation)
+
+        serialized_arr << node.to_h
+      end
+
+      serialized_arr.to_yaml
+    end
+  end
+end

data/lib/tensor_stream/helpers/infer_shape.rb

@@ -9,6 +9,12 @@ module TensorStream
 
     def self.infer_shape(tensor)
       case tensor.operation
+      when :case, :case_grad
+        tensor.inputs[2].shape.shape if tensor.inputs[2]
+      when :const
+        shape_eval(tensor.options[:value])
+      when :variable_v2
+        tensor.shape ? tensor.shape.shape : nil
       when :assign
         possible_shape = if tensor.inputs[0] && tensor.inputs[0].shape.shape
                            tensor.inputs[0].shape.shape
@@ -29,9 +35,9 @@ module TensorStream
         s
       when :arg_min, :argmax, :argmin
         return nil unless tensor.inputs[0].shape.known?
-        return nil if tensor.inputs[1] && tensor.inputs[1].value.nil?
+        return nil if tensor.inputs[1] && tensor.inputs[1].const_value.nil?
 
-        axis = tensor.inputs[1].nil? ? 0 : tensor.inputs[1].value
+        axis = tensor.inputs[1].nil? ? 0 : tensor.inputs[1].const_value
         new_shape = tensor.inputs[0].shape.shape
         new_shape.each_with_index.collect do |shape, index|
           next nil if index == axis
@@ -61,7 +67,7 @@ module TensorStream
           item
         end.compact
       when :reshape
-        new_shape = tensor.inputs[1] && tensor.inputs[1].value ? tensor.inputs[1].value : nil
+        new_shape = tensor.inputs[1] && tensor.inputs[1].const_value ? tensor.inputs[1].const_value : nil
         return nil if new_shape.nil?
         return nil if tensor.inputs[0].shape.nil?
 
@@ -83,11 +89,11 @@ module TensorStream
         tensor.inputs[0].shape.shape ? [tensor.inputs[0].shape.shape.size] : nil
       when :pad
         return nil unless tensor.inputs[0].shape.known?
-        return nil unless tensor.inputs[1].value
+        return nil unless tensor.inputs[1].const_value
 
         size = tensor.inputs[0].shape.shape.reduce(:*) || 1
         dummy_tensor_for_shape = TensorShape.reshape(Array.new(size), tensor.inputs[0].shape)
-        shape_eval(arr_pad(dummy_tensor_for_shape, tensor.inputs[1].value))
+        shape_eval(arr_pad(dummy_tensor_for_shape, tensor.inputs[1].const_value))
       when :mat_mul
         return nil if tensor.inputs[0].shape.shape.nil? || tensor.inputs[1].shape.shape.nil?
         return [] if tensor.inputs[0].shape.shape.empty? || tensor.inputs[1].shape.shape.empty?
@@ -128,9 +134,9 @@ module TensorStream
         rotated_shape = Array.new(axis + 1) { new_shape.shift }
         rotated_shape.rotate! + new_shape
       when :concat
-        return nil if tensor.inputs[0].value.nil?
+        return nil if tensor.inputs[0].const_value.nil?
 
-        axis = tensor.inputs[0].value # get axis
+        axis = tensor.inputs[0].const_value # get axis
 
         axis_size = 0
 
@@ -196,9 +202,9 @@ module TensorStream
 
         new_shape
       when :conv2d_backprop_input
-        return nil unless tensor.inputs[0].value
+        return nil unless tensor.inputs[0].const_value
 
-        tensor.inputs[0].value
+        tensor.inputs[0].const_value
       else
         return nil if tensor.inputs[0].nil?
         return tensor.inputs[0].shape.shape if tensor.inputs.size == 1

data/lib/tensor_stream/helpers/op_helper.rb

@@ -3,9 +3,11 @@ module TensorStream
   # module that contains helper functions useful for ops
   module OpHelper
     def _op(code, *args)
-      op = Operation.new(code.to_sym, *args)
-      if !TensorStream.get_default_graph.get_dependency_scope.nil?
-        i_op(:identity, op, TensorStream.get_default_graph.get_dependency_scope, name: [op.name, 'tuple', 'control_dependency'].join('/'))
+      default_graph = Graph.get_default_graph
+
+      op = default_graph.add_op!(code.to_sym, *args)
+      if !default_graph.get_dependency_scope.nil?
+        i_op(:identity, op, default_graph.get_dependency_scope, name: [op.name, 'tuple', 'control_dependency'].join('/'))
       else
         op
       end
@@ -20,7 +22,15 @@ module TensorStream
                 end
 
       args << options.merge(internal: true)
-      Operation.new(code.to_sym, *args)
+      Graph.get_default_graph.add_op!(code.to_sym, *args)
+    end
+
+    def i_var(data_type, rank, shape, variable_scope, options = {})
+      new_var = Variable.new(data_type)
+      new_var.prepare(rank, shape, variable_scope, options)
+      new_var.op = new_var.graph.add_variable!(new_var, options.merge(shape: @shape, data_type: data_type))
+
+      new_var
     end
 
     def cons(value, options = {})
@@ -55,8 +65,8 @@ module TensorStream
     end
 
     def format_source(trace)
-      grad_source = trace.select { |c| c.to_s.include?(File.join('lib', 'tensor_stream', 'math_gradients')) }.first
-      # source = trace.reject { |c| c.to_s.include?(File.join('lib', 'tensor_stream')) }.first
+      grad_source = trace.detect { |c| c.to_s.include?(File.join('lib', 'tensor_stream', 'math_gradients')) }
+      source = trace.reject { |c| c.to_s.include?(File.join('lib', 'tensor_stream')) }.first
       [grad_source, trace].compact.join("\n")
     end
 
@@ -82,6 +92,7 @@ module TensorStream
       axes = TensorStream.range(0, input_rank) if axes.nil?
       axes = (axes + input_rank) % input_rank
       axes_shape = i_op(:shape, axes)
+
       TensorStream.dynamic_stitch([TensorStream.range(0, input_rank), axes],
                                   [input_shape, i_op(:fill, axes_shape, 1)])
     end

data/lib/tensor_stream/helpers/string_helper.rb

@@ -1,6 +1,6 @@
 module TensorStream
   # helper string methods usually found in ActiveSupport but
-  # need to replicate here
+  # need to replicate here since we don't want to use ActiveSupport
   module StringHelper
     def camelize(string, uppercase_first_letter = true)
       string = if uppercase_first_letter
@@ -23,5 +23,36 @@ module TensorStream
         [k.to_sym, v]
       end.to_h
     end
+
+    def constantize(camel_cased_word)
+      names = camel_cased_word.split('::')
+
+      # Trigger a built-in NameError exception including the ill-formed constant in the message.
+      Object.const_get(camel_cased_word) if names.empty?
+
+      # Remove the first blank element in case of '::ClassName' notation.
+      names.shift if names.size > 1 && names.first.empty?
+
+      names.inject(Object) do |constant, name|
+        if constant == Object
+          constant.const_get(name)
+        else
+          candidate = constant.const_get(name)
+          next candidate if constant.const_defined?(name, false)
+          next candidate unless Object.const_defined?(name)
+
+          # Go down the ancestors to check if it is owned directly. The check
+          # stops when we reach Object or the end of ancestors tree.
+          constant = constant.ancestors.inject do |const, ancestor|
+            break const    if ancestor == Object
+            break ancestor if ancestor.const_defined?(name, false)
+            const
+          end
+
+          # owner is in Object, so raise
+          constant.const_get(name, false)
+        end
+      end
+    end
   end
 end

data/lib/tensor_stream/helpers/tensor_mixins.rb

@@ -0,0 +1,135 @@
+module TensorStream
+  module TensorMixins
+    def +(other)
+      _a, other = TensorStream.check_data_types(self, other)
+      _op(:add, self, other)
+    end
+
+    def [](index)
+      _op(:index, self, index)
+    end
+
+    def *(other)
+      _a, other = TensorStream.check_data_types(self, other)
+      _op(:mul, self, TensorStream.convert_to_tensor(other, dtype: data_type))
+    end
+
+    def **(other)
+      _a, other = TensorStream.check_data_types(self, other)
+      _op(:pow, self, TensorStream.convert_to_tensor(other, dtype: data_type))
+    end
+
+    def /(other)
+      _a, other = TensorStream.check_data_types(self, other)
+      _op(:div, self, TensorStream.convert_to_tensor(other, dtype: data_type))
+    end
+
+    def -(other)
+      _a, other = TensorStream.check_data_types(self, other)
+      _op(:sub, self, TensorStream.convert_to_tensor(other, dtype: data_type))
+    end
+
+    def -@
+      _op(:negate, self)
+    end
+
+    def %(other)
+      TensorStream.mod(self, other)
+    end
+
+    def floor(name: nil)
+      TensorStream.floor(self, name: name)
+    end
+
+    def ceil(name: nil)
+      TensorStream.ceil(self, name: name)
+    end
+
+    def round(name: nil)
+      TensorStream.round(self, name: name)
+    end
+
+    def log(name: nil)
+      TensorStream.log(self, name: name)
+    end
+
+    def reshape(shape, name: nil)
+      TensorStream.reshape(self, shape, name: name)
+    end
+
+    def zero?
+      _op(:equal, self, TensorStream.constant(0, dtype: data_type, name: 'equal/is_zero?'))
+    end
+
+    def ==(other)
+      _a, other = TensorStream.check_data_types(self, other)
+      _op(:equal, self, other)
+    end
+
+    def <(other)
+      _a, other = TensorStream.check_data_types(self, other)
+      _op(:less, self, other)
+    end
+
+    def !=(other)
+      _a, other = TensorStream.check_data_types(self, other)
+      _op(:not_equal, self, other)
+    end
+
+    def >(other)
+      _a, other = TensorStream.check_data_types(self, other)
+      _op(:greater, self, other)
+    end
+
+    def >=(other)
+      _a, other = TensorStream.check_data_types(self, other)
+      _op(:greater_equal, self, other)
+    end
+
+    def <=(other)
+      _a, other = TensorStream.check_data_types(self, other)
+      _op(:less_equal, self, other)
+    end
+
+    def and(other)
+      _a, other = TensorStream.check_data_types(self, other)
+      _op(:logical_and, self, other)
+    end
+
+    def matmul(other)
+      _a, other = TensorStream.check_data_types(self, other)
+      _op(:mat_mul, self, other)
+    end
+
+    def dot(other)
+      _a, other = TensorStream.check_data_types(self, other)
+      _op(:mat_mul, self, other)
+    end
+
+    def cast(data_type = :float32, name: nil)
+      TensorStream.cast(self, data_type, name: name)
+    end
+
+    def var(name: nil)
+      TensorStream.variable(self, name: name)
+    end
+
+    ##
+    # Apply a reduction to tensor
+    def reduce(op_type = :+, axis: nil, keepdims: false, name: nil)
+      reduce_op = case op_type.to_sym
+                  when :+
+                    :sum
+                  when :*
+                    :prod
+                  when :mean
+                    :mean
+                  else
+                    raise "unsupported reduce op type #{op_type} valid values are :+, :*, :prod, :mean"
+                  end
+      raise "blocks are not supported for tensors" if block_given?
+
+      TensorStream.reduce(reduce_op, self, axis, keepdims: keepdims, name: name)
+    end
+  end
+end