tensor_stream 1.0.0 → 1.0.1

data/lib/tensor_stream/ops/ones_like.rb

@@ -0,0 +1,19 @@
+TensorStream::OpMaker.define_operation :ones_like do |op|
+  op.what_it_does "Creates a tensor with all elements set to 1."
+  op.what_it_does "Given a single tensor (tensor), this operation returns a"
+  op.what_it_does "tensor of the same type and shape as tensor with all elements set to 1."
+  op.what_it_does "Optionally, you can specify a new type (dtype) for the returned tensor."
+
+
+  op.parameter :input, "A tensor"
+  op.option :dtype, "Optional new data type to cast into", :nil, alias: :data_type
+  op.option :name, "Optional name", :nil
+
+  op.define_shape do |tensor|
+    tensor.inputs[0].shape.shape
+  end
+
+  op.define_gradient do |grad, node, params|
+    nil # non differentiable
+  end
+end

data/lib/tensor_stream/ops/pow.rb

@@ -0,0 +1,25 @@
+TensorStream::OpMaker.define_operation :pow do |op|
+  op.what_it_does "Computes the power of one value to another 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|
+    x, y = params
+    z = node
+    sx = ts.shape(x)
+    sy = ts.shape(y)
+    rx, ry = _broadcast_gradient_args(sx, sy)
+    gx = ts.reduce_sum(grad * y * ts.pow(x, y - 1), rx)
+
+    log_x = ts.where(x > 0, ts.log(x), ts.zeros_like(x))
+    gy = ts.reduce_sum(grad * z * log_x, ry)
+
+    [gx, gy]
+  end
+end

data/lib/tensor_stream/ops/prod.rb

@@ -0,0 +1,60 @@
+TensorStream::OpMaker.define_operation :prod do |op|
+  op.other_names %w(reduce_prod)
+  op.what_it_does "Computes the product of elements across dimensions of a tensor."
+  op.what_it_does "Reduces input_tensor along the dimensions given in axis. Unless keepdims is true, the rank of the"
+  op.what_it_does "tensor is reduced by 1 for each entry in axis. If keepdims is true, the reduced dimensions are"
+  op.what_it_does "retained with length 1."
+  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.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.define_gradient do |grad, node, params|
+    x, y = params
+    input_shape = ts.shape(x)
+    y = ts.range(0, ts.rank(x)) if y.nil?
+    reduction_indices = ts.reshape(y, [-1])
+
+    output_shape_kept_dims = ts.reduced_shape(input_shape, y)
+    tile_scaling = _safe_shape_div(input_shape, output_shape_kept_dims)
+    grad = ts.reshape(grad, output_shape_kept_dims)
+    grad = ts.tile(grad, tile_scaling)
+
+    perm, reduced_num, other_num = ts.device("/cpu:0") {
+      rank = ts.rank(x)
+      reduction_indices = (reduction_indices + rank) % rank
+      reduced = ts.cast(reduction_indices, :int32)
+      idx = ts.range(0, rank)
+      other, = ts.setdiff1d(idx, reduced)
+      [ts.concat([reduced, other], 0),
+       ts.reduce_prod(ts.gather(input_shape, reduced)),
+       ts.reduce_prod(ts.gather(input_shape, other)),]
+    }
+
+    permuted = ts.transpose(x, perm)
+    permuted_shape = ts.shape(permuted)
+
+    reshaped = ts.reshape(permuted, [reduced_num, other_num])
+
+    # Calculate product, leaving out the current entry
+    left = ts.cumprod(reshaped, axis: 0, exclusive: true)
+    right = ts.cumprod(reshaped, axis: 0, exclusive: true, reverse: true)
+    y = ts.reshape(left * right, permuted_shape)
+
+    # Invert the transpose and reshape operations.
+    # Make sure to set the statically known shape information through a reshape.
+    out = grad * ts.transpose(y, ts.invert_permutation(perm))
+    [ts.reshape(out, input_shape, name: "prod"), nil]
+  end
+
+  op.define_shape do |tensor|
+    _infer_reduction_op_shape(tensor)
+  end
+end

