tensor_stream 0.7.0 → 0.8.0

data/lib/tensor_stream/nn/nn_ops.rb

@@ -25,8 +25,8 @@ module TensorStream
         logits = tf.convert_to_tensor(logits, name: 'logits')
         labels = tf.convert_to_tensor(labels, name: 'labels')
         labels = tf.cast(labels, logits.dtype)
-        softmax_logits = _op(:softmax_cross_entropy_with_logits_v2, logits, labels)
-        tf.reduce_sum(softmax_logits, tf.rank(logits) - 1)
+        output = _op(:softmax_cross_entropy_with_logits_v2, logits, labels)
+        output[0]
       end
     end
 
@@ -45,10 +45,8 @@ module TensorStream
         relu_logits = tf.where(cond, logits, zeros)
         neg_abs_logits = tf.where(cond, -logits, logits)
 
-        return tf.add(
-            relu_logits - logits * labels,
-            tf.log1p(tf.exp(neg_abs_logits)),
-            name: name)
+        tf.add(relu_logits - logits * labels,
+               tf.log1p(tf.exp(neg_abs_logits)), name: name)
       end
     end
   end

data/lib/tensor_stream/operation.rb

@@ -87,124 +87,124 @@ module TensorStream
       end
     end
 
-    def to_math(name_only = false, max_depth = 99, _cur_depth = 0)
+    def to_math(name_only = false, max_depth = 99, cur_depth = 0)
       return @name if max_depth.zero?
 
