tensor_stream 0.1.4 → 0.1.5

data/lib/tensor_stream/placeholder.rb

@@ -11,7 +11,7 @@ module TensorStream
       @is_const = false
       @source = format_source(caller_locations)
 
-      @name = options[:name] || build_name
+      @name = [@graph.get_name_scope, options[:name] || build_name].compact.join('/')
       @graph.add_node(self)
     end
 

data/lib/tensor_stream/session.rb

@@ -1,10 +1,14 @@
 module TensorStream
   #  TensorStream class that defines a session
   class Session
-    attr_reader :last_session_context
+    attr_reader :last_session_context, :closed, :target
+    attr_accessor :randomizer
+  
     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
+      @closed = false
+      @randomizer = {}
     end
 
     def self.default_session
@@ -22,18 +26,32 @@ module TensorStream
       # scan for placeholders and assign value
       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)
+          if k.is_a?(Placeholder)
+            context[k.name.to_sym] = options[:feed_dict][k]
+          end
         end
       end
 
-      evaluator = @evaluator_class.new(self, context.merge!(retain: options[:retain]), thread_pool: @thread_pool)
+      evaluator = @evaluator_class.new(self, context.merge!(retain: options[:retain]), thread_pool: @thread_pool, log_intermediates: options[:log_intermediates])
 
       execution_context = {}
-      result = args.collect { |e| evaluator.run(e, execution_context) }
       @last_session_context = context
+      result = args.collect { |e| evaluator.run(e, execution_context) }
       result.size == 1 ? result.first : result
     end
 
+    def list_devices
+      [Device.new("cpu")]
+    end
+
+    def close
+      @closed = true
+    end
+
+    def closed?
+      @closed
+    end
+
     def dump_internal_ops(tensor)
       dump_ops(tensor, ->(_k, n) { n.is_a?(Tensor) && n.internal? })
     end
@@ -50,6 +68,10 @@ module TensorStream
       end.compact
     end
 
+    def graph_ml(tensor, filename)
+      TensorStream::Graphml.new(self).serialize(tensor, filename)
+    end
+
     private
 
     def camelize(string, uppercase_first_letter = true)

data/lib/tensor_stream/tensor.rb

@@ -19,7 +19,7 @@ module TensorStream
       @is_const = options[:const] || false
       @internal = options[:internal]
       @graph = options[:graph] || TensorStream.get_default_graph
-      @name = options[:name] || build_name
+      @name = [@graph.get_name_scope, options[:name] || build_name].compact.reject(&:empty?).join('/')
       @given_name = @name
 
       if options[:value]
@@ -55,7 +55,7 @@ module TensorStream
     end
 
     def +(other)
-      TensorStream::Operation.new(:add, self, auto_wrap(other))
+      TensorStream::Operation.new(:add, self, TensorStream.convert_to_tensor(other, dtype: data_type))
     end
 
     def [](index)
@@ -63,19 +63,19 @@ module TensorStream
     end
 
     def *(other)
-      TensorStream::Operation.new(:mul, self, auto_wrap(other))
+      TensorStream::Operation.new(:mul, self, TensorStream.convert_to_tensor(other, dtype: data_type))
     end
 
     def **(other)
-      TensorStream::Operation.new(:pow, self, auto_wrap(other))
+      TensorStream::Operation.new(:pow, self, TensorStream.convert_to_tensor(other, dtype: data_type))
     end
 
     def /(other)
-      TensorStream::Operation.new(:div, self, auto_wrap(other))
+      TensorStream::Operation.new(:div, self, TensorStream.convert_to_tensor(other, dtype: data_type))
     end
 
     def -(other)
-      TensorStream::Operation.new(:sub, self, auto_wrap(other))
+      TensorStream::Operation.new(:sub, self, TensorStream.convert_to_tensor(other, dtype: data_type))
     end
 
     def -@
@@ -83,35 +83,40 @@ module TensorStream
     end
 
     def ==(other)
-      op(:equal, self, other)
+      _op(:equal, self, other)
     end
 
     def <(other)
-      op(:less, self, other)
+      _op(:less, self, other)
     end
 
     def !=(other)
-      op(:not_equal, self, other)
+      _op(:not_equal, self, other)
     end
 
     def >(other)
-      op(:greater, self, other)
+      _op(:greater, self, other)
     end
 
     def >=(other)
-      op(:greater_equal, self, other)
+      _op(:greater_equal, self, other)
     end
 
     def <=(other)
-      op(:less_equal, self, other)
+      _op(:less_equal, self, other)
     end
 
     def and(other)
-      op(:logical_and, self, other)
+      _op(:logical_and, self, other)
     end
 
     def matmul(other)
-      op(:matmul, self, other)
+      _op(:matmul, self, other)
+    end
+    
+
+    def dot(other)
+      _op(:matmul, self, other)
     end
 
     def collect(&block)
@@ -122,6 +127,10 @@ module TensorStream
       @name
     end
 
