tensor_stream 1.0.0 → 1.0.1

data/lib/tensor_stream/generated_stub/stub_file.erb

@@ -0,0 +1,24 @@
+# This file has ben automatically generated by stubgen
+# DO NOT EDIT
+#
+module TensorStream
+  module OpStub
+<% TensorStream::OpMaker.each_op do |op|%>
+    ##
+<% op.description_lines.each do |line|%>    # <%= line %>
+<%end%>    #
+    #<% if op.supports_broadcasting? %> This operation supports broadcasting
+    #<% end %>
+    # Params:
+<% op.parameters.each do |param| %>    # +<%= param[:name] %>+:: <%= param[:description]%><%if param[:validate]%> (of type <%= param[:validate] %>)<%end%>
+<% end %>    #
+    # Options:
+<% op.options.each do |k, v| %>    # +:<%= k %>+:: <%= v[:description]%><% if v[:default_value] != :nil %> default (<%= v[:default_value] %>)<%end%>
+<%end%>    def <%= op.operation.to_s %>(<%= (op.expand_params(true) + op.expand_options(true)).join(', ') %>)
+<%= op.generate_body %>
+    end
+<% op.aliases.each do |a|%>
+    alias_method :<%= a %>, :<%= op.operation %><%end%>
+<% end %>
+  end
+end

data/lib/tensor_stream/graph.rb

@@ -12,7 +12,7 @@ module TensorStream
       @node_keys = []
       @collections = {
         :"#{GraphKeys::GLOBAL_VARIABLES}" => [],
-        :"#{GraphKeys::TRAINABLE_VARIABLES}" => []
+        :"#{GraphKeys::TRAINABLE_VARIABLES}" => [],
       }
       @constants = {}
     end
@@ -27,7 +27,7 @@ module TensorStream
       @node_keys = []
       @collections = {
         :"#{GraphKeys::GLOBAL_VARIABLES}" => [],
-        :"#{GraphKeys::TRAINABLE_VARIABLES}" => []
+        :"#{GraphKeys::TRAINABLE_VARIABLES}" => [],
       }
       @constants = {}
     end
@@ -85,14 +85,14 @@ module TensorStream
     end
 
     def add_node(node, name = nil)
-      raise 'Placeholder cannot be used when eager_execution is enabled' if @eager_execution && node.is_a?(Placeholder)
+      raise "Placeholder cannot be used when eager_execution is enabled" if @eager_execution && node.is_a?(Placeholder)
 
       if name.nil?
         node.name = if @nodes[node.name]
-                      uniqunify(node.name)
-                    else
-                      node.name
-                    end
+          uniqunify(node.name)
+        else
+          node.name
+        end
       end
 
       node.device = get_device_scope
@@ -129,10 +129,10 @@ module TensorStream
 
     def add_op(operation, *args)
       options = if args.last.is_a?(Hash)
-                  args.pop
-                else
-                  {}
-                end
+        args.pop
+      else
+        {}
+      end
 
       inputs = args.map { |i| TensorStream.convert_to_tensor(i) }.map { |i| i ? i.op : nil }
 
@@ -141,7 +141,7 @@ module TensorStream
       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.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])
@@ -211,7 +211,7 @@ module TensorStream
     def get_operation_counter
       @op_counter ||= 0
 
-      name = @op_counter.zero? ? '' : "_#{@op_counter}"
+      name = @op_counter.zero? ? "" : "_#{@op_counter}"
 
       @op_counter += 1
 
@@ -222,7 +222,7 @@ module TensorStream
       @placeholder_counter ||= 0
       @placeholder_counter += 1
 
-      return '' if @placeholder_counter == 1
+      return "" if @placeholder_counter == 1
 
       "_#{@placeholder_counter}"
     end
@@ -231,14 +231,14 @@ module TensorStream
       @var_counter ||= 0
       @var_counter += 1
 
-      return '' if @var_counter == 1
+      return "" if @var_counter == 1
       "_#{@var_counter}"
     end
 
     def get_const_counter
       @const_counter ||= 0
 
-      name = @const_counter.zero? ? '' : "_#{@const_counter}"
+      name = @const_counter.zero? ? "" : "_#{@const_counter}"
 
       @const_counter += 1
       name
@@ -248,7 +248,7 @@ module TensorStream
       graph_thread_storage = Thread.current["ts_graph_#{object_id}"]
       return nil if graph_thread_storage.nil? || graph_thread_storage[:current_scope].nil?
 
-      graph_thread_storage[:current_scope].join('/')
+      graph_thread_storage[:current_scope].join("/")
     end
 
     def get_dependency_scope
@@ -279,7 +279,7 @@ module TensorStream
     protected
 
     def _variable_scope