-      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]
+      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_input},#{options[:axis]})"
-      when :negate
-        "-#{sub_input}"
-      when :index
-        "#{sub_input}[#{sub_input2}]"
-      when :slice
-        "#{sub_input}[#{sub_input2}]"
-      when :assign_sub
-        "(#{inputs[0] ? inputs[0].name : 'self'} -= #{auto_math(inputs[1], name_only, 1)})"
-      when :assign_add
-        "(#{inputs[0] ? inputs[0].name : 'self'} += #{auto_math(inputs[1], name_only, 1)})"
-      when :assign
-        "(#{inputs[0] ? inputs[0].name : 'self'} = #{auto_math(inputs[1], name_only, 1)})"
-      when :sin, :cos, :tanh
-        "#{operation}(#{sub_input})"
-      when :add
-        "(#{sub_input} + #{sub_input2})"
-      when :sub
-        "(#{sub_input} - #{sub_input2})"
-      when :pow
-        "(#{sub_input}^#{sub_input2})"
-      when :div
-        "(#{sub_input} / #{sub_input2})"
-      when :mul
-        if auto_math(inputs[0]) == 1
-          sub_input2
-        elsif auto_math(inputs[1]) == 1
-          sub_input
-        else
-          "(#{sub_input} * #{sub_input2})"
-        end
-      when :sum
-        "sum(|#{sub_input}|,  axis=#{sub_input2})"
-      when :mean
-        "mean(|#{sub_input}|, axis=#{sub_input2})"
-      when :prod
-        "prod(|#{sub_input}|,  axis=#{sub_input2})"
-      when :gradients
-        "gradient(#{sub_input})"
-      when :stop_gradient
-        sub_input
-      when :mat_mul
-        "#{sub_input}.matmul(#{sub_input2})"
-      when :eye
-        "eye(#{sub_input})"
-      when :transpose
-        "transpose(#{sub_input})"
-      when :shape
-        "#{sub_input}.shape"
-      when :exp
-        "e^#{sub_input})"
-      when :ones
-        "ones(#{sub_input})"
-      when :ones_like
-        "ones_like(#{sub_input})"
-      when :flow_group
-        "flow_group(#{inputs.collect { |i| auto_math(i, name_only, max_depth - 1, _cur_depth) }.join(',')})"
-      when :zeros
-        "zeros(#{sub_input})"
-      when :reshape
-        "reshape(#{sub_input},#{sub_input2})"
-      when :rank
-        "#{sub_input}.rank"
-      when :cond
-        "(#{auto_math(options[:pred], name_only, max_depth - 1, _cur_depth)} ? #{sub_input} : #{sub_input2})"
-      when :less
-        "#{sub_input} < #{sub_input2}"
-      when :less_equal
-        "#{sub_input} <= #{sub_input2}"
-      when :greater
-        "#{sub_input} > #{sub_input2}"
-      when :greater_equal
-        "#{sub_input} >= #{sub_input2}"
-      when :square
-        "#{sub_input}\u00B2"
-      when :log
-        "log(#{sub_input})"
-      when :identity
-        "identity(#{sub_input})"
-      when :print
-        "print(#{sub_input})"
-      when :pad
-        "pad(#{sub_input},#{auto_math(options[:paddings])})"
-      when :equal
-        "#{sub_input} == #{sub_input2}"
-      when :not_equal
-        "#{sub_input} != #{sub_input2}"
-      when :logical_and
-        "#{sub_input} && #{sub_input2}"
-      when :sqrt
-        "sqrt(#{sub_input})"
-      when :log1p
-        "log1p(#{sub_input})"
-      when :zeros_like
-        "zeros_like(#{sub_input})"
-      when :where
-        "where(#{auto_math(options[:pred], name_only, max_depth - 1, _cur_depth)}, #{sub_input}, #{sub_input2})"
-      when :max
-        "max(#{sub_input},#{sub_input2})"
-      when :cast
-        "cast(#{sub_input}, #{data_type})"
-      when :broadcast_transform
-        "broadcast_transform(#{sub_input},#{sub_input2})"
-      when :broadcast_gradient_args
-        "broadcast_transform(#{sub_input},#{sub_input2})"
-      else
-        "#{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
+            when :argmax
+              "argmax(#{sub_input},#{options[:axis]})"
+            when :negate
+              "-#{sub_input}"
+            when :index
+              "#{sub_input}[#{sub_input2}]"
+            when :slice
+              "#{sub_input}[#{sub_input2}]"
+            when :assign_sub
+              "(#{inputs[0] ? inputs[0].name : 'self'} -= #{auto_math(inputs[1], name_only, 1)})"
+            when :assign_add
+              "(#{inputs[0] ? inputs[0].name : 'self'} += #{auto_math(inputs[1], name_only, 1)})"
+            when :assign
+              "(#{inputs[0] ? inputs[0].name : 'self'} = #{auto_math(inputs[1], name_only, 1)})"
+            when :sin, :cos, :tanh
+              "#{operation}(#{sub_input})"
+            when :add
+              "(#{sub_input} + #{sub_input2})"
+            when :sub
+              "(#{sub_input} - #{sub_input2})"
+            when :pow
+              "(#{sub_input}^#{sub_input2})"
+            when :div
+              "(#{sub_input} / #{sub_input2})"
+            when :mul
+              if auto_math(inputs[0]) == 1
+                sub_input2
+              elsif auto_math(inputs[1]) == 1
+                sub_input
+              else
+                "(#{sub_input} * #{sub_input2})"
+              end
+            when :sum
+              "sum(|#{sub_input}|,  axis=#{sub_input2})"
+            when :mean
+              "mean(|#{sub_input}|, axis=#{sub_input2})"
+            when :prod
+              "prod(|#{sub_input}|,  axis=#{sub_input2})"
+            when :gradients
+              "gradient(#{sub_input})"
+            when :stop_gradient
+              sub_input
+            when :mat_mul
+              "#{sub_input}.matmul(#{sub_input2})"
+            when :eye
+              "eye(#{sub_input})"
+            when :transpose
+              "transpose(#{sub_input})"
+            when :shape
+              "#{sub_input}.shape"
+            when :exp
+              "e^#{sub_input})"
+            when :ones
+              "ones(#{sub_input})"
+            when :ones_like
+              "ones_like(#{sub_input})"
+            when :flow_group
+              "flow_group(#{inputs.collect { |i| auto_math(i, name_only, max_depth - 1, cur_depth) }.join(',')})"
+            when :zeros
+              "zeros(#{sub_input})"
+            when :reshape
+              "reshape(#{sub_input},#{sub_input2})"
+            when :rank
+              "#{sub_input}.rank"
+            when :cond
+              "(#{auto_math(options[:pred], name_only, max_depth - 1, cur_depth)} ? #{sub_input} : #{sub_input2})"
+            when :less
+              "#{sub_input} < #{sub_input2}"
+            when :less_equal
+              "#{sub_input} <= #{sub_input2}"
+            when :greater
+              "#{sub_input} > #{sub_input2}"
+            when :greater_equal
+              "#{sub_input} >= #{sub_input2}"
+            when :square
+              "#{sub_input}\u00B2"
+            when :log
+              "log(#{sub_input})"
+            when :identity
+              "identity(#{sub_input})"
+            when :print
+              "print(#{sub_input})"
+            when :pad
+              "pad(#{sub_input},#{auto_math(options[:paddings])})"
+            when :equal
+              "#{sub_input} == #{sub_input2}"
+            when :not_equal
+              "#{sub_input} != #{sub_input2}"
+            when :logical_and
+              "#{sub_input} && #{sub_input2}"
+            when :sqrt
+              "sqrt(#{sub_input})"
+            when :log1p
+              "log1p(#{sub_input})"
+            when :zeros_like
+              "zeros_like(#{sub_input})"
+            when :where
+              "where(#{auto_math(options[:pred], name_only, max_depth - 1, cur_depth)}, #{sub_input}, #{sub_input2})"
+            when :max
+              "max(#{sub_input},#{sub_input2})"
+            when :cast
+              "cast(#{sub_input}, #{data_type})"
+            when :broadcast_transform
+              "broadcast_transform(#{sub_input},#{sub_input2})"
+            when :broadcast_gradient_args
+              "broadcast_transform(#{sub_input},#{sub_input2})"
+            else
+              "#{operation}(#{sub_input})" if sub_input
+              "#{operation}(#{sub_input}, #{sub_input2})" if sub_input && sub_input2
+            end
+      ["\n", Array.new(cur_depth + 1) { ' ' }, out].flatten.join
     end
 
     def run
