tensor_stream 1.0.4 → 1.0.9

data/lib/tensor_stream/ops.rb

@@ -70,9 +70,8 @@ module TensorStream
 
     ##
     # Outputs random values from a truncated normal distribution.
-    def truncated_normal(shape, dtype: :float32, mean: 0.0, stddev: 1.0, seed: nil, name: nil)
-      options = {dtype: dtype, mean: mean, stddev: stddev, seed: seed, name: name}
-      _op(:truncated_normal, shape, options)
+    def truncated_normal(shape, dtype: :float32, mean: 0.0, stddev: 1.0, seed: nil, name: nil, pre_gen_table_size: nil)
+      _op(:truncated_normal, shape, dtype: dtype, mean: mean, stddev: stddev, seed: seed, name: name, pre_gen_table_size: pre_gen_table_size)
     end
 
     ##
@@ -163,14 +162,6 @@ module TensorStream
       _op(:ones, shape, data_type: dtype, name: name)
     end
 
-    ##
-    # Returns the truth value of (x < y) element-wise.
-    # This operation supports broadcasting
-    def less(input_a, input_b, name: nil)
-      check_data_types(input_a, input_b)
-      _op(:less, input_a, input_b, name: name)
-    end
-
     ##
     # Returns the truth value of x AND y element-wise.
     def logical_and(input_a, input_b, name: nil)
@@ -203,6 +194,15 @@ module TensorStream
       end
     end
 
+    ##
+    # Partitions data into num_partitions tensors using indices from partitions
+    def dynamic_partition(data, partitions, num_partitions, name: nil)
+      result = _op(:dynamic_partition, data, partitions, num_partitions: num_partitions, name: nil)
+      num_partitions.times.map do |index|
+        result[index]
+      end
+    end
+
     def split(value, num_or_size_splits, axis: 0, num: nil, name: "split")
       value = convert_to_tensor(value)
       num_or_size_splits = convert_to_tensor(num_or_size_splits)
@@ -532,6 +532,9 @@ module TensorStream
       _op(:squeeze, value, axis: axis, name: nil)
     end
 
+    def clip_by_norm(tensor, clip_norm, axes: nil, name: nil)
+    end
+
     ##
     # Computes the difference between two lists of numbers or strings.
     # Given a list x and a list y, this operation returns a list out that represents all values

data/lib/tensor_stream/ops/bias_add.rb

@@ -0,0 +1,16 @@
+TensorStream::OpMaker.define_operation :bias_add do |op|
+  op.what_it_does "Adds bias to value."
+
+  op.parameter :value, "A Tensor", :nil, validate: 'NUMERIC_TYPES'
+  op.parameter :bias, "A 1 D tensor", :nil, validate: 'NUMERIC_TYPES'
+
+  op.supports_broadcasting!
+  op.exclude!
+
+  op.option :name, "Optional name", :nil
+  op.option :data_format, "A string. 'NHWC' and 'NCHW' are supported.", :nil
+
+  op.define_gradient do |grad, node, _params|
+    [grad, _op(:bias_add_grad, grad, data_format: node.options[:data_format])]
+  end
+end

data/lib/tensor_stream/ops/equal.rb

@@ -12,4 +12,8 @@ TensorStream::OpMaker.define_operation :equal do |op|
   op.define_gradient do |grad, node, params|
     _min_or_max_grad(node.inputs, grad, ->(a, b) { ts.equal(a, b) })
   end
+
+  op.define_data_type do
+    :boolean
+  end
 end

data/lib/tensor_stream/ops/greater.rb

@@ -8,4 +8,8 @@ TensorStream::OpMaker.define_operation :greater do |op|
   op.supports_broadcasting!
 
   op.option :name, "Optional name", :nil
+
+  op.define_data_type do
+    :boolean
+  end
 end

data/lib/tensor_stream/ops/greater_equal.rb

@@ -8,4 +8,8 @@ TensorStream::OpMaker.define_operation :greater_equal do |op|
   op.supports_broadcasting!
 
   op.option :name, "Optional name", :nil
+
+  op.define_data_type do
+    :boolean
+  end
 end

data/lib/tensor_stream/ops/less.rb

@@ -0,0 +1,19 @@
+TensorStream::OpMaker.define_operation :less do |op|
+  op.what_it_does "Returns the truth value of (x < y) element-wise."
+
+  op.parameter :input_a, "tensor X"
+  op.parameter :input_b, "tensor Y"
+
+  op.apply_data_type_coercion!
+  op.supports_broadcasting!
+
+  op.option :name, "Optional name", :nil
+
+  op.define_gradient do |grad, node, _params|
+    _min_or_max_grad(node.inputs, grad, ->(a, b) { ts.less(a, b) })
+  end
+
+  op.define_data_type do
+    :boolean
+  end
+end

