tensor_stream 0.1.1 → 0.1.2

data/lib/tensor_stream/graph.rb

@@ -1,7 +1,8 @@
 module TensorStream
+  # A class that defines a TensorStream graph
   class Graph
     attr_accessor :nodes, :collections, :eager_execution
-    
+
     def initialize
       @eager_execution = false
       @nodes = {}
@@ -25,7 +26,7 @@ module TensorStream
       Thread.current[:tensor_stream_current_graph] = TensorStream::Graph.new
     end
 
-    def get_collection(name, options = {})
+    def get_collection(name, _options = {})
       @collections[name.to_sym]
     end
 
@@ -35,15 +36,10 @@ module TensorStream
     end
 
     def add_node(node)
-      fail "Placeholder cannot be used when eager_execution is enabled" if @eager_execution && node.is_a?(Placeholder)
-      if @nodes[node.name]
-        node.name = uniqunify(node.name)
-      end
-
+      raise 'Placeholder cannot be used when eager_execution is enabled' if @eager_execution && node.is_a?(Placeholder)
+      node.name = uniqunify(node.name) if @nodes[node.name]
       @nodes[node.name] = node
-      if @eager_execution
-        node.value = node.eval
-      end
+      node.value = node.eval if @eager_execution
     end
 
     def node_added?(name)
@@ -60,15 +56,15 @@ module TensorStream
     end
 
     def add_variable(node, options = {})
-      fail "duplicate variable detected #{node.name} and reuse=false in current scope" if @nodes[node.name] && !options[:reuse]
+      raise "duplicate variable detected #{node.name} and reuse=false in current scope" if @nodes[node.name] && !options[:reuse]
 
       add_to_collection(GraphKeys::GLOBAL_VARIABLES, node)
 
       add_node(node)
     end
 
-    def control_dependencies(dependencies = [], &block)
-      
+    def control_dependencies(_dependencies = [], &_block)
+      raise 'not implemented'
     end
 
     def enable_eager_execution
@@ -78,21 +74,58 @@ module TensorStream
     def disable_eager_execution
       @eager_execution = false
     end
-    
+
     def executing_eagerly?
       @eager_execution
     end
 
+    def get_operation_counter
+      @op_counter ||= 0
+
+      name = @op_counter.zero? ? '' : "_#{@op_counter}"
+
+      @op_counter += 1
+
+      name
+    end
+
+    def get_placeholder_counter
+      @placeholder_counter ||= 0
+      @placeholder_counter += 1
+
+      return '' if @placeholder_counter == 1
+      "_#{@placeholder_counter}"
+    end
+
+    def get_var_counter
+      @var_counter ||= 0
+      @var_counter += 1
+
+      return '' if @var_counter == 1
+      "_#{@var_counter}"
+    end
+
+    def get_const_counter
+      @const_counter ||= 0
+
+      name = @const_counter.zero? ? '' : "_#{@const_counter}"
+
+      @const_counter += 1
+      name
+    end
+
     protected
 
     def uniqunify(name)
       counter = 0
       new_name = name
-      begin
-        counter +=1
+      Kernel.loop do
+        counter += 1
         new_name = "#{name}_#{counter}"
-      end while @nodes[new_name]
+
+        break unless @nodes.key?(new_name)
+      end
       new_name
     end
   end
-end
+end

data/lib/tensor_stream/graph_keys.rb

@@ -1,5 +1,5 @@
 module TensorStream
   class GraphKeys
-    GLOBAL_VARIABLES = 'variables'
+    GLOBAL_VARIABLES = 'variables'.freeze
   end
-end
+end

data/lib/tensor_stream/helpers/op_helper.rb

@@ -1,12 +1,13 @@
 module TensorStream
+  # module that contains helper functions useful for ops
   module OpHelper
-    def op(code, a, b = nil, options = {})
-      Operation.new(code.to_sym, a, b, options)
+    def op(code, t_a, t_b = nil, options = {})
+      Operation.new(code.to_sym, t_a, t_b, options)
     end
 
     # same as op but with a marker that it was internal generated
-    def i_op(code, a, b = nil, options = {})
-      Operation.new(code.to_sym, a, b, options.merge(internal: true))
+    def i_op(code, t_a, t_b = nil, options = {})
+      Operation.new(code.to_sym, t_a, t_b, options.merge(internal: true))
     end
 
     def cons(value, options = {})