+    def op
+      is_const ? _op(:const, self, nil, name: self.name) : _op(:variable, self, nil, name: self.name)
+    end
+
     def eval(options = {})
       Session.default_session.run(self, options)
     end
@@ -149,10 +158,10 @@ module TensorStream
     end
 
     def first
-      op(:index, self, 0)
+      _op(:index, self, 0)
     end
 
-    def to_math(name_only = false, max_depth = 99)
+    def to_math(name_only = false, max_depth = 99, _unused = 0)
       return @name if max_depth.zero? || name_only || @value.nil?
 
       if @value.is_a?(Array)
@@ -162,8 +171,8 @@ module TensorStream
       end
     end
 
-    def auto_math(tensor, name_only = false, max_depth = 99)
-      tensor.is_a?(Tensor) ? tensor.to_math(name_only, max_depth) : tensor
+    def auto_math(tensor, name_only = false, max_depth = 99, _cur_depth = 0)
+      tensor.is_a?(Tensor) ? tensor.to_math(name_only, max_depth, _cur_depth) : tensor
     end
 
     def self.detect_type(value)
@@ -181,6 +190,7 @@ module TensorStream
     end
 
     def self.cast_dtype(val, dtype)
+      return val if dtype.nil?
       return val if val.is_a?(Tensor)
 
       if val.is_a?(Array)
@@ -218,7 +228,7 @@ module TensorStream
     end
 
     def print!(message)
-      op(:print, self, self, message: message)
+      _op(:print, self, self, message: message)
     end
 
     protected
@@ -232,10 +242,6 @@ module TensorStream
       add_consumer(consumer)
     end
 
-    def format_source(trace)
-      trace.reject { |c| c.to_s.include?(File.join('lib', 'tensor_stream')) }.first
-    end
-
     def hashify_tensor(tensor)
       if tensor.is_a?(Tensor)
         tensor.to_h
@@ -264,16 +270,6 @@ module TensorStream
       end
     end
 
-    def auto_wrap(operand)
-      return auto_wrap(operand.call) if operand.is_a?(Proc)
-
-      if !operand.is_a?(Tensor)
-        i_cons(operand, dtype: @data_type || Tensor.detect_type(operand))
-      else
-        operand
-      end
-    end
-
     def build_name
       @is_const ? "Const#{graph.get_const_counter}:#{@rank}" : "Variable#{graph.get_var_counter}:#{@rank}"
     end

data/lib/tensor_stream/tensor_shape.rb

@@ -3,9 +3,9 @@ module TensorStream
   class TensorShape
     attr_accessor :rank, :shape
 
-    def initialize(shape, rank)
+    def initialize(shape, rank = nil)
       @shape = shape
-      @rank = rank
+      @rank = rank.nil? && shape ? shape.size : rank
     end
 
     def to_s
@@ -22,5 +22,55 @@ module TensorStream
     def ndims
       shape.size
     end
+
+    def known?
+      return false if shape.nil?
+      shape.each { |s| return false if s.nil? }
+
+      true
+    end
+
+    def self.infer_shape(shape_a, shape_b)
+      return shape_a if shape_b.nil?
+      return shape_b if shape_a.nil?
+      return shape_a if shape_a == shape_b
+      return shape_b if shape_b.size > shape_a.size
+      return shape_a if shape_a.size > shape_b.size
+
+      reversed_a = shape_a.reverse
+      reversed_b = shape_b.reverse
+
+      reversed_a.each_with_index.collect do |s, index|
+        next s if index >= reversed_b.size
+        next nil if s.nil? || reversed_b[index].nil?
+        next nil if s.is_a?(Tensor) || reversed_b[index].is_a?(Tensor)
+        next reversed_b[index] if reversed_b[index] > s
+        s
+      end.reverse
+    end
+
+    def self.reshape(arr, new_shape)
+      return arr if new_shape.empty?
+
+      s = new_shape.shift
+
+      if new_shape.size.zero?
+        raise "reshape dimen mismatch #{arr.size} != #{s}" if arr.size != s
+        return arr
+      end
+
+      dim = (arr.size / s)
+      arr.each_slice(dim).collect do |slice|
+        reshape(slice, new_shape.dup)
+      end
+    end
+
+    def self.fix_inferred_elements(shape, total_size)
+      return shape if shape.empty?
+
+      current_size = shape.inject(1) { |product, n| n > 0 ? product * n : product }
+      inferred_size = total_size / current_size
+      shape.map { |s| s == -1 ? inferred_size : s }
+    end
   end
 end

data/lib/tensor_stream/train/gradient_descent_optimizer.rb

@@ -9,10 +9,7 @@ module TensorStream
       end
 
       def minimize(cost)
-        trainable_vars = TensorStream::Graph.get_default_graph
-                                            .get_collection(GraphKeys::GLOBAL_VARIABLES)
-                                            .select(&:trainable)
-
+        trainable_vars = TensorStream.trainable_variables
         derivatives = TensorStream.gradients(cost, trainable_vars)
         trainable_vars.each_with_index.collect do |var, index|
           var.assign_sub(derivatives[index] * @learning_rate)