-      return VariableScope.new(name: '', reuse: false, initializer: nil) if Thread.current[:tensor_stream_variable_scope].nil? || Thread.current[:tensor_stream_variable_scope].empty?
+      return VariableScope.new(name: "", reuse: false, initializer: nil) if Thread.current[:tensor_stream_variable_scope].nil? || Thread.current[:tensor_stream_variable_scope].empty?
       scope = Thread.current[:tensor_stream_variable_scope].last
       scope
     end

data/lib/tensor_stream/graph_builder.rb

@@ -13,48 +13,48 @@ module TensorStream
       protobuf = TensorStream::Protobuf.new
       parsed_tree = protobuf.load_from_string(buffer)
       parsed_tree.each do |node|
-        next unless node['type'] == 'node'
+        next unless node["type"] == "node"
 
         # puts "build #{node['name']}"
         options = protobuf.options_evaluator(node)
-        options[:name] = node['name']
+        options[:name] = node["name"]
         options[:__graph] = @graph
-        value = options.delete('value')
+        value = options.delete("value")
         options = symbolize_keys(options)
-        case node['op']
-        when 'Const'
+        case node["op"]
+        when "Const"
           dimension = shape_eval(value)
           rank = dimension.size
           options[:value] = value
           options[:const] = true
           TensorStream::Constant.new(options[:dtype] || options[:T], rank, dimension, options)
-        when 'VariableV2'
+        when "VariableV2"
           # evaluate options
           shape = options[:shape]
           i_var(options[:dtype] || options[:T], nil, shape, nil, options)
-        when 'Placeholder'
+        when "Placeholder"
           shape = options[:shape]
           TensorStream::Placeholder.new(options[:dtype] || options[:T], nil, shape, options)
         else
-          op = underscore(node['op']).to_sym
+          op = underscore(node["op"]).to_sym
           puts "warning unsupported op #{op}" unless TensorStream::Evaluator::RubyEvaluator.ops.key?(op)
 
           # map input tensor
-          inputs = node['input'].map do |input|
-            input[0] = '' if input.start_with?('^')
+          inputs = node["input"].map { |input|
+            input[0] = "" if input.start_with?("^")
 
-            input_indexed, index = input.split(':')
+            input_indexed, index = input.split(":")
 
             tensor = if index && index.to_i > 0
-                       @graph.get_tensor_by_name(input_indexed)[index.to_i]
-                     else
-                       @graph.get_tensor_by_name(input)
-                     end
+              @graph.get_tensor_by_name(input_indexed)[index.to_i]
+            else
+              @graph.get_tensor_by_name(input)
+            end
 
             raise "tensor not found by name #{input}" if tensor.nil?
 
             tensor
-          end
+          }
 
           options[:data_type] = options.delete(:T)
           Graph.get_default_graph.add_op!(op, *inputs, options)
@@ -64,4 +64,4 @@ module TensorStream
       @graph
     end
   end
-end
+end

data/lib/tensor_stream/graph_deserializers/protobuf.rb

@@ -1,4 +1,4 @@
-require 'yaml'
+require "yaml"
 
 module TensorStream
   # A .pb graph deserializer
@@ -14,7 +14,7 @@ module TensorStream
     # parsers a protobuf file and spits out
     # a ruby hash
     def load(pbfile)
-      f = File.new(pbfile, 'r')
+      f = File.new(pbfile, "r")
       lines = []
       while !f.eof? && (str = f.readline.strip)
         lines << str
@@ -23,38 +23,38 @@ module TensorStream
     end
 
     def parse_value(value_node)
-      return unless value_node['tensor']
+      return unless value_node["tensor"]
 
-      evaluate_tensor_node(value_node['tensor'])
+      evaluate_tensor_node(value_node["tensor"])
     end
 
     def evaluate_tensor_node(node)
-      if !node['shape'].empty? && node['tensor_content']
-        content = node['tensor_content']
-        unpacked = eval(%Q("#{content}"))
+      if !node["shape"].empty? && node["tensor_content"]
+        content = node["tensor_content"]
+        unpacked = eval(%("#{content}"))
 
-        if node['dtype'] == 'DT_FLOAT'
-          TensorShape.reshape(unpacked.unpack('f*'), node['shape'])
-        elsif node['dtype'] == 'DT_INT32'
-          TensorShape.reshape(unpacked.unpack('l*'), node['shape'])
-        elsif node['dtype'] == 'DT_STRING'
-          node['string_val']
+        if node["dtype"] == "DT_FLOAT"
+          TensorShape.reshape(unpacked.unpack("f*"), node["shape"])
+        elsif node["dtype"] == "DT_INT32"
+          TensorShape.reshape(unpacked.unpack("l*"), node["shape"])
+        elsif node["dtype"] == "DT_STRING"
+          node["string_val"]
         else