@@ -17,13 +18,13 @@ module TensorStream
       TensorStream.constant(value, options.merge(internal: true))
     end
 
-    def shape_eval(input)
-      return [] unless input.kind_of?(Array)
+    def shape_eval(input, output_type = :int32)
+      return [] unless input.is_a?(Array)
       arr = []
       arr_ptr = input
 
       Kernel.loop do
-        arr << arr_ptr.size
+        arr << (TensorStream::Ops::FLOATING_POINT_TYPES.include?(output_type) ? arr_ptr.size.to_f : arr_ptr.size)
         arr_ptr = arr_ptr[0]
 
         break unless arr_ptr.is_a?(Array)
@@ -32,27 +33,30 @@ module TensorStream
       arr
     end
 
-  def dtype_eval(dtype, rank, value)
-    dtype = Tensor.detect_type(value[0])
-    rank+=1 if dtype == :array
+    def dtype_eval(rank, value)
+      dtype = Tensor.detect_type(value[0])
 
-    [dtype, rank, value[0], value.size]
-  end
+      rank += 1 if dtype == :array
 
-  def val_to_dtype(value, rank = 0)
-    dtype = if value.is_a?(String)
-      :string
-    elsif value.is_a?(Float)
-      :float32
-    elsif value.is_a?(Integer)
-      :int32
-    elsif value.is_a?(Array)
-      rank += 1
-      :array
-    else
-      :float32
-    end
-    dtype
-  end
+      [dtype, rank, value[0], value.size]
+    end
+
+    def val_to_dtype(value)
+      if value.is_a?(String)
+        :string
+      elsif value.is_a?(Float)
+        :float32
+      elsif value.is_a?(Integer)
+        :int32
+      elsif value.is_a?(Array)
+        :array
+      else
+        :float32
+      end
+    end
+
+    def fp_type?(type)
+      TensorStream::Ops::FLOATING_POINT_TYPES.include?(type)
+    end
   end
 end

data/lib/tensor_stream/math_gradients.rb

@@ -3,19 +3,19 @@ module TensorStream
   class MathGradients
     extend TensorStream::OpHelper
 
-    def self.derivative(tensor, dx, options = {})
-      gradient_program_name = "_grad_#{tensor.name}_#{dx.name}"
+    def self.derivative(tensor, wrt_dx, options = {})
+      gradient_program_name = "_grad_#{tensor.name}_#{wrt_dx.name}"
       return options[:graph].get_node(gradient_program_name) if options[:graph] && options[:graph].node_added?(gradient_program_name)
 
       constant_options = { dtype: options[:dtype] }
       constant_options_1 = { dtype: options[:dtype] || tensor.data_type }
 
-      return i_op(:ones_like, dx, constant_options_1) if tensor.equal?(dx)
+      return i_op(:ones_like, wrt_dx, constant_options_1) if tensor.equal?(wrt_dx)
       return i_cons(0, constant_options) if options[:stop_gradients] && _include?(options[:stop_gradients], tensor)
 
       if tensor.is_a?(Operation)
-        grad = derivative(tensor.items[0], dx, options) if tensor.items[0]
-        grad2 = derivative(tensor.items[1], dx, options) if tensor.items[1]
+        grad = derivative(tensor.items[0], wrt_dx, options) if tensor.items[0]
+        grad2 = derivative(tensor.items[1], wrt_dx, options) if tensor.items[1]
 
         case tensor.operation
         when :max
@@ -51,11 +51,11 @@ module TensorStream
         when :cos
           -i_op(:sin, tensor.items[0]) * grad
         when :add
-          grad_with_broadcast(tensor, dx, ->(a,b) { i_op(:add, a, b, name: 'grad_sum') } , options)
+          grad_with_broadcast(tensor, wrt_dx, ->(a, b) { i_op(:add, a, b, name: 'grad_sum') }, options)
         when :sub
-          grad_with_broadcast(tensor, dx, ->(a,b) { i_op(:sub, a, b, name: 'grad_sub') } , options)
+          grad_with_broadcast(tensor, wrt_dx, ->(a, b) { i_op(:sub, a, b, name: 'grad_sub') }, options)
         when :pow
-          gx = _ds(tensor.items[1])*( _ds(tensor.items[0])**(_ds(tensor.items[1]) - 1)) * grad
+          gx = _ds(tensor.items[1]) * (_ds(tensor.items[0])**(_ds(tensor.items[1]) - 1)) * grad
 
           log_x = i_op(:where, i_op(:log, tensor.items[0], nil, name: 'log_pow_grad'), i_op(:zeros_like, tensor.items[0]), pred: tensor.items[0] > 0)
           gy = _ds(tensor.items[0])**_ds(tensor.items[1]) * log_x * grad2