data/lib/tensor_stream/ops/random_uniform.rb

@@ -0,0 +1,18 @@
+TensorStream::OpMaker.define_operation :random_uniform do |op|
+  op.what_it_does "Outputs random values from a uniform distribution."
+
+  op.parameter :shape, "A 1-D integer Tensor or array. The shape of the output tensor."
+
+  op.option :name, "Optional name", :nil
+  op.option :dtype, "The type of the output: float16, float32, float64, int32, or int64", ":float32"
+  op.option :minval, "A 0-D Tensor or ruby value of type dtype. The lower bound on the range of random values to generate. Defaults to 0.", 0
+  op.option :maxval, "A 0-D Tensor or ruby value of type dtype. The upper bound on the range of random values to generate. Defaults to 1 if dtype is floating point.", 1
+  op.option :seed, " A ruby integer. Used to create a random seed for the distribution. See set_random_seed for behavior.", :nil
+
+  op.define_shape do |tensor|
+    a_shape = tensor.inputs[0] ? tensor.inputs[0].const_value : tensor.options[:shape]
+    next nil if a_shape.nil?
+
+    a_shape.is_a?(Array) ? a_shape : [a_shape]
+  end
+end

data/lib/tensor_stream/ops/range.rb

@@ -0,0 +1,20 @@
+TensorStream::OpMaker.define_operation :range do |op|
+  op.what_it_does "Creates a sequence of numbers."
+  op.what_it_does "Creates a sequence of numbers that begins at start and extends by increments of delta up to but not including limit."
+
+  op.parameter :start, "Acts as first entry in the range if limit is not nil; otherwise, acts as range limit and first entry defaults to 0.", "0"
+  op.parameter :limit, "Upper limit of sequence, exclusive. If nil, defaults to the value of start while the first entry of the range defaults to 0.", "0"
+  op.parameter :delta, "Number that increments start. Defaults to 1.", 1
+
+  op.option :name, " A name for the operation. Defaults to \"range\".", "\"range\""
+  op.option :dtype, "The type of the elements of the resulting tensor.", :nil
+  op.option :output_type, "Output data type defaults to int32", ":int32"
+
+  op.define_gradient do |grad, node, params|
+    nil # non differentiable
+  end
+
+  op.define_shape do |tensor|
+    nil
+  end
+end

data/lib/tensor_stream/ops/rank.rb

@@ -0,0 +1,13 @@
+TensorStream::OpMaker.define_operation :rank do |op|
+  op.what_it_does "Returns the rank of a tensor"
+
+  op.parameter :input, "A tensor"
+  op.option :name, "Optional name", :nil
+
+  op.add_custom "input = convert_to_tensor(input)"
+  op.add_custom "return cons(input.shape.ndims) if input.shape.known?"
+
+  op.define_shape do |tensor|
+    []
+  end
+end

data/lib/tensor_stream/ops/reshape.rb

@@ -0,0 +1,24 @@
+TensorStream::OpMaker.define_operation :reshape do |op|
+  op.what_it_does "Reshapes a tensor."
+  op.what_it_does "Given tensor, this operation returns a tensor that has the same values as tensor with shape shape."
+
+  op.parameter :input, "A tensor"
+  op.parameter :shape, "A new tensor shape"
+  op.option :name, "Optional name", :nil
+
+  op.define_gradient do |grad, node, params|
+    [ts.reshape(grad, ts.shape(node.inputs[0])), nil]
+  end
+
+  op.define_shape do |tensor|
+    new_shape = tensor.inputs[1]&.const_value ? tensor.inputs[1].const_value : nil
+    next nil if new_shape.nil?
+    next nil if tensor.inputs[0].shape.nil?
+
+    input_shape = tensor.inputs[0].shape.shape
+    next new_shape if input_shape.nil? && !new_shape.include?(-1) && !new_shape.include?(nil)
+    next nil if input_shape.nil? || input_shape.include?(nil)
+
+    TensorStream::TensorShape.fix_inferred_elements(new_shape, input_shape.reduce(:*))
+  end
+end

data/lib/tensor_stream/ops/round.rb

