tensor_stream 0.1.1 → 0.1.2

data/lib/tensor_stream/ops.rb

@@ -1,4 +1,5 @@
 module TensorStream
+  # Class that defines all available ops supported by TensorStream
   module Ops
     FLOATING_POINT_TYPES = %w[float32 float64].map(&:to_sym)
     NUMERIC_TYPES = %w[int32 int64 float32 float64].map(&:to_sym)
@@ -7,27 +8,26 @@ module TensorStream
       op(:argmax, input, nil, axis: axis, name: name, dimension: dimension, data_type: output_type)
     end
 
-    def gradients(ys, xs, grad_ys: nil,
-                          name: 'gradients',
-                          colocate_gradients_with_ops: false,
-                          gate_gradients: false,
-                          aggregation_method: nil,
-                          stop_gradients: nil
-                          )
-     
-      gs = xs.collect do |x|
-        fail "#{x} passed is not a tensor object" unless x.is_a?(Tensor)
+    def gradients(input, wrt_xs, grad_ys: nil,
+                  name: 'gradients',
+                  colocate_gradients_with_ops: false,
+                  gate_gradients: false,
+                  aggregation_method: nil,
+                  stop_gradients: nil)
+
+      gs = wrt_xs.collect do |x|
+        raise "#{x} passed is not a tensor object" unless x.is_a?(Tensor)
 
         stops = stop_gradients ? stop_gradients.map(&:name).join('_') : ''
-        gradient_program_name = "grad_#{ys.name}_#{x.name}_#{stops}".to_sym
+        gradient_program_name = "grad_#{input.name}_#{x.name}_#{stops}".to_sym
 
-        tensor_program = if ys.graph.node_added?(gradient_program_name)
-                           ys.graph.get_node(gradient_program_name)
+        tensor_program = if input.graph.node_added?(gradient_program_name)
+                           input.graph.get_node(gradient_program_name)
                          else
-                           derivative_ops = TensorStream::MathGradients.derivative(ys, x, graph: ys.graph,
-                                                  stop_gradients: stop_gradients)
+                           derivative_ops = TensorStream::MathGradients.derivative(input, x, graph: input.graph,
+                                                                                             stop_gradients: stop_gradients)
                            unit_matrix = op(:ones_like, x)
-                           ys.graph.add_node!(gradient_program_name, unit_matrix * derivative_ops)
+                           input.graph.add_node!(gradient_program_name, unit_matrix * derivative_ops)
                          end
         tensor_program
       end
@@ -35,12 +35,12 @@ module TensorStream
     end
 
     def random_uniform(shape, dtype: :float32, minval: 0, maxval: 1, seed: nil, name: nil)
-      options = {shape: shape, dtype: dtype, minval: minval, maxval: maxval, seed: seed, name: name}
+      options = { shape: shape, dtype: dtype, minval: minval, maxval: maxval, seed: seed, name: name }
       op(:random_uniform, nil, nil, options)
     end
 
     def random_normal(shape, dtype: :float32, mean: 0.0, stddev: 1.0, seed: nil, name: nil)
-      options = {shape: shape, dtype: dtype, mean: mean, stddev: stddev, seed: seed, name: name}
+      options = { shape: shape, dtype: dtype, mean: mean, stddev: stddev, seed: seed, name: name }
       op(:random_normal, nil, nil, options)
     end
 
@@ -53,7 +53,7 @@ module TensorStream
     end
 
     def shape(input, name: nil, out_type: :int32)
-      op(:shape, input, nil, name: name)
+      op(:shape, input, nil, name: name, out_type: out_type)
     end
 
     def rank(input, name: nil)
@@ -63,35 +63,35 @@ module TensorStream
     def zeros_initializer(options = {})
       op(:zeros, nil, nil, options)
     end
-  
+
     def slice(input, start, size, name: nil)
       op(:slice, input, start, size: size, name: name)
     end
-  
+
     def zeros(shape, dtype: :float32, name: nil)
       op(:zeros, shape, nil, data_type: dtype, name: name)
     end