@@ -74,18 +74,15 @@ module TensorStream
           input_size = i_op(:reduce_prod, i_op(:shape, tensor.items[0]))
           output_size = i_op(:reduce_prod, i_op(:shape, tensor))
           factor = input_size / output_size
- 
+
           (grad / i_op(:cast, factor, data_type: grad.dtype))
         when :reduce_sum
           grad
         when :stop_gradient
           return i_cons(0, constant_options)
         when :matmul
-          tensor_shape1 = tensor.items[1].shape ? tensor.items[1].shape.shape : nil
-          tensor_shape0 = tensor.items[0].shape ? tensor.items[0].shape.shape : nil
-
-          derivative_a = derivative(tensor.items[0], dx)
-          derivative_b = derivative(tensor.items[1], dx)
+          derivative_a = derivative(tensor.items[0], wrt_dx)
+          derivative_b = derivative(tensor.items[1], wrt_dx)
 
           s0 =  i_op(:shape, tensor.items[0])
           s1 =  i_op(:shape, tensor.items[1])
@@ -94,13 +91,13 @@ module TensorStream
           identity_1 = i_op(:ones, [s0[0], s1[1]], nil, data_type: tensor.items[1].data_type)
 
           matmul_da = i_op(:matmul, identity_0, tensor.items[1], transpose_b: true,
-                                                     pad_zeros: true,
-                                                     name:        'matrix_dx')
+                                                                 pad_zeros: true,
+                                                                 name:        'matrix_dx')
           matmul_db = i_op(:matmul, tensor.items[0], identity_1, transpose_a: true,
-                                                     pad_zeros: true,
-                                                     name:        'matrix_dy')       
+                                                                 pad_zeros: true,
+                                                                 name:        'matrix_dy')
 
-          zero_vect = i_op(:zeros_like, dx, nil, name: 'zero_vect')
+          zero_vect = i_op(:zeros_like, wrt_dx, nil, name: 'zero_vect')
 
           # matmul_db = op(:transpose, matmul_db, nil).first
 
@@ -143,9 +140,9 @@ module TensorStream
       end
     end
 
-    def self.grad_with_broadcast(tensor, dx, func, options)
-      grad = derivative(tensor.items[0], dx, options)
-      grad2 = derivative(tensor.items[1], dx, options)
+    def self.grad_with_broadcast(tensor, wrt_dx, func, options)
+      grad = derivative(tensor.items[0], wrt_dx, options)
+      grad2 = derivative(tensor.items[1], wrt_dx, options)
       elements1 = i_op(:reduce_prod, i_op(:shape, tensor.items[0]), data_type: :float32)
       elements2 = i_op(:reduce_prod, i_op(:shape, tensor.items[1]), data_type: :float32)
       multiplier = elements1 / elements2
@@ -157,4 +154,4 @@ module TensorStream
       false
     end
   end
-end
+end

data/lib/tensor_stream/nn/nn_ops.rb

@@ -1,7 +1,7 @@
 module TensorStream
   # High level machine learning functions
   class NN
-    def self.softmax(logits, options = {})
+    def self.softmax(logits, _options = {})
       TensorStream.exp(logits) / TensorStream.reduce_sum(TensorStream.exp(logits))
     end
 
@@ -14,4 +14,4 @@ module TensorStream
   def self.nn
     TensorStream::NN
   end
-end
+end

data/lib/tensor_stream/operation.rb

@@ -1,35 +1,32 @@
 module TensorStream
+  # TensorStream class that defines an operation
   class Operation < Tensor
     attr_accessor :name, :operation, :items, :rank, :options
 
-    def initialize(operation, a, b, options = {})
+    def initialize(operation, input_a, input_b, options = {})
+      @graph = options[:graph] || TensorStream.get_default_graph
+
       @operation = operation
       @rank = options[:rank] || 0
       @name = options[:name] || set_name
       @internal = options[:internal]
       @given_name = @name
-      @source = set_source(caller_locations)
+      @source = format_source(caller_locations)
 
-      @graph = options[:graph] || TensorStream.get_default_graph
       @options = options
 