@@ -0,0 +1,15 @@
+TensorStream::OpMaker.define_operation :round do |op|
+  op.what_it_does "Rounds the values of a tensor to the nearest integer, 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|
+    nil
+  end
+
+  op.define_shape do |tensor|
+    tensor.inputs[0].shape.shape
+  end
+end

data/lib/tensor_stream/ops/shape.rb

@@ -0,0 +1,14 @@
+TensorStream::OpMaker.define_operation :shape do |op|
+  op.what_it_does "This operation returns a 1-D integer tensor representing the shape of input"
+
+  op.parameter :input, "A tensor"
+  op.option :name, "Optional name", :nil
+  op.option :out_type, "Optional output type", ":int32"
+
+  op.add_custom 'return constant(shape_eval(input, out_type), dtype: out_type, name: "Shape/#{name}") if input.is_a?(Array) && !input[0].is_a?(Tensor)'
+  op.add_custom 'return constant(input.shape.shape, dtype: out_type, name: "Shape/#{input.name}_c") if shape_full_specified(input)'
+
+  op.define_shape do |tensor|
+    tensor.inputs[0].shape.shape ? [tensor.inputs[0].shape.shape.size] : nil
+  end
+end

data/lib/tensor_stream/ops/sigmoid.rb

@@ -0,0 +1,10 @@
+TensorStream::OpMaker.define_operation :sigmoid do |op|
+  op.what_it_does "Computes sigmoid 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|
+    i_op(:sigmoid_grad, params[0], grad)
+  end
+end

data/lib/tensor_stream/ops/sign.rb

@@ -0,0 +1,12 @@
+TensorStream::OpMaker.define_operation :sign do |op|
+  op.what_it_does      "Computes sign of input element-wise."
+  op.what_it_does_code "y = sign(x) = -1 if x < 0; 0 if x == 0 or tf.is_nan(x); 1 if x > 0."
+  op.what_it_does      "Zero is returned for NaN inputs."
+
+  op.parameter :input_a, "tensor X"
+  op.option :name, "Optional name", :nil
+
+  op.define_gradient do |grad, node, params|
+    ts.zeros(ts.shape(params[0]), dtype: params[0].data_type)
+  end
+end

data/lib/tensor_stream/ops/sin.rb

@@ -0,0 +1,10 @@
+TensorStream::OpMaker.define_operation :sin do |op|
+  op.what_it_does "Computes sin of input 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|
+    grad * ts.cos(params[0])
+  end
+end

data/lib/tensor_stream/ops/size.rb

@@ -0,0 +1,16 @@
+TensorStream::OpMaker.define_operation :size do |op|
+  op.what_it_does "Returns the size of a tensor."
+  op.what_it_does "Returns a 0-D Tensor representing the number of elements in input of type out_type. Defaults to :int32."
+
+  op.parameter :input, "A tensor"
+  op.option :name, "Optional name", :nil
+  op.option :out_type, "Optional output type", ":int32"
+
+  op.define_gradient do |grad, node, params|
+    nil # non differentiable
+  end
+
+  op.define_shape do |tensor|
+    []
+  end
+end

data/lib/tensor_stream/ops/sub.rb

@@ -0,0 +1,24 @@
+TensorStream::OpMaker.define_operation :sub do |op|
+  op.other_names %w(subtract)
+  op.what_it_does "Returns 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|
+    x, y = params
+    next [grad, -grad] if shapes_fully_specified_and_equal(x, y)
+
+    sx = ts.shape(x, name: "sub/shape_x")
+    sy = ts.shape(y, name: "sub/shape_y")
+    rx, ry = _broadcast_gradient_args(sx, sy)
+
+    [ts.reshape(ts.reduce_sum(grad, rx, name: "add/reduce_sub_x"), sx),
+     -ts.reshape(ts.reduce_sum(grad, ry, name: "add/reduce_sub_y"), sy),]
+  end
+end

data/lib/tensor_stream/ops/sum.rb