-          raise "unknown dtype #{node['dtype']}"
+          raise "unknown dtype #{node["dtype"]}"
         end
       else
 
-        val = if node['dtype'] == 'DT_FLOAT'
-                node['float_val'] ? node['float_val'].to_f : []
-              elsif node['dtype'] == 'DT_INT32'
-                node['int_val'] ? node['int_val'].to_i : []
-              elsif node['dtype'] == 'DT_STRING'
-                node['string_val']
-              else
-                raise "unknown dtype #{node['dtype']}"
-              end
+        val = if node["dtype"] == "DT_FLOAT"
+          node["float_val"] ? node["float_val"].to_f : []
+        elsif node["dtype"] == "DT_INT32"
+          node["int_val"] ? node["int_val"].to_i : []
+        elsif node["dtype"] == "DT_STRING"
+          node["string_val"]
+        else
+          raise "unknown dtype #{node["dtype"]}"
+        end
 
-        if node['shape'] == [1]
+        if node["shape"] == [1]
           [val]
         else
           val
@@ -63,16 +63,16 @@ module TensorStream
     end
 
     def map_type_to_ts(attr_value)
-      case(attr_value)
-      when 'DT_FLOAT'
+      case attr_value
+      when "DT_FLOAT"
         :float32
-      when 'DT_INT32'
+      when "DT_INT32"
         :int32
-      when 'DT_INT64'
+      when "DT_INT64"
         :int64
-      when 'DT_STRING'
+      when "DT_STRING"
         :string
-      when 'DT_BOOL'
+      when "DT_BOOL"
         :boolean
       else
         raise "unknown type #{attr_value}"
@@ -80,21 +80,21 @@ module TensorStream
     end
 
     def options_evaluator(node)
-      return {} if node['attributes'].nil?
+      return {} if node["attributes"].nil?
 
-      node['attributes'].map do |attribute|
-        attr_type, attr_value = attribute['value'].flat_map { |k, v| [k, v] }
+      node["attributes"].map { |attribute|
+        attr_type, attr_value = attribute["value"].flat_map { |k, v| [k, v] }
 
-        if attr_type == 'tensor'
+        if attr_type == "tensor"
           attr_value = evaluate_tensor_node(attr_value)
-        elsif attr_type == 'type'
+        elsif attr_type == "type"
           attr_value = map_type_to_ts(attr_value)
-        elsif attr_type == 'b'
-          attr_value = attr_value == 'true'
+        elsif attr_type == "b"
+          attr_value = attr_value == "true"
         end
 
-        [attribute['key'], attr_value]
-      end.to_h
+        [attribute["key"], attr_value]
+      }.to_h
     end
 
     protected
@@ -108,126 +108,126 @@ module TensorStream
       lines.each do |str|
         case state
         when :top
-          node['type'] = parse_node_name(str)
+          node["type"] = parse_node_name(str)
           state = :node_context
           next
         when :node_context
-          if str == 'attr {'
+          if str == "attr {"
             state = :attr_context
             node_attr = {}
-            node['attributes'] ||= []
-            node['attributes'] << node_attr
+            node["attributes"] ||= []
+            node["attributes"] << node_attr
             next
-          elsif str == '}'
+          elsif str == "}"
             state = :top
             block << node
             node = {}
             next
           else
-            key, value = str.split(':', 2)
-            if key == 'input'
-              node['input'] ||= []
-              node['input'] << process_value(value.strip)
+            key, value = str.split(":", 2)
+            if key == "input"
+              node["input"] ||= []
+              node["input"] << process_value(value.strip)
             else
               node[key] = process_value(value.strip)
             end
           end
         when :attr_context
-          if str == 'value {'
+          if str == "value {"
             state = :value_context
-            node_attr['value'] = {}
+            node_attr["value"] = {}
             next
-          elsif str == '}'
+          elsif str == "}"
             state = :node_context
             next
           else
-            key, value = str.split(':', 2)
+            key, value = str.split(":", 2)
             node_attr[key] = process_value(value.strip)
           end
         when :value_context
-          if str == 'list {'
+          if str == "list {"
             state = :list_context
-            node_attr['value'] = []
+            node_attr["value"] = []
             next
-          elsif str == 'shape {'
+          elsif str == "shape {"
             state = :shape_context
-            node_attr['value']['shape'] = []
+            node_attr["value"]["shape"] = []
             next
-          elsif str == 'tensor {'
+          elsif str == "tensor {"
             state = :tensor_context
-            node_attr['value']['tensor'] = {}
+            node_attr["value"]["tensor"] = {}
             next
-          elsif str == '}'
+          elsif str == "}"
             state = :attr_context
             next
           else
