tensor_stream 0.4.1 → 0.5.0

data/lib/tensor_stream/session.rb

@@ -6,13 +6,29 @@ module TensorStream
     attr_reader :last_session_context, :closed, :target, :session_cache
     attr_accessor :randomizer
 
-    def initialize(evaluator = :ruby_evaluator, thread_pool_class: Concurrent::ImmediateExecutor, evaluator_options: {})
-      @evaluator_class = Object.const_get("TensorStream::Evaluator::#{camelize(evaluator.to_s)}")
+    def initialize(evaluator = nil, thread_pool_class: Concurrent::ImmediateExecutor, log_device_placement: false, evaluator_options: {})
       @thread_pool = thread_pool_class.new
       @closed = false
       @session_cache = {}
       @randomizer = {}
+      @log_device_placement = log_device_placement
       @evaluator_options = evaluator_options
+      get_evaluator_classes(evaluator)
+      @evaluators = {}
+    end
+
+    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
     end
 
     def clear_session_cache
@@ -44,16 +60,31 @@ module TensorStream
 
       @evaluator_options[:thread_pool] = @thread_pool
       @evaluator_options[:log_intermediates] = options[:log_intermediates]
-      evaluator = @evaluator_class.new(self, context.merge!(retain: options[:retain]), @evaluator_options)
 
-      execution_context = {}
+      args.each { |t| prepare_evaluators(t, context) }
       @last_session_context = context
-      result = args.collect { |e| evaluator.run(e, execution_context) }
+
+      if @log_device_placement
+        context[:_cache][:placement].each do |k, v|
+          puts "#{k} : #{v[0].name}"
+        end
+      end
+      result = args.collect do |e|
+        value = delegate_to_evaluator(e, context, {})
+        value.respond_to?(:to_ruby) ? value.to_ruby : value
+      end
+
+ 
+
       result.size == 1 ? result.first : result
     end
 
     def list_devices
-      [Device.new("cpu")]
+      TensorStream::Evaluator.evaluators.collect do |k, v|
+        v[:class].query_supported_devices.collect do |device|
+          device
+        end
+      end.flatten
     end
 
     def close
@@ -74,14 +105,56 @@ 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)
       TensorStream::Graphml.new(self).serialize(tensor, filename)
     end
+
+    def delegate_to_evaluator(tensor_arr, session_context, context)
+      arr = tensor_arr.is_a?(Array) ? tensor_arr : [tensor_arr]
+      result = arr.collect do |tensor|
+        session_context[:_cache][:placement][tensor.name][1].run_with_buffer(tensor, session_context, context)
+      end
+      result.size == 1 ? result.first : result
+    end
+
+    protected
+
+    def assign_evaluator(tensor)
+      device = @evaluator_classes.map do |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
+
+      raise "no evaluator available to execute #{tensor.operation}" if device.nil?
+
+      key = "#{device.evaluator.to_s}/#{device.name}"
+      if @evaluators.key?(key)
+        @evaluators[key]
+      else
+        @evaluators[key] = [device, device.evaluator.new(self, device)]
+      end
+    end
+
+    def prepare_evaluators(tensor_arr, context)
+      context[:_cache][:placement] ||= {}
+
+      tensor_arr = tensor_arr.is_a?(Array) ? tensor_arr : [tensor_arr]
+      tensor_arr.each do |tensor|
+        next if context[:_cache][:placement][tensor.name]
+
+        graph = tensor.graph
+        graph.nodes.values.each do |node|
+          context[:_cache][:placement][node.name] = assign_evaluator(node)
+        end
+      end
+    end
   end
 end

data/lib/tensor_stream/tensor.rb

@@ -7,7 +7,7 @@ module TensorStream
 
     attr_accessor :name, :data_type, :shape, :rank, :native_buffer, :is_const,
                   :value, :breakpoint, :internal, :source, :given_name, :graph,
-                  :consumers, :outputs
+                  :consumers, :outputs, :device
 
     def initialize(data_type, rank, shape, options = {})
       setup_initial_state(options)
@@ -28,7 +28,7 @@ module TensorStream
           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.is_a?(Tensor) ? Tensor.cast_dtype(v, data_type) : v
+            v.is_a?(Tensor) ? Tensor.cast_dtype(v, @data_type) : v
           end
         elsif !shape.empty?
           @value = reshape(Tensor.cast_dtype(options[:value], @data_type), shape.dup)
@@ -189,14 +189,16 @@ module TensorStream
     end
 
     def self.detect_type(value)