@@ -0,0 +1,27 @@
+TensorStream::OpMaker.define_operation :sum do |op|
+  op.other_names %w(reduce_sum)
+  op.what_it_does "Computes the sum of elements across dimensions of a tensor."
+  op.what_it_does "Reduces input_tensor along the dimensions given in axis. Unless keepdims is true, the rank of the"
+  op.what_it_does "tensor is reduced by 1 for each entry in axis. If keepdims is true, the reduced dimensions are"
+  op.what_it_does "retained with length 1."
+  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.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.define_gradient do |grad, node, params|
+    x, y = params
+    _sum_grad(x, y, grad)
+  end
+
+  op.define_shape do |tensor|
+    _infer_reduction_op_shape(tensor)
+  end
+end

data/lib/tensor_stream/ops/tan.rb

@@ -0,0 +1,12 @@
+TensorStream::OpMaker.define_operation :tan do |op|
+  op.what_it_does "Computes tan of input 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|
+    secx = ts.reciprocal(ts.cos(params[0]))
+    secx2 = ts.square(secx)
+    grad * secx2
+  end
+end

data/lib/tensor_stream/ops/tanh.rb

@@ -0,0 +1,10 @@
+TensorStream::OpMaker.define_operation :tanh do |op|
+  op.what_it_does "Computes tanh of input 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|
+    grad * i_op(:tanh_grad, params[0])
+  end
+end

data/lib/tensor_stream/ops/tile.rb

@@ -0,0 +1,19 @@
+TensorStream::OpMaker.define_operation :tile do |op|
+  op.what_it_does "Constructs a tensor by tiling a given tensor."
+  op.what_it_does "This operation creates a new tensor by replicating input multiples times."
+  op.what_it_does "The output tensor's i'th dimension has input.dims(i) * multiples[i] elements,"
+  op.what_it_does "and the values of input are replicated multiples[i] times along the 'i'th dimension. For example, tiling [a b c d] by [2] produces [a b c d a b c d]."
+
+  op.parameter :input, "A tensor"
+  op.parameter :multiples, "Must be one of the following types: int32, int64. 1-D. Length must be the same as the number of dimensions in input"
+  op.option :name, "Optional name", :nil
+
+
+  op.define_gradient do |grad, node, params|
+    nil # non differentiable
+  end
+
+  op.define_shape do |tensor|
+    nil
+  end
+end

data/lib/tensor_stream/ops/zeros.rb

@@ -0,0 +1,15 @@
+TensorStream::OpMaker.define_operation :zeros do |op|
+  op.what_it_does "Creates a tensor with all elements set to zero"
+
+  op.parameter :shape, "A 1-D integer Tensor or ruby array. The shape of the output tensor."
+
+  op.option :dtype, "Optional name", ":float32"
+  op.option :name, "Optional name", :nil
+
+  op.define_shape do |tensor|
+    a_shape = tensor.inputs[0] ? tensor.inputs[0].const_value : tensor.options[:shape]
+    next nil if a_shape.nil?
+
+    a_shape.is_a?(Array) ? a_shape : [a_shape]
+  end
+end

data/lib/tensor_stream/placeholder.rb

@@ -10,12 +10,12 @@ module TensorStream
       @value = nil
       @is_const = false
 
-      @name = [@graph.get_name_scope, options[:name] || build_name].compact.reject(&:empty?).join('/')
+      @name = [@graph.get_name_scope, options[:name] || build_name].compact.reject(&:empty?).join("/")
       @op = Graph.get_default_graph.add_op!(:placeholder, data_type: @data_type, shape: @shape, internal_name: @name)
     end
 
     def inspect
-      "Placeholder(#{@name} shape: #{@shape || '?'} data_type: #{@data_type})"
+      "Placeholder(#{@name} shape: #{@shape || "?"} data_type: #{@data_type})"
     end
 
     private

data/lib/tensor_stream/profile/report_tool.rb

@@ -4,9 +4,9 @@ module TensorStream
   class ReportTool
     def self.profile_for(session, order_by: :slowest)
       context = session.last_session_context
-      eval_times = context[:profile][:operations].map do |name, profile|
+      eval_times = context[:profile][:operations].map { |name, profile|
         [name, profile[:op], profile[:eval_time], profile[:shape]]
-      end
+      }
 
       if order_by == :slowest
         eval_times.sort_by { |a| a[2] }.reverse!