-            key, value = str.split(':', 2)
-            if key == 'dtype'
-              node_attr['value']['dtype'] = value.strip
-            elsif key == 'type'
-              node_attr['value']['type'] = value.strip
+            key, value = str.split(":", 2)
+            if key == "dtype"
+              node_attr["value"]["dtype"] = value.strip
+            elsif key == "type"
+              node_attr["value"]["type"] = value.strip
             else
-              node_attr['value'][key] = process_value(value.strip)
+              node_attr["value"][key] = process_value(value.strip)
             end
           end
         when :list_context
-          if str == '}'
+          if str == "}"
             state = :value_context
             next
           else
-            key, value = str.split(':', 2)
-            node_attr['value'] << { key => value }
+            key, value = str.split(":", 2)
+            node_attr["value"] << {key => value}
           end
         when :tensor_context
-          if str == 'tensor_shape {'
+          if str == "tensor_shape {"
             state = :tensor_shape_context
-            node_attr['value']['tensor']['shape'] = []
+            node_attr["value"]["tensor"]["shape"] = []
             next
-          elsif str == '}'
+          elsif str == "}"
             state = :value_context
             next
           else
-            key, value = str.split(':', 2)
-            if node_attr['value']['tensor'][key] && !node_attr['value']['tensor'][key].is_a?(Array)
-              node_attr['value']['tensor'][key] = [node_attr['value']['tensor'][key]]
-              node_attr['value']['tensor'][key] << process_value(value.strip)
-            elsif node_attr['value']['tensor'][key]
-              node_attr['value']['tensor'][key] << process_value(value.strip)
+            key, value = str.split(":", 2)
+            if node_attr["value"]["tensor"][key] && !node_attr["value"]["tensor"][key].is_a?(Array)
+              node_attr["value"]["tensor"][key] = [node_attr["value"]["tensor"][key]]
+              node_attr["value"]["tensor"][key] << process_value(value.strip)
+            elsif node_attr["value"]["tensor"][key]
+              node_attr["value"]["tensor"][key] << process_value(value.strip)
             else
-              node_attr['value']['tensor'][key] = process_value(value.strip)
+              node_attr["value"]["tensor"][key] = process_value(value.strip)
             end
           end
         when :tensor_shape_context
-          if str == 'dim {'
+          if str == "dim {"
             state = :tensor_shape_dim_context
             next
-          elsif str == '}'
+          elsif str == "}"
             state = :tensor_context
             next
           end
         when :shape_context
-          if str == '}'
+          if str == "}"
             state = :value_context
             next
-          elsif str == 'dim {'
+          elsif str == "dim {"
             state = :shape_dim_context
             next
           end
         when :shape_dim_context
-          if str == '}'
+          if str == "}"
             state = :shape_context
             next
           else
-            _key, value = str.split(':', 2)
-            node_attr['value']['shape'] << value.strip.to_i
+            _key, value = str.split(":", 2)
+            node_attr["value"]["shape"] << value.strip.to_i
           end
         when :tensor_shape_dim_context
-          if str == '}'
+          if str == "}"
             state = :tensor_shape_context
             next
           else
-            _key, value = str.split(':', 2)
-            node_attr['value']['tensor']['shape'] << value.strip.to_i
+            _key, value = str.split(":", 2)
+            node_attr["value"]["tensor"]["shape"] << value.strip.to_i
           end
         end
       end
@@ -236,22 +236,22 @@ module TensorStream
     end
 
     def parse_node_name(str)
-      str.split(' ')[0]
+      str.split(" ")[0]
     end
 
     def process_value(value)
       if value.start_with?('"')
-        unescape(value.gsub!(/\A"|"\Z/, ''))
+        unescape(value.gsub!(/\A"|"\Z/, ""))
       else
         unescape(value)
       end
     end
 
     UNESCAPES = {
-      'a' => "\x07", 'b' => "\x08", 't' => "\x09",
-      'n' => "\x0a", 'v' => "\x0b", 'f' => "\x0c",
-      'r' => "\x0d", 'e' => "\x1b", "\\\\" => "\x5c",
-      "\"" => "\x22", "'" => "\x27"
+      "a" => "\x07", "b" => "\x08", "t" => "\x09",
+      "n" => "\x0a", "v" => "\x0b", "f" => "\x0c",
+      "r" => "\x0d", "e" => "\x1b", "\\\\" => "\x5c",
+      "\"" => "\x22", "'" => "\x27",
     }.freeze
 
     def unescape(str)
@@ -260,11 +260,11 @@ module TensorStream
         if $1
           $1 == '\\' ? '\\' : UNESCAPES[$1]
         elsif $2 # escape \u0000 unicode
-          ["#{$2}".hex].pack('U*')
+          [$2.to_s.hex].pack("U*")
         elsif $3 # escape \0xff or \xff
-          [$3].pack('H2')
+          [$3].pack("H2")
         end
       end
     end
   end
-end
+end