@@ -232,7 +232,7 @@ module TensorStream
 
         axis = inputs[1].is_a?(Tensor) ? inputs[1].value : inputs[1]
 
-        axis = [ axis ] unless axis.is_a?(Array)
+        axis = [axis] unless axis.is_a?(Array)
         return input_shape.each_with_index.map do |s, index|
           next nil if axis.include?(index)
           s
@@ -240,6 +240,7 @@ module TensorStream
       when :reshape
         new_shape = inputs[1] && inputs[1].value ? inputs[1].value : nil
         return nil if new_shape.nil?
+        return nil if inputs[0].shape.nil?
 
         input_shape = inputs[0].shape.shape
         return new_shape if input_shape.nil?
@@ -257,11 +258,29 @@ module TensorStream
         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]
+      when :transpose
+        return nil unless shape_full_specified(inputs[0])
+        return nil if inputs[1].is_a?(Tensor)
+
+        rank = inputs[0].shape.shape.size
+        perm = inputs[1] || (0...rank).to_a.reverse
+        return perm.map { |p| inputs[0].shape.shape[p] }
+      when :stack
+        return nil unless shape_full_specified(inputs[0])
+
+        axis = options[:axis] || 0
+        new_shape = [inputs.size]
+        inputs[0].shape.shape.inject(new_shape) { |ns, s| ns << s }
+        rank = inputs[0].shape.shape.size + 1
+        axis = rank + axis if axis < 0
+        rotated_shape = Array.new(axis + 1) { new_shape.shift }
+        rotated_shape.rotate! + new_shape
+      when :tile
+        nil
       else
+        return nil if inputs[0].nil?
         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
+        return TensorShape.infer_shape(inputs[0].shape.shape, inputs[1].shape.shape) if inputs.size == 2 && inputs[0] && inputs[1]
       end
 
       nil
@@ -287,8 +306,8 @@ module TensorStream
           input.flatten.compact.each do |t|
             t.send(:setup_output, self) if t.is_a?(Tensor)
           end
-        else
-          input.send(:setup_output, self) if input.is_a?(Tensor) && (input.name != self.name)
+        elsif input.is_a?(Tensor) && (input.name != name)
+          input.send(:setup_output, self)
         end
       end
     end

data/lib/tensor_stream/ops.rb

@@ -245,7 +245,7 @@ module TensorStream
     ##
     # Concatenates tensors along one dimension.
     def concat(values, axis, name: 'concat')
-      _op(:concat, values, nil, axis: axis, name: name)
+      _op(:concat, *values, axis: axis, name: name)
     end
 
     ##
@@ -318,6 +318,13 @@ module TensorStream
       _op(:acos, input, name: name)
     end
 
+    ##
+    # Computes atan of input element-wise
+    def atan(input, name: nil)
+      check_allowed_types(input, FLOATING_POINT_TYPES)
+      _op(:atan, input, name: name)
+    end
+
     ##
     # Returns x - y element-wise.
     #
@@ -582,8 +589,8 @@ module TensorStream
 
     ##
     # Transposes a. Permutes the dimensions according to perm.
-    def transpose(tensor, perm: nil, name: 'transpose')
-      _op(:transpose, tensor, nil, perm: perm, name: name)
+    def transpose(tensor, perm = nil, name: 'transpose')
+      _op(:transpose, tensor, perm, name: name)
     end
 
     ##
@@ -612,5 +619,31 @@ module TensorStream
       op_result = _op(:broadcast_gradient_args, shape_a, shape_b, name: name)
       [op_result[0], op_result[1]]
     end