data/lib/tensor_stream/variable.rb

@@ -7,19 +7,27 @@ module TensorStream
 
       @data_type = data_type
       @rank = rank
-      @shape = TensorShape.new(shape, rank)
       @value = nil
       @source = format_source(caller_locations)
-
-      @name = options[:name] || build_name
-      @initalizer_tensor = options[:initializer] if options[:initializer]
+      @name = [TensorStream.get_variable_scope, options[:name] || build_name].compact.reject(&:empty?).join('/')
+      @initalizer_tensor = options[:initializer] ? options[:initializer] : _variable_scope.initializer || TensorStream.glorot_uniform_initializer
+      if shape.nil? && @initalizer_tensor && @initalizer_tensor.shape
+        shape = @initalizer_tensor.shape.shape
+      end
+      @shape = TensorShape.new(shape, rank)
       @trainable = options.fetch(:trainable, true)
       @graph.add_variable(self, options)
     end
 
+    def trainable?
+      @trainable
+    end
+
     def initializer
-      @initalizer_tensor.shape = @shape
-      assign(@initalizer_tensor)
+      init_op = @initalizer_tensor.op
+      init_op.shape = @shape || init_op.shape
+      init_op.data_type = @data_type || init_op.data_type
+      assign(init_op)
     end
 
     def assign(value)
@@ -34,7 +42,7 @@ module TensorStream
       Operation.new(:assign_add, self, value)
     end
 
-    def to_math(_tensor, _name_only = false, _max_depth = 99)
+    def to_math(_tensor, _name_only = false, _max_depth = 99, _unused = 0)
       @name
     end
 
@@ -49,5 +57,13 @@ module TensorStream
     def self.global_variables_initializer
       variables_initializer(TensorStream::GraphKeys::GLOBAL_VARIABLES)
     end
+
+    private
+
+    def _variable_scope
+      return OpenStruct.new(name: '', reuse: false, initializer: nil) if Thread.current[:tensor_stream_variable_scope].nil? || Thread.current[:tensor_stream_variable_scope].empty?
+      scope = Thread.current[:tensor_stream_variable_scope].last
+      scope
+    end
   end
 end

data/lib/tensor_stream/version.rb

@@ -1,5 +1,5 @@
 module TensorStream
-  VERSION = '0.1.4'.freeze
+  VERSION = '0.1.5'.freeze
 
   def self.version
     VERSION

data/samples/logistic_regression.rb

@@ -0,0 +1,76 @@
+require "bundler/setup"
+require 'tensor_stream'
+require 'pry-byebug'
+
+tf = TensorStream
+
+rows = File.readlines(File.join("samples","iris.data")).map {|l| l.chomp.split(',') }
+
+iris = rows[0...100].shuffle!
+
+transformed_data = iris.collect do |row|
+  row[0, 4].map(&:to_f)
+end
+
+columns = (0..3).map do |i|
+  transformed_data.map { |row| row[i] }
+end
+
+# Normalize data values before feeding into network
+normalize = -> (val, high, low) { (val - low) / (high - low) } # maps input to float between 0 and 1
+
+transformed_data.map! do |row|
+  row.map.with_index do |val, j|
+    max, min = columns[j].max, columns[j].min
+    normalize.(val, max, min)
+  end
+end
+
+
+srand(5)
+seed = 5
+tf.set_random_seed(seed)
+
+train_x = transformed_data[0..50].map  { |x| x[0..3].map(&:to_f) }
+train_y = iris[0..50].map  { |x| x[4] == 'Iris-setosa' ? 0.0 : 1.0 }
+
+test_x = transformed_data[51..100].map { |x| x[0..3].map(&:to_f) }
+test_y = iris[51..100].map { |x| x[4] == 'Iris-setosa' ? 0.0 : 1.0 }
+
+
+A = tf.variable(tf.random_normal([4, 1]))
+b = tf.variable(tf.random_normal([1, 1]))
+
+init = tf.global_variables_initializer
+sess = tf.session
+sess.run(init)
+
+data = tf.placeholder(:float32, shape: [nil, 4])
+target = tf.placeholder(:float32, shape: [nil, 1])
+
+mod = data.dot(A) + b
+
+loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits: mod, labels: target))
+
+learning_rate = 0.003
+batch_size = 30
+iter_num = 1500
+
+optimizer = TensorStream::Train::GradientDescentOptimizer.new(learning_rate)
+goal = optimizer.minimize(loss)
+prediction = tf.round(tf.sigmoid(mod))
+# Bool into float32 type
+correct = tf.cast(tf.equal(prediction, target), dtype: :float32)
+# Average
+accuracy = tf.reduce_mean(correct)
+
+loss_trace = []
+train_acc = []
+test_acc = []
+
+(0..iter_num).each do |epoch|
+  batch_train_X = train_x
+  batch_train_y = [train_y].transpose
+  sess.run(goal, feed_dict: { data => batch_train_X, target => batch_train_y })
+  temp_loss = sess.run(loss, feed_dict: {data => batch_train_X, target => batch_train_y})
+end