-  
+
     def ones(shape, dtype: :float32, name: nil)
       op(:ones, shape, nil, data_type: dtype, name: name)
     end
-  
-    def less(a, b, name: nil)
-      op(:less, a, b, name: name)
+
+    def less(input_a, input_b, name: nil)
+      op(:less, input_a, input_b, name: name)
     end
-  
-    def greater(a, b, name: nil)
-      op(:greater, a, b, name: name)
+
+    def greater(input_a, input_b, name: nil)
+      op(:greater, input_a, input_b, name: name)
     end
 
-    def greater_equal(a, b, name: nil)
-      op(:greater_equal, a, b, name: name)
+    def greater_equal(input_a, input_b, name: nil)
+      op(:greater_equal, input_a, input_b, name: name)
     end
 
-    def less_equal(a, b, name: nil)
-      op(:less_equal, a, b, name: name)
+    def less_equal(input_a, input_b, name: nil)
+      op(:less_equal, input_a, input_b, name: name)
     end
-  
+
     def reduce_mean(input_tensor, axis = nil, keepdims: false, name: nil)
       op(:reduce_mean, input_tensor, nil, axis: axis, keepdims: keepdims, name: name)
     end
@@ -99,66 +99,66 @@ module TensorStream
     def reduce_sum(input_tensor, axis = nil, keepdims: false, name: nil)
       op(:reduce_sum, input_tensor, nil, axis: axis, keepdims: keepdims, name: name)
     end
-  
+
     def reduce_prod(input, axis = nil, keepdims: false, name: nil)
       op(:reduce_prod, input, nil, axis: axis, keepdims: keepdims, name: name)
     end
-  
+
     def concat(values, axis, name: 'concat')
       op(:concat, values, nil, axis: axis, name: name)
     end
-  
+
     def reshape(tensor, shape, name: nil)
       op(:reshape, tensor, shape, name: name)
     end
-  
+
     def square(tensor, name: nil)
       op(:square, tensor, nil, name: name)
     end
-  
+
     def cond(pred, true_fn, false_fn, name: nil)
       op(:cond, true_fn, false_fn, pred: pred, name: name)
     end
 
-    def where(condition, x = nil, y = nil, name: nil)
-      op(:where, x, y, pred: condition)
+    def where(condition, true_t = nil, false_t = nil, name: nil)
+      op(:where, true_t, false_t, pred: condition, name: name)
     end
-  
-    def add(a, b, name: nil)
-      op(:add, a, b, name: name)
+
+    def add(input_a, input_b, name: nil)
+      op(:add, input_a, input_b, name: name)
     end
-  
-    def sub(a, b, name: nil)
-      op(:sub, a, b, name: name)
+
+    def sub(input_a, input_b, name: nil)
+      op(:sub, input_a, input_b, name: name)
     end
 
-    def max(a, b, name: nil)
-      check_allowed_types(a, NUMERIC_TYPES)
-      check_allowed_types(b, NUMERIC_TYPES)
+    def max(input_a, input_b, name: nil)
+      check_allowed_types(input_a, NUMERIC_TYPES)
+      check_allowed_types(input_b, NUMERIC_TYPES)
 
-      op(:max, a, b, name: name)
+      op(:max, input_a, input_b, name: name)
     end
 
     def cast(input, dtype, name: nil)
       op(:cast, input, nil, data_type: dtype, name: name)
     end
-  
+
     def print(input, data, message: nil, name: nil)
       op(:print, input, data, message: message, name: name)
     end
-  
-    def negate(a, options = {})
-      op(:negate, a, nil, options)
+
+    def negate(input, options = {})
+      op(:negate, input, nil, options)
     end
-  
-    def equal(a, b, name: nil)
-      op(:equal, a, b, name: name)
+
+    def equal(input_a, input_b, name: nil)
+      op(:equal, input_a, input_b, name: name)
     end
 
-    def not_equal(a, b, name: nil)
-      op(:not_equal, a, b, name: name)
+    def not_equal(input_a, input_b, name: nil)
+      op(:not_equal, input_a, input_b, name: name)
     end