data/lib/tensor_stream/ops/less_equal.rb

@@ -12,4 +12,8 @@ TensorStream::OpMaker.define_operation :less_equal do |op|
   op.define_gradient do |grad, node, params|
     _min_or_max_grad(node.inputs, grad, ->(a, b) { ts.greater_equal(a, b) })
   end
+
+  op.define_data_type do
+    :boolean
+  end
 end

data/lib/tensor_stream/ops/not_equal.rb

@@ -0,0 +1,19 @@
+TensorStream::OpMaker.define_operation :not_equal do |op|
+  op.what_it_does "Returns the truth value of (x != y) element-wise."
+
+  op.parameter :input_a, "tensor X"
+  op.parameter :input_b, "tensor Y"
+
+  op.apply_data_type_coercion!
+  op.supports_broadcasting!
+
+  op.option :name, "Optional name", :nil
+
+  op.define_gradient do |grad, node, params|
+    _min_or_max_grad(node.inputs, grad, ->(a, b) { ts.not_equal(a, b) })
+  end
+
+  op.define_data_type do
+    :boolean
+  end
+end

data/lib/tensor_stream/ops/rsqrt.rb

@@ -0,0 +1,11 @@
+TensorStream::OpMaker.define_operation :rsqrt do |op|
+  op.what_it_does "Computes reciprocal of square root of x element-wise."
+
+  op.parameter :input_a, "tensor X", validate: 'FLOATING_POINT_TYPES'
+  op.option :name, "Optional name", :nil
+
+  op.define_gradient do |grad, node, params|
+    # Returns -0.5 * grad * conj(y)^3.
+    i_op(:rsqrt_grad, node, grad)
+  end
+end

data/lib/tensor_stream/ops/strided_slice.rb

@@ -0,0 +1,24 @@
+TensorStream::OpMaker.define_operation :strided_slice do |op|
+  op.what_it_does "Extracts a strided slice of a tensor "
+  op.what_it_does "this op extracts a slice of size `(end-begin)/stride`
+  from the given `input_` tensor. Starting at the location specified by `begin`
+  the slice continues by adding `stride` to the index until all dimensions are
+  not less than `end`.
+  Note that a stride can be negative, which causes a reverse slice."
+
+  op.parameter :input, "A tensor"
+  op.parameter :_begin, "start index"
+  op.parameter :_end, "end index"
+  op.parameter :strides, "end index", :nil
+  op.option :name, "Optional name", :nil
+
+  op.define_gradient do |grad, node, params|
+    input, b_index, e_index, strides = params
+    x = ts.shape(input, out_type: node.inputs[0].data_type)
+
+    _op(:strided_slice_grad, x, b_index, e_index, strides, grad)
+  end
+
+  op.define_shape do |tensor|
+  end
+end

data/lib/tensor_stream/ops/sum.rb

@@ -7,14 +7,16 @@ TensorStream::OpMaker.define_operation :sum do |op|
   op.what_it_does "If axis has no entries, all dimensions are reduced, and a tensor with a single element is returned."
 
   op.parameter :input_a, "tensor X"
-  op.parameter :axis, "tensor X", :nil, validate: 'INTEGER_TYPES'
+  op.parameter :axis_p, "tensor X", :nil, validate: 'INTEGER_TYPES'
 
+  op.option :axis, "axis", :nil, exclude: true
   op.option :name, "Optional name", :nil
   op.option :keepdims, "If true, retains reduced dimensions with length 1.", :false
 
   op.add_custom "input_a = TensorStream.convert_to_tensor(input_a)"
   op.add_custom "return input_a if input_a.shape.scalar?"
-  op.add_custom "axis = cast_axis(input_a, axis)"
+  op.add_custom "axis_p = axis_p || axis"
+  op.add_custom "axis_p = cast_axis(input_a, axis_p)"
 
   op.define_gradient do |grad, node, params|
     x, y = params

data/lib/tensor_stream/ops/top_k.rb