-
-      @items = [a, b].map { |i| options[:preserve_params_type] ? i : auto_wrap(i) }
+      @items = [input_a, input_b].map { |i| options[:preserve_params_type] ? i : auto_wrap(i) }
       @data_type = set_data_type(options[:data_type])
 
-      if options[:shape]
-        @shape = TensorShape.new(options[:shape], options[:shape].size || 0)
-      end
+      @shape = TensorShape.new(options[:shape], options[:shape].size || 0) if options[:shape]
+
       @graph.add_node(self)
     end
+
     def to_s
       @name
     end
 
-    def self.reset_counters
-      @@op_counter = 0
-    end
-
     def to_h
       {
         op: operation,
@@ -38,18 +35,18 @@ module TensorStream
       }
     end
 
-    def self.empty_matrix?(m)
-      if m.kind_of?(Array)
-        m.each do |item|
-          if item.kind_of?(Array)
-            return false if !empty_matrix?(item)
-          else
-            return false if item!=0 || item!=0.0
+    def self.empty_matrix?(input)
+      if input.is_a?(Array)
+        input.each do |item|
+          if item.is_a?(Array)
+            return false unless empty_matrix?(item)
+          elsif item != 0 || item != 0.0
+            return false
           end
         end
       end
 
-      return true
+      true
     end
 
     def set_data_type(passed_data_type)
@@ -64,7 +61,7 @@ module TensorStream
     end
 
     def to_math(name_only = false, max_depth = 99)
-      return @name if max_depth == 0
+      return @name if max_depth.zero?
 
       sub_item = auto_math(items[0], name_only, max_depth - 1)
 
@@ -78,15 +75,15 @@ module TensorStream
       when :slice
         "#{sub_item}[#{auto_math(items[1], name_only, max_depth - 1)}]"
       when :assign_sub
-        "(#{items[0] ? items[0].name : "self"} -= #{auto_math(items[1], name_only)})"
+        "(#{items[0] ? items[0].name : 'self'} -= #{auto_math(items[1], name_only)})"
       when :assign_add
-        "(#{items[0] ? items[0].name : "self"} += #{auto_math(items[1], name_only)})"
+        "(#{items[0] ? items[0].name : 'self'} += #{auto_math(items[1], name_only)})"
       when :assign
-        "(#{items[0] ? items[0].name : "self"} = #{auto_math(items[1], name_only)})"
+        "(#{items[0] ? items[0].name : 'self'} = #{auto_math(items[1], name_only)})"
       when :sin, :cos, :tanh
         "#{operation}(#{sub_item})"
       when :add
-       "(#{sub_item} + #{auto_math(items[1], name_only, max_depth - 1)})"
+        "(#{sub_item} + #{auto_math(items[1], name_only, max_depth - 1)})"
       when :sub
         "(#{sub_item} - #{auto_math(items[1], name_only, max_depth - 1)})"
       when :pow
@@ -126,7 +123,7 @@ module TensorStream
       when :ones_like
         "ones_like(#{sub_item})"
       when :flow_group
-        "flow_group(#{items.collect { |i| auto_math(i)}.join(',')})"
+        "flow_group(#{items.collect { |i| auto_math(i) }.join(',')})"
       when :zeros
         "zeros(#{sub_item})"
       when :reshape
@@ -158,38 +155,24 @@ module TensorStream
       when :zeros_like
         "zeros_like(#{sub_item})"
       when :where
-        "where(#{auto_math(options[:pred] , name_only, max_depth - 1)},#{auto_math(items[0])},#{auto_math(items[1])})"
+        "where(#{auto_math(options[:pred], name_only, max_depth - 1)},#{auto_math(items[0])},#{auto_math(items[1])})"
       when :max
         "max(#{auto_math(sub_item)},#{auto_math(items[1])})"
       when :cast
         "cast(#{auto_math(sub_item)}, #{data_type})"
       else
-        fail "math form for #{operation}"
+        raise "math form for #{operation}"
       end
     end
 
     def run
-      self.eval
+      eval
     end
 
     private
 
-    def self.operation_counter
-      @@op_counter ||= 0
-
-      name = if @@op_counter == 0
-        ""
-      else
-        "_#{@@op_counter}"
-      end
-
-      @@op_counter += 1
-      
-      name
-    end
-
     def set_name
-      "#{@operation}#{Operation.operation_counter}:#{@rank}"
+      "#{@operation}#{graph.get_operation_counter}:#{@rank}"
     end
   end
-end
+end