-  
+
     def zeros_like(tensor, dtype: nil, name: nil)
       op(:zeros_like, tensor, nil, data_type: dtype, name: name)
     end
@@ -166,75 +166,75 @@ module TensorStream
     def ones_like(tensor, dtype: nil, name: nil)
       op(:ones_like, tensor, nil, data_type: dtype, name: name)
     end
-  
+
     def identity(input, name: nil)
       op(:identity, input, nil, name: name)
     end
-  
-    def multiply(a, b, name: nil)
-      op(:mul, a, b, name: name)
+
+    def multiply(input_a, input_b, name: nil)
+      op(:mul, input_a, input_b, name: name)
     end
-  
-    def pow(a, e, name: nil)
-      op(:pow, a, e, name: name)
+
+    def pow(input_a, input_e, name: nil)
+      op(:pow, input_a, input_e, name: name)
     end
-  
-    def abs(x, name: nil)
-      op(:abs, x, nil, name: name)
+
+    def abs(input, name: nil)
+      op(:abs, input, nil, name: name)
     end
-  
-    def sign(x, name: nil)
-      op(:sign, x, nil, name: name)
+
+    def sign(input, name: nil)
+      op(:sign, input, nil, name: name)
     end
-  
-    def sin(a, options = {})
+
+    def sin(input, options = {})
       options[:data_type] ||= :float32
-      check_allowed_types(a, FLOATING_POINT_TYPES)
-      op(:sin, a, nil, options)
+      check_allowed_types(input, FLOATING_POINT_TYPES)
+      op(:sin, input, nil, options)
     end
-  
-    def cos(a, options = {})
+
+    def cos(input, options = {})
       options[:data_type] ||= :float32
-      check_allowed_types(a, FLOATING_POINT_TYPES)
-      op(:cos, a, nil, options)
+      check_allowed_types(input, FLOATING_POINT_TYPES)
+      op(:cos, input, nil, options)
     end
-  
-    def tan(a, options = {})
+
+    def tan(input, options = {})
       options[:data_type] ||= :float32
-      check_allowed_types(a, FLOATING_POINT_TYPES)
-      op(:tan, a, nil, options)
+      check_allowed_types(input, FLOATING_POINT_TYPES)
+      op(:tan, input, nil, options)
     end
-  
-    def tanh(a, options = {})
+
+    def tanh(input, options = {})
       options[:data_type] ||= :float32
-      check_allowed_types(a, FLOATING_POINT_TYPES)
-      op(:tanh, a, nil, options)
+      check_allowed_types(input, FLOATING_POINT_TYPES)
+      op(:tanh, input, nil, options)
     end
-  
-    def sqrt(a, name: nil)
+
+    def sqrt(input, name: nil)
       options = {
-        data_type: a.data_type,
+        data_type: input.data_type,
         name: name
       }
-      check_allowed_types(a, FLOATING_POINT_TYPES)
-      op(:sqrt, a, nil, options)
+      check_allowed_types(input, FLOATING_POINT_TYPES)
+      op(:sqrt, input, nil, options)
     end
-  
-    def log(input, options= {})
+
+    def log(input, options = {})
       options[:data_type] ||= :float32
       check_allowed_types(input, FLOATING_POINT_TYPES)
       op(:log, input, nil, options)
     end
-  
-    def exp(a, options = {})
+
+    def exp(input, options = {})
       options[:data_type] ||= :float32
-      check_allowed_types(a, FLOATING_POINT_TYPES)
-      op(:exp, a, nil, options)
+      check_allowed_types(input, FLOATING_POINT_TYPES)
+      op(:exp, input, nil, options)
     end
 
     def matmul(input_a, input_b, transpose_a: false,
-                                 transpose_b: false,
-                                 name: nil)
+               transpose_b: false,
+               name: nil)
       op(:matmul, input_a, input_b, transpose_a: transpose_a, transpose_b: transpose_b, name: name)
     end
 
@@ -246,4 +246,4 @@ module TensorStream
       op(:pad, tensor, nil, paddings: paddings, mode: mode, name: name)
     end
   end
-end
+end

data/lib/tensor_stream/placeholder.rb