@@ -0,0 +1,23 @@
+TensorStream::OpMaker.define_operation :top_k do |op|
+  op.what_it_does "Finds values and indices of the `k` largest entries for the last dimension."
+
+  op.parameter :input, "1-D or higher `Tensor` with last dimension at least `k`."
+  op.parameter :k, "0-D `int32` `Tensor`.  Number of top elements to look for along the last dimension (along each row for matrices)", 1
+  op.option :sorted, "If true the resulting `k` elements will be sorted by the values in descending order.", "true"
+  op.option :name, "Optional name", :nil
+
+  op.add_custom_post "[result[0], result[1]]"
+
+  op.define_shape do |tensor|
+    next nil unless tensor.inputs[0].shape.known?
+
+    input_shape = tensor.inputs[0].shape.shape.dup
+    k = tensor.options[:k]
+    input_shape[-1] = k
+    input_shape
+  end
+
+  op.define_gradient do |grad, node, params|
+    #TODO
+  end
+end

data/lib/tensor_stream/session.rb

@@ -18,17 +18,7 @@ module TensorStream
     end
 
     def get_evaluator_classes(evaluators)
-      @evaluator_classes = if evaluators.is_a?(Array)
-        if evaluators.empty?
-          TensorStream::Evaluator.default_evaluators
-        else
-          evaluators.collect { |name| Object.const_get("TensorStream::Evaluator::#{camelize(name.to_s)}") }
-        end
-      elsif evaluators.nil?
-        TensorStream::Evaluator.default_evaluators
-      else
-        [Object.const_get("TensorStream::Evaluator::#{camelize(evaluators.to_s)}")]
-      end
+      @evaluator_classes = TensorStream::EvaluatorUtils.get_evaluator_classes(evaluators)
     end
 
     def clear_session_cache
@@ -58,7 +48,8 @@ module TensorStream
       # scan for placeholders and assign value
       options[:feed_dict]&.each_key do |k|
         if k.is_a?(Placeholder)
-          context[k.name.to_sym] = options[:feed_dict][k]
+          ph = options[:feed_dict][k]
+          context[k.name.to_sym] = ph.is_a?(Tensor) ? ph.op : ph
         elsif k.is_a?(String)
           target_graph = args[0].graph
           node = target_graph.get_node(k)
@@ -98,6 +89,9 @@ module TensorStream
     end
 
     def close
+      # unlink resources to save memory
+      @last_session_context = nil
+      @session_cache = {}
       @closed = true
     end
 

data/lib/tensor_stream/tensor.rb

@@ -4,6 +4,7 @@ module TensorStream
   # Base class that defines a tensor like interface
   class Tensor
     include OpHelper
+    extend OpHelper
     include TensorMixins
 
     attr_reader :graph, :value

data/lib/tensor_stream/tensor_shape.rb

@@ -18,7 +18,8 @@ module TensorStream
     end
 
     def [](index)
-      @shape[index]
+      new_shape = @shape[index]
+      TensorShape.new(@shape[index])
     end
 
     def ndims
@@ -42,6 +43,36 @@ module TensorStream
       known?
     end
 
+    def merge_with(other)
+      assert_compatible_with(other)
+
+      if @shape.nil?
+        TensorShape.new(other)
+      else
+        TensorShape.new(@shape)
+      end
+    end
+
+    def compatible_with?(other)
+      other = as_dimension(other)
+
+      shape.nil? || other.nil? || shape == other
+    end
+
+    def as_dimension(value)
+      value.is_a?(TensorShape) ? value.shape : value
+    end
+
+    def value
+      shape
+    end
+
+    ##
+    # Raises an exception if `other` is not compatible with this shape.
+    def assert_compatible_with(other)
+      raise TensorStream::ValueError, "Dimensions #{self} and #{other} are not compatible" unless compatible_with?(other)
+    end
+
     def self.infer_shape(shape_a, shape_b)
       return nil if shape_a.nil? || shape_b.nil?
       return shape_a if shape_b.empty?

data/lib/tensor_stream/train/saver.rb

@@ -7,9 +7,9 @@ module TensorStream
     class Saver
       include TensorStream::OpHelper
 
-      def initialize
+      def initialize(var_list = nil)
         graph = TensorStream::Graph.get_default_graph
-        vars = graph.get_collection(GraphKeys::GLOBAL_VARIABLES)
+        vars = var_list || graph.get_collection(GraphKeys::GLOBAL_VARIABLES)
 
         @filename = graph["ts_filename"] || TensorStream.placeholder(:string, name: "ts_filename", shape: [])
 
@@ -50,7 +50,6 @@ module TensorStream
         meta_data = JSON.parse(File.read(meta_file))
         gs = meta_data["gs"]
         filename = File.join(modelpath, ["model", gs, ".ckpt"].compact.join("-"))
-
         session.run(@restore_op, feed_dict: {@filename => filename})
       end
 

data/lib/tensor_stream/utils.rb