-      if value.is_a?(String)
+      if !!value==value
+        :boolean
+      elsif value.is_a?(String)
         :string
       elsif value.is_a?(Float)
         :float32
       elsif value.is_a?(Integer)
         :int32
       elsif value.is_a?(Array)
-        :array
+        return detect_type(value[0])
       else
         :float32
       end
@@ -225,7 +227,7 @@ module TensorStream
         end
       when :string
         val.to_s
-      when :int32, :int16
+      when :int32, :int16, :int
         if !!val == val
           val ? 1 : 0
         else

data/lib/tensor_stream/utils.rb

@@ -28,6 +28,19 @@ module TensorStream
       TensorStream::Graph.get_default_graph.executing_eagerly?
     end
 
+    ##
+    # List available evaluators + devices in the current local environment
+    # Returns:
+    # - An array containing the names of those devices
+    def list_local_devices
+      local_name = 'job:localhost'
+      TensorStream::Evaluator.evaluators.collect do |k, v|
+        v[:class].query_supported_devices.collect do |device_str|
+          [local_name, "ts:#{k}:#{device_str.name}"].join('/')
+        end
+      end.flatten
+    end
+
     def variable(value, name: nil, initializer: nil, graph: nil, dtype: nil, trainable: true)
       op = Operation.new(:assign, nil, value)
       common_options = {
@@ -46,7 +59,7 @@ module TensorStream
       else
         TensorStream::Variable.new(dtype || :float32, 0, nil, common_options)
       end
-      op.items[0] = tensor
+      op.inputs[0] = tensor
       tensor
     end
 
@@ -65,6 +78,10 @@ module TensorStream
       end
     end
 
+    def device(device_uri, &block)
+      get_default_graph.device(device_uri, &block)
+    end
+
     def name_scope(name, default: nil, values: nil)
       if values
         graph_count = values.select { |v| v.is_a?(Tensor) }.map(&:graph).map(&:object_id).uniq.size
@@ -85,8 +102,8 @@ module TensorStream
       Thread.current[:tensor_stream_variable_scope].map(&:name).compact.reject(&:empty?).join('/')
     end
 
-    def session(evaluator = :ruby_evaluator, thread_pool_class: Concurrent::ImmediateExecutor)
-      session = TensorStream::Session.new(evaluator, thread_pool_class: thread_pool_class)
+    def session(evaluator = nil, thread_pool_class: Concurrent::ImmediateExecutor, log_device_placement: false)
+      session = TensorStream::Session.new(evaluator, thread_pool_class: thread_pool_class, log_device_placement: log_device_placement)
       yield session if block_given?
 
       session
@@ -100,27 +117,23 @@ module TensorStream
       TensorStream::Layers
     end
 
-    def constant(value, options = {})
-      shared_options = { const: true, value: value, name: options[:name] }
+    def constant(value, dtype: nil, shape: nil, internal: false, name: 'Const')
+      shared_options = { const: true, value: value, name: name, internal: internal }
       if value.is_a?(Float)
-        TensorStream::Tensor.new(options[:dtype] || :float32, 0, options[:shape] || [], shared_options)
+        TensorStream::Tensor.new(dtype || :float32, 0, shape || [], shared_options)
       elsif value.is_a?(Integer)
-        TensorStream::Tensor.new(options[:dtype] || :int32, 0, options[:shape] || [], shared_options)
+        TensorStream::Tensor.new(dtype || :int32, 0, shape || [], shared_options)
       elsif value.is_a?(String)
-        TensorStream::Tensor.new(options[:dtype] || :string, 0, options[:shape] || [], shared_options)
+        TensorStream::Tensor.new(dtype || :string, 0, shape || [], shared_options)
       elsif value.is_a?(Array)
-        dtype = nil
-        rank = 1
-        dimensions = []
-        value_ptr = value
-
-        Kernel.loop do
-          dtype, rank, value_ptr, d = dtype_eval(rank, value_ptr)
-          dimensions << d
-          break if dtype != :array
-        end
+        dimension = shape || shape_eval(value)
+        rank = dimension.size
+
+        cur_dtype = dtype || Tensor.detect_type(value.flatten.last)
+        value = Tensor.cast_dtype(value, cur_dtype) unless dtype.nil?
 
-        TensorStream::Tensor.new(dtype, rank, options[:shape] || dimensions, shared_options)
+        shared_options[:value] = value
+        TensorStream::Tensor.new(cur_dtype, rank, dimension, shared_options)
       end
     end
 

data/lib/tensor_stream/version.rb

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

data/tensor_stream.gemspec

@@ -44,5 +44,4 @@ Gem::Specification.new do |spec|
   spec.add_dependency "deep_merge"
   spec.add_dependency "concurrent-ruby"
   spec.add_dependency "sciruby"
-  spec.add_dependency "distribution"
 end

data/test_samples/raw_neural_net_sample.rb

@@ -38,15 +38,15 @@ Y = tf.placeholder(:float64, shape: [nil, num_classes])
 
 # Store layers weight & bias
 weights = {
-    'h1' => tf.variable(tf.random_normal([num_input, n_hidden_1]), dtype: :float64),
-    'h2' => tf.variable(tf.random_normal([n_hidden_1, n_hidden_2]), dtype: :float64),
-    'out' => tf.variable(tf.random_normal([n_hidden_2, num_classes]), dtype: :float64)
+    'h1' => tf.variable(tf.random_normal([num_input, n_hidden_1]), dtype: :float64, name: 'h1'),
+    'h2' => tf.variable(tf.random_normal([n_hidden_1, n_hidden_2]), dtype: :float64, name: 'h2'),
+    'out' => tf.variable(tf.random_normal([n_hidden_2, num_classes]), dtype: :float64, name: 'out')
 }
 
 biases = {
-    'b1' => tf.variable(tf.random_normal([n_hidden_1]), dtype: :float64),
-    'b2' => tf.variable(tf.random_normal([n_hidden_2]), dtype: :float64),
-    'out' => tf.variable(tf.random_normal([num_classes]), dtype: :float64)
+    'b1' => tf.variable(tf.random_normal([n_hidden_1]), dtype: :float64, name: 'b1'),
+    'b2' => tf.variable(tf.random_normal([n_hidden_2]), dtype: :float64, name: 'b2'),
+    'out' => tf.variable(tf.random_normal([num_classes]), dtype: :float64, name: 'out2')
 }
 
 
@@ -82,7 +82,7 @@ accuracy = tf.reduce_mean(tf.cast(correct_pred, :float32))
 init = tf.global_variables_initializer
 
 # Start training
-tf.session(:opencl_evaluator) do |sess|
+tf.session do |sess|
     # Run the initializer
     sess.run(init)
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tensor_stream
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Joseph Emmanuel Dayo
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-06-17 00:00:00.000000000 Z
+date: 2018-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -206,20 +206,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: distribution
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: A reimplementation of TensorFlow for ruby. This is a ground up implementation
   with no dependency on TensorFlow. Effort has been made to make the programming style
   as near to TensorFlow as possible, comes with a pure ruby evaluator by default as
@@ -252,44 +238,46 @@ files:
 - lib/tensor_stream/control_flow.rb
 - lib/tensor_stream/debugging/debugging.rb
 - lib/tensor_stream/device.rb
+- lib/tensor_stream/evaluator/base_evaluator.rb
 - lib/tensor_stream/evaluator/buffer.rb
 - lib/tensor_stream/evaluator/evaluator.rb
-- lib/tensor_stream/evaluator/kernels/_bool_operand.cl
-- lib/tensor_stream/evaluator/kernels/_operand.cl
-- lib/tensor_stream/evaluator/kernels/abs.cl
-- lib/tensor_stream/evaluator/kernels/add.cl
-- lib/tensor_stream/evaluator/kernels/argmax.cl
-- lib/tensor_stream/evaluator/kernels/argmin.cl
-- lib/tensor_stream/evaluator/kernels/cast.cl
-- lib/tensor_stream/evaluator/kernels/cond.cl.erb
-- lib/tensor_stream/evaluator/kernels/cos.cl
-- lib/tensor_stream/evaluator/kernels/div.cl.erb
-- lib/tensor_stream/evaluator/kernels/exp.cl
-- lib/tensor_stream/evaluator/kernels/gemm.cl
-- lib/tensor_stream/evaluator/kernels/log.cl
-- lib/tensor_stream/evaluator/kernels/log1p.cl
-- lib/tensor_stream/evaluator/kernels/max.cl
-- lib/tensor_stream/evaluator/kernels/mul.cl
-- lib/tensor_stream/evaluator/kernels/negate.cl
-- lib/tensor_stream/evaluator/kernels/pow.cl
-- lib/tensor_stream/evaluator/kernels/reciprocal.cl
-- lib/tensor_stream/evaluator/kernels/round.cl
-- lib/tensor_stream/evaluator/kernels/sigmoid.cl
-- lib/tensor_stream/evaluator/kernels/sigmoid_grad.cl
-- lib/tensor_stream/evaluator/kernels/sign.cl
-- lib/tensor_stream/evaluator/kernels/sin.cl
-- lib/tensor_stream/evaluator/kernels/softmax.cl
-- lib/tensor_stream/evaluator/kernels/softmax_grad.cl
-- lib/tensor_stream/evaluator/kernels/sqrt.cl
-- lib/tensor_stream/evaluator/kernels/square.cl
-- lib/tensor_stream/evaluator/kernels/sub.cl
-- lib/tensor_stream/evaluator/kernels/tan.cl
-- lib/tensor_stream/evaluator/kernels/tanh.cl
-- lib/tensor_stream/evaluator/kernels/tanh_grad.cl
-- lib/tensor_stream/evaluator/kernels/where.cl
-- lib/tensor_stream/evaluator/opencl_buffer.rb
-- lib/tensor_stream/evaluator/opencl_evaluator.rb
-- lib/tensor_stream/evaluator/opencl_template_helper.rb
+- lib/tensor_stream/evaluator/opencl/kernels/_bool_operand.cl
+- lib/tensor_stream/evaluator/opencl/kernels/_operand.cl
+- lib/tensor_stream/evaluator/opencl/kernels/abs.cl
+- lib/tensor_stream/evaluator/opencl/kernels/add.cl
+- lib/tensor_stream/evaluator/opencl/kernels/argmax.cl
+- lib/tensor_stream/evaluator/opencl/kernels/argmin.cl
+- lib/tensor_stream/evaluator/opencl/kernels/cast.cl
+- lib/tensor_stream/evaluator/opencl/kernels/cond.cl.erb
+- lib/tensor_stream/evaluator/opencl/kernels/cos.cl
+- lib/tensor_stream/evaluator/opencl/kernels/div.cl.erb
+- lib/tensor_stream/evaluator/opencl/kernels/exp.cl
+- lib/tensor_stream/evaluator/opencl/kernels/gemm.cl
+- lib/tensor_stream/evaluator/opencl/kernels/log.cl
+- lib/tensor_stream/evaluator/opencl/kernels/log1p.cl
+- lib/tensor_stream/evaluator/opencl/kernels/max.cl
+- lib/tensor_stream/evaluator/opencl/kernels/mul.cl
+- lib/tensor_stream/evaluator/opencl/kernels/negate.cl
+- lib/tensor_stream/evaluator/opencl/kernels/pow.cl
+- lib/tensor_stream/evaluator/opencl/kernels/reciprocal.cl
+- lib/tensor_stream/evaluator/opencl/kernels/round.cl
+- lib/tensor_stream/evaluator/opencl/kernels/sigmoid.cl
+- lib/tensor_stream/evaluator/opencl/kernels/sigmoid_grad.cl
+- lib/tensor_stream/evaluator/opencl/kernels/sign.cl
+- lib/tensor_stream/evaluator/opencl/kernels/sin.cl
+- lib/tensor_stream/evaluator/opencl/kernels/softmax.cl
+- lib/tensor_stream/evaluator/opencl/kernels/softmax_grad.cl
+- lib/tensor_stream/evaluator/opencl/kernels/sqrt.cl
+- lib/tensor_stream/evaluator/opencl/kernels/square.cl
+- lib/tensor_stream/evaluator/opencl/kernels/sub.cl
+- lib/tensor_stream/evaluator/opencl/kernels/tan.cl
+- lib/tensor_stream/evaluator/opencl/kernels/tanh.cl
+- lib/tensor_stream/evaluator/opencl/kernels/tanh_grad.cl
+- lib/tensor_stream/evaluator/opencl/kernels/where.cl
+- lib/tensor_stream/evaluator/opencl/opencl_buffer.rb
+- lib/tensor_stream/evaluator/opencl/opencl_device.rb
+- lib/tensor_stream/evaluator/opencl/opencl_evaluator.rb
+- lib/tensor_stream/evaluator/opencl/opencl_template_helper.rb
 - lib/tensor_stream/evaluator/operation_helpers/array_ops_helper.rb
 - lib/tensor_stream/evaluator/operation_helpers/math_helper.rb
 - lib/tensor_stream/evaluator/operation_helpers/random_gaussian.rb
@@ -352,7 +340,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: A Pure ruby tensorflow implementation

data/lib/tensor_stream/evaluator/kernels/cond.cl.erb

@@ -1,5 +0,0 @@
-% ["#{dtype}"].product(%w[less less_equal equal not_equal greater greater_equal logical_and]).each do |dtype, fname|
-% c_dtype = dtype_to_c_type(dtype)
-% op = operator_to_c(fname)
-<%= render 'bool_operand.cl', c_dtype: c_dtype, op: op, fname: fname, dtype: dtype, result_t: 'int' %>
-% end