@@ -1,13 +1,16 @@
 module TensorStream
+  # Class that defines a TensorStream placeholder
   class Placeholder < Tensor
     def initialize(data_type, rank, shape, options = {})
+      @graph = options[:graph] || TensorStream.get_default_graph
+
       @data_type = data_type
       @rank = rank
       @shape = TensorShape.new(shape, rank)
       @value = nil
       @is_const = false
-      @source = set_source(caller_locations)
-      @graph = options[:graph] || TensorStream.get_default_graph
+      @source = format_source(caller_locations)
+
       @name = options[:name] || build_name
       @graph.add_node(self)
     end
@@ -15,7 +18,7 @@ module TensorStream
     private
 
     def build_name
-      "Placeholder#{Tensor.placeholder_name}:#{@rank}"
+      "Placeholder#{graph.get_placeholder_counter}:#{@rank}"
     end
   end
-end
+end

data/lib/tensor_stream/session.rb

@@ -1,5 +1,7 @@
 module TensorStream
+  #  TensorStream class that defines a session
   class Session
+    attr_reader :last_session_context
     def initialize(evaluator = :ruby_evaluator, thread_pool_class: Concurrent::ImmediateExecutor)
       @evaluator_class = Object.const_get("TensorStream::Evaluator::#{camelize(evaluator.to_s)}")
       @thread_pool = thread_pool_class.new
@@ -9,25 +11,21 @@ module TensorStream
       @session ||= Session.new
     end
 
-    def last_session_context
-      @last_session_context
-    end
-
     def run(*args)
       options = if args.last.is_a?(Hash)
-        args.pop
-      else
-        {}
-      end
+                  args.pop
+                else
+                  {}
+                end
       context = {}
 
       # scan for placeholders and assign value
-      options[:feed_dict].keys.each do |k|
-        if k.is_a?(Placeholder)
-          context[k.name.to_sym] = options[:feed_dict][k]
+      if options[:feed_dict]
+        options[:feed_dict].keys.each do |k|
+          context[k.name.to_sym] = options[:feed_dict][k] if k.is_a?(Placeholder)
         end
-      end if options[:feed_dict]
-      
+      end
+
       evaluator = @evaluator_class.new(self, context.merge!(retain: options[:retain]), thread_pool: @thread_pool)
 
       execution_context = {}
@@ -37,16 +35,16 @@ module TensorStream
     end
 
     def dump_internal_ops(tensor)
-      dump_ops(tensor, ->(k, n) { n.is_a?(Tensor) && n.internal? } )
+      dump_ops(tensor, ->(_k, n) { n.is_a?(Tensor) && n.internal? })
     end
 
     def dump_user_ops(tensor)
-      dump_ops(tensor, ->(k, n) { n.is_a?(Tensor) && !n.internal? } )
+      dump_ops(tensor, ->(_k, n) { n.is_a?(Tensor) && !n.internal? })
     end
 
     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 do |k, node|
         next unless @last_session_context[node.name]
         "#{k} #{node.to_math(true, 1)} = #{@last_session_context[node.name]}"
       end.compact
@@ -55,12 +53,12 @@ module TensorStream
     private
 
     def camelize(string, uppercase_first_letter = true)
-      if uppercase_first_letter
-        string = string.sub(/^[a-z\d]*/) { $&.capitalize }
-      else
-        string = string.sub(/^(?:(?=\b|[A-Z_])|\w)/) { $&.downcase }
-      end
+      string = if uppercase_first_letter
+                 string.sub(/^[a-z\d]*/) { $&.capitalize }
+               else
+                 string.sub(/^(?:(?=\b|[A-Z_])|\w)/) { $&.downcase }
+               end
       string.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }.gsub('/', '::')
     end
   end
-end
+end

data/lib/tensor_stream/tensor.rb

@@ -1,48 +1,19 @@
 require 'ostruct'
 
 module TensorStream
+  # Base class that defines a tensor like interface
   class Tensor
     include OpHelper
 
     attr_accessor :name, :data_type, :shape, :rank, :native_buffer, :is_const, :value, :breakpoint, :internal, :source, :given_name, :graph
 