@@ -15,4 +15,4 @@ module TensorStream
       end
     end
   end
-end
+end

data/lib/tensor_stream/session.rb

@@ -19,16 +19,16 @@ module TensorStream
 
     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
+        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
     end
 
     def clear_session_cache
@@ -41,10 +41,10 @@ module TensorStream
 
     def run(*args)
       options = if args.last.is_a?(Hash)
-                  args.pop
-                else
-                  {}
-                end
+        args.pop
+      else
+        {}
+      end
 
       @evaluator_options[:thread_pool] = @thread_pool
       @evaluator_options[:log_intermediates] = options[:log_intermediates]
@@ -52,25 +52,23 @@ module TensorStream
       context = {
         _cache: @session_cache,
         _options: options.merge(@evaluator_options),
-        profile: { step: 0, operations: {} },
+        profile: {step: 0, operations: {}},
       }
 
       # scan for placeholders and assign value
-      if options[:feed_dict]
-        options[:feed_dict].each_key do |k|
-          if k.is_a?(Placeholder)
-            context[k.name.to_sym] = options[:feed_dict][k]
-          elsif k.is_a?(String)
-            target_graph = args[0].graph
-            node = target_graph.get_node(k)
-            raise "Cannot find placeholder with the name of #{k}" if node.operation != :placeholder
-
-            context[k.to_sym] = options[:feed_dict][k]
-          elsif k.is_a?(Operation) && k.operation == :placeholder
-            context[k.name.to_sym] = options[:feed_dict][k]
-          else
-            raise "Invalid placeholder type passed key must be a string or a placeholder type"
-          end
+      options[:feed_dict]&.each_key do |k|
+        if k.is_a?(Placeholder)
+          context[k.name.to_sym] = options[:feed_dict][k]
+        elsif k.is_a?(String)
+          target_graph = args[0].graph
+          node = target_graph.get_node(k)
+          raise "Cannot find placeholder with the name of #{k}" if node.operation != :placeholder
+
+          context[k.to_sym] = options[:feed_dict][k]
+        elsif k.is_a?(Operation) && k.operation == :placeholder
+          context[k.name.to_sym] = options[:feed_dict][k]
+        else
+          raise "Invalid placeholder type passed key must be a string or a placeholder type"
         end
       end
 
@@ -82,21 +80,21 @@ module TensorStream
           puts "#{k} : #{v[0].name}"
         end
       end
-      result = args.collect do |e|
+      result = args.collect { |e|
         next e.value if e.is_a?(Tensor) && e.is_const && e.value
 
         value = delegate_to_evaluator(e, context, {})
         recursive_eval(value)
-      end
+      }
       args.size == 1 ? result.first : result
     end
 
     def list_devices
-      TensorStream::Evaluator.evaluators.collect do |_k, v|
+      TensorStream::Evaluator.evaluators.collect { |_k, v|
         v[:class].query_supported_devices.collect do |device|
           device
         end
-      end.flatten
+      }.flatten
     end
 
     def close
@@ -117,11 +115,11 @@ module TensorStream
 
     def dump_ops(tensor, selector)
       graph = tensor.graph
-      graph.nodes.select { |k, v| selector.call(k, v) }.collect do |k, node|
+      graph.nodes.select { |k, v| selector.call(k, v) }.collect { |k, node|
         next unless @last_session_context[node.name]
 
         "#{k} #{node.to_math(true, 1)} = #{@last_session_context[node.name]}"
-      end.compact
+      }.compact
     end
 
     def graph_ml(tensor, filename)
@@ -143,12 +141,12 @@ module TensorStream
     end
 
     def assign_evaluator(tensor)
-      device = @evaluator_classes.map do |klass|
+      device = @evaluator_classes.map { |klass|
         next nil if tensor.is_a?(Operation) && !klass.ops.include?(tensor.operation.to_sym)
         next klass.default_device if tensor.device.nil?
 
         klass.query_device(tensor.device)
-      end.compact.first
+      }.compact.first
 
       raise "no evaluator available to execute #{tensor.operation}" if device.nil?