+
+    ##
+    # Gather slices from params and axis according to indices.
+    #
+    def gather(params, indices, validate_indices: nil,
+                                name: nil,
+                                axis: 0)
+      _op(:gather, params, indices, validate_indices: validate_indices, name: name, axis: axis)
+    end
+
+    def stack(values, axis: 0, name: 'stack')
+      _op(:stack, *values, axis: axis, name: name)
+    end
+
+    def setdiff1d(x, y, index_dtype: :int32, name: nil)
+      result = _op(:setdiff1d, x, y, index_dtype: index_dtype, name: name)
+      [result[0], result[1]]
+    end
+
+    def cumprod(x, axis: 0, exclusive: false, reverse: false, name: nil)
+      _op(:cumprod, x, axis: axis, exclusive: exclusive, reverse: reverse, name: name)
+    end
+
+    def invert_permutation(x, name: nil)
+      _op(:invert_permutation, x, name: name)
+    end
   end
 end

data/lib/tensor_stream/session.rb

@@ -22,7 +22,7 @@ module TensorStream
                              if evaluators.empty?
                                TensorStream::Evaluator.default_evaluators
                              else
-                               evaluators.collect { |name|  Object.const_get("TensorStream::Evaluator::#{camelize(name.to_s)}") }
+                               evaluators.collect { |name| Object.const_get("TensorStream::Evaluator::#{camelize(name.to_s)}") }
                              end
                            elsif evaluators.nil?
                              TensorStream::Evaluator.default_evaluators
@@ -52,9 +52,7 @@ module TensorStream
       # scan for placeholders and assign value
       if options[:feed_dict]
         options[:feed_dict].keys.each do |k|
-          if k.is_a?(Placeholder)
-            context[k.name.to_sym] = options[:feed_dict][k]
-          end
+          context[k.name.to_sym] = options[:feed_dict][k] if k.is_a?(Placeholder)
         end
       end
 
@@ -77,7 +75,7 @@ module TensorStream
     end
 
     def list_devices
-      TensorStream::Evaluator.evaluators.collect do |k, v|
+      TensorStream::Evaluator.evaluators.collect do |_k, v|
         v[:class].query_supported_devices.collect do |device|
           device
         end
@@ -102,10 +100,10 @@ module TensorStream
 
     def dump_ops(tensor, selector)
       graph = tensor.graph
-      graph.nodes.select { |k, v| selector.call(k, v) }.collect { |k, node|
+      graph.nodes.select { |k, v| selector.call(k, v) }.collect do |k, node|
         next unless @last_session_context[node.name]
         "#{k} #{node.to_math(true, 1)} = #{@last_session_context[node.name]}"
-      }.compact
+      end.compact
     end
 
     def graph_ml(tensor, filename)
@@ -115,9 +113,7 @@ module TensorStream
     def delegate_to_evaluator(tensor_arr, session_context, context)
       arr = tensor_arr.is_a?(Array) ? tensor_arr : [tensor_arr]
       result = arr.collect do |tensor|
-        if session_context[:_cache][:placement][tensor.name].nil?
-          session_context[:_cache][:placement][tensor.name] = assign_evaluator(tensor)
-        end
+        session_context[:_cache][:placement][tensor.name] = assign_evaluator(tensor) if session_context[:_cache][:placement][tensor.name].nil?
 
         session_context[:_cache][:placement][tensor.name][1].run_with_buffer(tensor, session_context, context)
       end
@@ -144,7 +140,7 @@ module TensorStream
 
       raise "no evaluator available to execute #{tensor.operation}" if device.nil?
 
-      key = "#{device.evaluator.to_s}/#{device.name}"
+      key = "#{device.evaluator}/#{device.name}"
       if @evaluators.key?(key)
         @evaluators[key]
       else

data/lib/tensor_stream/tensor.rb

@@ -4,9 +4,9 @@ module TensorStream
   # Base class that defines a tensor like interface
   class Tensor
     include OpHelper
-
+    attr_reader :graph
     attr_accessor :name, :data_type, :shape, :rank, :native_buffer, :is_const,
-                  :value, :breakpoint, :internal, :source, :given_name, :graph,
+                  :value, :breakpoint, :internal, :source, :given_name,
                   :consumers, :outputs, :device
 
     def initialize(data_type, rank, shape, options = {})
@@ -174,7 +174,7 @@ module TensorStream
     end
 
     def op
-      is_const ? _op(:const, self, nil, name: name) : _op(:variable, self, nil, name: name)
+      @op ||= is_const ? _op(:const, self, nil, name: name) : _op(:variable, self, nil, name: name)
     end
 
     def eval(options = {})