-    def self.const_name
-      @const_counter ||= 0
-
-      name = if @const_counter == 0
-        ""
-      else
-        "_#{@const_counter}"
-      end
-
-      @const_counter += 1
-      
-      name
-    end
-
-    def self.var_name
-      @var_counter ||= 0
-      @var_counter += 1
-
-      return "" if @var_counter == 1
-      return "_#{@var_counter}"
-    end
-
-    def self.placeholder_name
-      @placeholder_counter ||= 0
-      @placeholder_counter += 1
-
-      return "" if @placeholder_counter == 1
-      return "_#{@placeholder_counter}"
-    end
-
     def initialize(data_type, rank, shape, options = {})
       @data_type = data_type
       @rank = rank
       @breakpoint = false
       @shape = TensorShape.new(shape, rank)
       @value = nil
-      @source = set_source(caller_locations)
+      @source = format_source(caller_locations)
       @is_const = options[:const] || false
       @internal = options[:internal]
       @graph = options[:graph] || TensorStream.get_default_graph
@@ -50,16 +21,14 @@ module TensorStream
       @given_name = @name
 
       if options[:value]
-        if options[:value].kind_of?(Array)
+        if options[:value].is_a?(Array)
           # check if single dimenstion array is passed
-          if shape.size >= 2 && options[:value].size > 0 && !options[:value][0].kind_of?(Array)
-            options[:value] = reshape(options[:value], shape.reverse.dup)
-          end
+          options[:value] = reshape(options[:value], shape.reverse.dup) if shape.size >= 2 && !options[:value].empty? && !options[:value][0].is_a?(Array)
 
           @value = options[:value].collect do |v|
-            v.kind_of?(Tensor) ? Tensor.cast_dtype(v, data_type) : v
+            v.is_a?(Tensor) ? Tensor.cast_dtype(v, data_type) : v
           end
-        elsif shape.size > 0
+        elsif !shape.empty?
           @value = reshape(Tensor.cast_dtype(options[:value], @data_type), shape.dup)
         else
           @value = Tensor.cast_dtype(options[:value], @data_type)
@@ -83,66 +52,56 @@ module TensorStream
       @placeholder_counter = 0
     end
 
-    def build_buffer
-      @native_buffer = if @data_type == :float32 && @rank == 2
-        NArray.sfloat(@shape.cols * @shape.rows)
-      elsif @data_type == :float32 && @rank == 0
-        NArray.sfloat(1)
-      else
-        raise "Invalid data type #{@data_type}"
-      end
-    end
-
-    def +(operand)
-      TensorStream::Operation.new(:add, self, auto_wrap(operand))
+    def +(other)
+      TensorStream::Operation.new(:add, self, auto_wrap(other))
     end
 
     def [](index)
       TensorStream::Operation.new(:index, self, index)
     end
 
-    def *(operand)
-      TensorStream::Operation.new(:mul, self, auto_wrap(operand))
+    def *(other)
+      TensorStream::Operation.new(:mul, self, auto_wrap(other))
     end
 
-    def **(operand)
-      TensorStream::Operation.new(:pow, self, auto_wrap(operand))
+    def **(other)
+      TensorStream::Operation.new(:pow, self, auto_wrap(other))
     end
 
-    def /(operand)
-      TensorStream::Operation.new(:div, self, auto_wrap(operand))
+    def /(other)
+      TensorStream::Operation.new(:div, self, auto_wrap(other))
     end
 
-    def -(operand)
-      TensorStream::Operation.new(:sub, self, auto_wrap(operand))
+    def -(other)
+      TensorStream::Operation.new(:sub, self, auto_wrap(other))
     end
 
     def -@
       TensorStream::Operation.new(:negate, self, nil)
     end
 
-    def ==(operand)
-      op(:equal, self, operand)
+    def ==(other)
+      op(:equal, self, other)
     end
 
-    def <(operand)
-      op(:less, self, operand)
+    def <(other)
+      op(:less, self, other)
     end
 
-    def !=(operand)
-      op(:not_equal, self, operand)
+    def !=(other)
+      op(:not_equal, self, other)
     end
 