@@ -45,25 +45,22 @@ module TensorStream
     # Creates a variable
     # A variable maintains state across sessions
     def variable(value, name: nil, initializer: nil, graph: nil, dtype: nil, trainable: true)
-      op = Graph.get_default_graph.add_op(:assign, nil, value)
       common_options = {
-        initializer: initializer || op,
+        initializer: TensorStream.convert_to_tensor(initializer || value),
         name: name,
         graph: graph,
         dtype: dtype,
         trainable: trainable,
       }
       tensor = if value.is_a?(String)
-        i_var(dtype || :string, 0, [], get_variable_scope, common_options)
-      elsif value.is_a?(Integer)
-        i_var(dtype || :int32, 0, [], get_variable_scope, common_options)
-      elsif value.is_a?(Float)
-        i_var(dtype || :float32, 0, [], get_variable_scope, common_options)
-      else
-        i_var(dtype || :float32, 0, nil, get_variable_scope, common_options)
-      end
-      op.set_input(0, tensor.op)
-      Graph.get_default_graph.add_node(op)
+                 i_var(dtype || :string, 0, [], get_variable_scope, common_options)
+               elsif value.is_a?(Integer)
+                 i_var(dtype || :int32, 0, [], get_variable_scope, common_options)
+               elsif value.is_a?(Float)
+                 i_var(dtype || :float32, 0, [], get_variable_scope, common_options)
+               else
+                 i_var(dtype || :float32, 0, nil, get_variable_scope, common_options)
+               end
       tensor
     end
 
@@ -219,6 +216,10 @@ module TensorStream
       TensorStream::Trainer
     end
 
+    def math
+      TensorStream::Maths
+    end
+
     def image
       TensorStream::Images
     end
@@ -242,12 +243,16 @@ module TensorStream
       return convert_to_tensor(value.call) if value.is_a?(Proc)
       # raise "Invalid tensor value" if value.nil?
 
-      if value.is_a?(Array) && value[0].is_a?(Tensor)
+      if value.is_a?(Array) && value.detect { |v| v.is_a?(Tensor) }
         return TensorStream.stack(value) if value.size > 1
 
         return TensorStream.expand_dims(value[0], 0)
       end
 
+      if value.is_a?(TensorShape)
+        value = value.shape
+      end
+
       check_if_dense(value)
       i_cons(value, dtype: dtype || Tensor.detect_type(value), name: name)
     end

data/lib/tensor_stream/utils/freezer.rb

@@ -19,7 +19,11 @@ module TensorStream
           node = graph.get_tensor_by_name(node_key)
           case node.operation
           when :variable_v2
-            value = node.container
+            value = Evaluator.read_variable(node.graph, node.options[:var_name])
+           if value.nil?
+             raise "#{node.options[:var_name]} has no value"
+           end
+
             options = {
               value: value,
               data_type: node.data_type,

data/lib/tensor_stream/utils/py_ports.rb

@@ -0,0 +1,11 @@
+module TensorStream
+  module PyPorts
+    def floor_div(a, b)
+      if (a.is_a?(Float))
+        (a.to_i / b.to_i).to_f
+      else
+        a / b
+      end
+    end
+  end
+end

data/lib/tensor_stream/variable.rb

@@ -46,17 +46,16 @@ module TensorStream
 
     def assign(value, name: nil, use_locking: false)
       TensorStream.check_data_types(self, value)
-      _op(:assign, self, value, name: name)
+      _op(:assign, value, name: name, var_name: @name)
     end
 
     def read_value
-      @value = buffer.to_ruby if buffer
-      @value
+      Evaluator.read_variable(@graph, @name)
     end
 
     def assign_add(value, name: nil)
       TensorStream.check_data_types(self, value)
-      _op(:assign_add, self, value, data_type: data_type, name: name)
+      _op(:assign_add, value, data_type: data_type, name: name, var_name: @name)
     end
 
     def to_math(_tensor, _name_only = false, _max_depth = 99, _unused = 0)
@@ -65,11 +64,15 @@ module TensorStream
 
     def assign_sub(value)
       TensorStream.check_data_types(self, value)
-      _op(:assign_sub, self, value)
+      _op(:assign_sub, value, data_type: data_type, name: name, var_name: @name)
     end
 
     def self.variables_initializer(collection)
-      TensorStream.group(TensorStream.get_default_graph.get_collection(collection).map(&:initializer))
+      global_variables_ops = TensorStream.get_default_graph.get_collection(collection).map do |variable|
+        _op(:assign, variable.initializer, var_name: variable.name)
+      end
+
+      TensorStream.group(global_variables_ops)
     end
 
     def self.global_variables_initializer