-    def >(operand)
-      op(:greater, self, operand)
+    def >(other)
+      op(:greater, self, other)
     end
 
-    def >=(operand)
-      op(:greater_equal, self, operand)
+    def >=(other)
+      op(:greater_equal, self, other)
     end
 
-    def <=(operand)
-      op(:less_equal, self, operand)
+    def <=(other)
+      op(:less_equal, self, other)
     end
 
     def collect(&block)
@@ -153,23 +112,6 @@ module TensorStream
       @name
     end
 
-    # def to_ary
-    #   if rank == 2
-    #     @native_buffer.to_a.each_slice(shape.cols).collect { |slice| slice }
-    #   else
-    #     raise "Invalid rank"
-    #   end
-    # end
-
-    # open cl methods
-    def open_cl_buffer(context)
-      @cl_buffer ||= context.create_buffer(@native_buffer.size * @native_buffer.element_size, :flags => OpenCL::Mem::COPY_HOST_PTR, :host_ptr => @native_buffer)
-    end
-
-    def sync_cl_buffer(queue, events = [])
-      queue.enqueue_read_buffer(@cl_buffer, @native_buffer, :event_wait_list => events)
-    end
-
     def eval(options = {})
       Session.default_session.run(self, options)
     end
@@ -201,21 +143,21 @@ module TensorStream
     end
 
     def to_math(name_only = false, max_depth = 99)
-      return @name if max_depth==0 || name_only || @value.nil?
-      
-      if @value.kind_of?(Array)
-        @value.collect { |v| v.kind_of?(Tensor) ? v.to_math(name_only, max_depth - 1) : v }
+      return @name if max_depth.zero? || name_only || @value.nil?
+
+      if @value.is_a?(Array)
+        @value.collect { |v| v.is_a?(Tensor) ? v.to_math(name_only, max_depth - 1) : v }
       else
         is_const ? @value : @name
       end
     end
 
     def auto_math(tensor, name_only = false, max_depth = 99)
-      tensor.kind_of?(Tensor) ? tensor.to_math(name_only, max_depth) : tensor
+      tensor.is_a?(Tensor) ? tensor.to_math(name_only, max_depth) : tensor
     end
 
     def self.detect_type(value)
-      dtype = if value.is_a?(String)
+      if value.is_a?(String)
         :string
       elsif value.is_a?(Float)
         :float32
@@ -257,7 +199,7 @@ module TensorStream
       when :unknown
         val
       else
-        fail "unknown data_type #{dtype} passed"
+        raise "unknown data_type #{dtype} passed"
       end
     end
 
@@ -268,15 +210,15 @@ module TensorStream
 
     protected
 
-    def set_source(trace)
-      trace.reject { |c| c.to_s.include?(File.join("lib","tensor_stream")) }.first
+    def format_source(trace)
+      trace.reject { |c| c.to_s.include?(File.join('lib', 'tensor_stream')) }.first
     end
 
     def hashify_tensor(tensor)
-      if tensor.kind_of?(Tensor) 
+      if tensor.is_a?(Tensor)
         tensor.to_h
-      elsif tensor.kind_of?(Array)
-        tensor.collect do |t| hashify_tensor(t) end
+      elsif tensor.is_a?(Array)
+        tensor.collect { |t| hashify_tensor(t) }
       else
         tensor
       end
@@ -290,11 +232,11 @@ module TensorStream
           reshape(s, shape)
         end
       else
-        return arr if shape.size < 1
+        return arr if shape.empty?
         slice = shape.shift
         return arr if slice.nil?
 
-        slice.times.collect do |s|
+        Array.new(slice) do
           reshape(arr, shape.dup)
         end
       end
@@ -311,7 +253,7 @@ module TensorStream
     end
 
     def build_name
-      "#{@is_const ? "Const#{Tensor.const_name}:#{@rank}" : "Variable#{Tensor.var_name}:#{@rank}"}"
+      @is_const ? "Const#{graph.get_const_counter}:#{@rank}" : "Variable#{graph.get_var_counter}:#{@rank}"
     end
   end
 end