tensor_stream 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bb0eeddbfc4edec804a8207a5c708272245229dd
-  data.tar.gz: 399ea9f9b5f92376168a814a8c48c90d9c9f8371
+  metadata.gz: f14dd6388d5cdd10827cebde01a9cbca0686b653
+  data.tar.gz: d2ccba35defe6474a21bd75fcb09f8d49ce42e79
 SHA512:
-  metadata.gz: b2e4f871654bad8e35147643dd371de24689bb2971a20d352488e339d0a8b298757c4a8e335d4706a384b5aebf265b65281db721d2228901b194fb07092e8797
-  data.tar.gz: 48e9f34c17bb1f1673383d38c56429885cfb07f835374b7426a45e23695134ea05cc9faedd3a22d22da8a2c72da959d2063f8243ed52f8491aae4dfcc9507ccf
+  metadata.gz: 244026aae6ce13d8e932deada3c169b5320df517eb5dd7db5ea8c06c1cdedc9c9829d7f149261602f502c284ffe65ae831845016d9425250b0ad9d7d66fc6a0e
+  data.tar.gz: 91811c88a464604f5ca1e776f86d0342dc316ee016d920d40d8a228e2978f6a275783c5613a97cf21af1ba9256c951ad3db777b66fae20e5d1f8f9659f170301

data/CHANGELOG.md

@@ -4,6 +4,15 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.1] - 2018-06-27
+### Added
+- Added support for control_dependencies
+- [NEW OP] floor, ceil
+
+### Fixes
+- fixed variable assignment of value sometimes not working
+- variable assignment now checks for data types properly
+
 ## [0.5.0] - 2018-06-25
 ### Added
 - [OpenCL] boolean types now use short by default

data/README.md

@@ -214,10 +214,41 @@ sess.run(....) # do stuff
 
 ```
 
-You can manually place operations using ts.device
+You can manually place operations using ts.device e.g:
 
 ```ruby
+ts = TensorStream
+# Creates a graph. place in the first OpenCL CPU device
 
+a, b = ts.device('/cpu:0') do
+  a = ts.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape: [2, 3], name: 'a')
+  b = ts.constant([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], shape: [3, 2], name: 'b')
+  [a, b]
+end
+
+c = ts.device('/device:GPU:0') do
+  ts.matmul(a, b)
+end
+
+# Creates a session with log_device_placement set to True.
+sess = ts.session(log_device_placement: true)
+# Runs the op.
+print(sess.run(c))
+
+# a : apple:0
+# b : apple:0
+# a_1 : apple:0
+# b_1 : apple:0
+# matmul:0 : apple:1
+# [[22.0, 28.0], [49.0, 64.0]] => nil
+```
+
+To force the ruby evaluator even with the OpenCL evaluator loaded you can use:
+
+```ruby
+ts.device('/ts:ruby:cpu') do
+    # put ops here
+end
 ```
 
 Note that the OpenCL evaluator provides speedup if you are using large tensors, tensors that are only using scalars like the linear regression sample will actually be slower.

data/benchmark/benchmark.rb

@@ -24,7 +24,10 @@ seed = 5
 tf.set_random_seed(seed)
 
 SHAPES = [32, 32]
-a = tf.random_uniform(SHAPES)
+
+sess = tf.session(:ruby_evaluator)
+
+a = tf.constant(sess.run(tf.random_uniform(SHAPES)))
 a_int = tf.constant([
   [1, 2, 3, 4, 4, 1, 4, 8, 3, 4, 1, 1],
   [2, 2, 3, 4, 4, 1, 1, 1, 1, 4, 1, 1],
@@ -40,11 +43,11 @@ a_int = tf.constant([
   [4, 2, 3, 4, 0, 1, 1, 0, 0, 2, 1, 2],
 ])
 
-b = tf.random_uniform(SHAPES)
+b = tf.constant(sess.run(tf.random_uniform(SHAPES)))
 
-c = tf.random_uniform(SHAPES)
+c = tf.constant(sess.run(tf.random_uniform(SHAPES)))
 
-d = tf.random_uniform(SHAPES)
+d = tf.constant(sess.run(tf.random_uniform(SHAPES)))
 
 p = tf.placeholder('float')
 q = tf.placeholder('float')
@@ -59,13 +62,11 @@ softmax = tf.nn.softmax(a)
 
 puts TensorStream::Evaluator.default_evaluators
 
-sess = tf.session(:ruby_evaluator)
 sess2 = tf.session
 
 puts `cat /proc/cpuinfo | grep "model name" | head -1`
 device = TensorStream::Evaluator::OpenclEvaluator.default_device.native_device
 puts "OpenCL device #{device.platform.to_s} #{device.name}"
-
 Benchmark.bmbm do |x|
   x.report("pure ruby ooo matmul     :") { 100.times do sess.run(out_of_order) end }
   x.report("opencl    ooo matmul     :") { 100.times do sess2.run(out_of_order) end }

data/benchmark_intel.txt

@@ -1,21 +1,36 @@
-Intel(R) HD Graphics Skylake ULT GT2
+TensorStream::Evaluator::OpenclEvaluator
+TensorStream::Evaluator::RubyEvaluator
+model name	: Intel(R) Core(TM) i5-6200U CPU @ 2.30GHz
+OpenCL device Intel Gen OCL Driver Intel(R) HD Graphics Skylake ULT GT2
 Rehearsal --------------------------------------------------------------
-pure ruby                :   3.150000   0.000000   3.150000 (  3.160716)
-opencl                   :   0.260000   0.100000   0.360000 (  0.593404)
-pure ruby single function:   0.480000   0.010000   0.490000 (  0.489171)
-opencl     singlefunction:   0.290000   0.020000   0.310000 (  0.369045)
-pure ruby pow float:         0.150000   0.000000   0.150000 (  0.146517)
-opencl pow float:            0.330000   0.010000   0.340000 (  0.366148)
-pure ruby pow int:           0.020000   0.000000   0.020000 (  0.026756)
-opencl pow int:              0.230000   0.010000   0.240000 (  0.246756)
------------------------------------------------------ total: 5.060000sec
+pure ruby ooo matmul     :   1.800000   0.000000   1.800000 (  1.803752)
+opencl    ooo matmul     :   0.520000   0.050000   0.570000 (  0.630992)
+pure ruby softmax        :   0.300000   0.000000   0.300000 (  0.303185)
+opencl    softmax        :   0.180000   0.010000   0.190000 (  0.200246)
+pure ruby matmul         :   0.860000   0.010000   0.870000 (  0.869387)
+opencl    matmul         :   0.260000   0.020000   0.280000 (  0.335164)
+pure ruby                :   2.960000   0.020000   2.980000 (  2.980800)
+opencl                   :   1.050000   0.090000   1.140000 (  1.258354)
+pure ruby single function:   0.460000   0.000000   0.460000 (  0.464543)
+opencl     singlefunction:   0.570000   0.020000   0.590000 (  0.590300)
+pure ruby pow float:         0.120000   0.000000   0.120000 (  0.123025)
+opencl pow float:            0.290000   0.010000   0.300000 (  0.316175)
+pure ruby pow int:           0.020000   0.000000   0.020000 (  0.021570)
+opencl pow int:              0.180000   0.000000   0.180000 (  0.194088)
+----------------------------------------------------- total: 9.800000sec
 
                                  user     system      total        real
-pure ruby                :   3.170000   0.000000   3.170000 (  3.178458)
-opencl                   :   0.230000   0.110000   0.340000 (  0.588869)
-pure ruby single function:   0.450000   0.000000   0.450000 (  0.449185)
-opencl     singlefunction:   0.100000   0.020000   0.120000 (  0.158280)
-pure ruby pow float:         0.100000   0.000000   0.100000 (  0.098041)
-opencl pow float:            0.050000   0.000000   0.050000 (  0.084249)
-pure ruby pow int:           0.020000   0.000000   0.020000 (  0.021537)
-opencl pow int:              0.030000   0.010000   0.040000 (  0.062121)
+pure ruby ooo matmul     :   1.860000   0.000000   1.860000 (  1.866387)
+opencl    ooo matmul     :   0.410000   0.040000   0.450000 (  0.505565)
+pure ruby softmax        :   0.300000   0.000000   0.300000 (  0.298407)
+opencl    softmax        :   0.120000   0.000000   0.120000 (  0.128033)
+pure ruby matmul         :   0.830000   0.000000   0.830000 (  0.836471)
+opencl    matmul         :   0.240000   0.010000   0.250000 (  0.269629)
+pure ruby                :   2.950000   0.000000   2.950000 (  2.947306)
+opencl                   :   0.930000   0.100000   1.030000 (  1.205344)
+pure ruby single function:   0.650000   0.000000   0.650000 (  0.642834)
+opencl     singlefunction:   0.840000   0.040000   0.880000 (  1.097814)
+pure ruby pow float:         0.140000   0.000000   0.140000 (  0.140097)
+opencl pow float:            0.190000   0.010000   0.200000 (  0.269772)
+pure ruby pow int:           0.030000   0.000000   0.030000 (  0.030491)
+opencl pow int:              0.040000   0.010000   0.050000 (  0.084335)

data/benchmark_nvidia.txt

@@ -1,33 +1,36 @@
-using GeForce GTX 950M
-Rehearsal ------------------------------------------------------------------
-pure ruby ooo matmul         :   1.850000   0.000000   1.850000 (  1.851424)
-opencl    ooo matmul         :   0.050000   0.000000   0.050000 (  0.059594)
-pure ruby softmax        :       0.310000   0.000000   0.310000 (  0.309991)
-opencl    softmax        :       0.040000   0.000000   0.040000 (  0.029352)
-pure ruby matmul         :       0.900000   0.000000   0.900000 (  0.902600)
-opencl    matmul         :       0.040000   0.000000   0.040000 (  0.032638)
-pure ruby                :       3.160000   0.010000   3.170000 (  3.167418)
-opencl                   :       0.200000   0.000000   0.200000 (  0.191803)
-pure ruby single function:       0.470000   0.000000   0.470000 (  0.486152)
-opencl     singlefunction:       0.120000   0.000000   0.120000 (  0.118357)
-pure ruby pow float:             0.120000   0.000000   0.120000 (  0.123476)
-opencl pow float:                0.060000   0.000000   0.060000 (  0.056446)
-pure ruby pow int:               0.020000   0.000000   0.020000 (  0.021575)
-opencl pow int:                  0.070000   0.010000   0.080000 (  0.073531)
---------------------------------------------------------- total: 7.430000sec
+TensorStream::Evaluator::OpenclEvaluator
+TensorStream::Evaluator::RubyEvaluator
+model name	: Intel(R) Core(TM) i5-6200U CPU @ 2.30GHz
+OpenCL device NVIDIA CUDA GeForce GTX 950M
+Rehearsal --------------------------------------------------------------
+pure ruby ooo matmul     :   1.670000   0.010000   1.680000 (  1.682059)
+opencl    ooo matmul     :   0.100000   0.100000   0.200000 (  0.220002)
+pure ruby softmax        :   0.380000   0.010000   0.390000 (  0.377827)
+opencl    softmax        :   0.040000   0.000000   0.040000 (  0.040750)
+pure ruby matmul         :   1.000000   0.010000   1.010000 (  1.013795)
+opencl    matmul         :   0.040000   0.000000   0.040000 (  0.032285)
+pure ruby                :   3.460000   0.010000   3.470000 (  3.486048)
+opencl                   :   0.320000   0.020000   0.340000 (  0.326977)
+pure ruby single function:   0.460000   0.000000   0.460000 (  0.460433)
+opencl     singlefunction:   0.130000   0.000000   0.130000 (  0.130273)
+pure ruby pow float:         0.110000   0.000000   0.110000 (  0.115466)
+opencl pow float:            0.040000   0.010000   0.050000 (  0.030290)
+pure ruby pow int:           0.020000   0.000000   0.020000 (  0.023065)
+opencl pow int:              0.040000   0.010000   0.050000 (  0.044086)
+----------------------------------------------------- total: 7.990000sec
 
-                                     user     system      total        real
-pure ruby ooo matmul         :   1.840000   0.000000   1.840000 (  1.841208)
-opencl    ooo matmul         :   0.060000   0.020000   0.080000 (  0.073492)
-pure ruby softmax        :       0.310000   0.000000   0.310000 (  0.306199)
-opencl    softmax        :       0.030000   0.000000   0.030000 (  0.034720)
-pure ruby matmul         :       0.910000   0.000000   0.910000 (  0.910180)
-opencl    matmul         :       0.030000   0.010000   0.040000 (  0.025197)
-pure ruby                :       3.180000   0.000000   3.180000 (  3.170839)
-opencl                   :       0.170000   0.000000   0.170000 (  0.165880)
-pure ruby single function:       0.430000   0.000000   0.430000 (  0.427909)
-opencl     singlefunction:       0.090000   0.010000   0.100000 (  0.091550)
-pure ruby pow float:             0.090000   0.000000   0.090000 (  0.096681)
-opencl pow float:                0.040000   0.000000   0.040000 (  0.040202)
-pure ruby pow int:               0.020000   0.000000   0.020000 (  0.021576)
-opencl pow int:                  0.030000   0.000000   0.030000 (  0.022889)
+                                 user     system      total        real
+pure ruby ooo matmul     :   1.790000   0.000000   1.790000 (  1.794305)
+opencl    ooo matmul     :   0.050000   0.000000   0.050000 (  0.049030)
+pure ruby softmax        :   0.300000   0.000000   0.300000 (  0.305664)
+opencl    softmax        :   0.030000   0.000000   0.030000 (  0.021897)
+pure ruby matmul         :   0.810000   0.000000   0.810000 (  0.805583)
+opencl    matmul         :   0.030000   0.000000   0.030000 (  0.024358)
+pure ruby                :   2.870000   0.010000   2.880000 (  2.881779)
+opencl                   :   0.170000   0.000000   0.170000 (  0.173036)
+pure ruby single function:   0.400000   0.000000   0.400000 (  0.398390)
+opencl     singlefunction:   0.120000   0.000000   0.120000 (  0.117482)
+pure ruby pow float:         0.100000   0.000000   0.100000 (  0.099471)
+opencl pow float:            0.030000   0.000000   0.030000 (  0.025039)
+pure ruby pow int:           0.030000   0.000000   0.030000 (  0.028251)
+opencl pow int:              0.040000   0.000000   0.040000 (  0.031384)

data/lib/tensor_stream/evaluator/base_evaluator.rb

@@ -97,8 +97,13 @@ module TensorStream
           resolved_inputs = tensor.inputs.map do |i|
             next if i.nil?
             if @context[:_cache][:placement][tensor.name] != @context[:_cache][:placement][i.name] # tensor is on another device or evaluator
+              cache_key = "#{tensor.graph.object_id}_#{i.name}:#{object_id}"
+              next @context[:_cache][cache_key] if @context[:_cache].key?(cache_key)
+
               result = @session.delegate_to_evaluator(i, @context, execution_context)
-              convert_from_buffer(i, result)
+              convert_from_buffer(i, result).tap do |buffer|
+                @context[:_cache][cache_key] = buffer if i.is_const
+              end
             else
               prepare_input(i, execution_context, op_options)
             end

data/lib/tensor_stream/evaluator/opencl/kernels/ceil.cl

@@ -0,0 +1,8 @@
+% c_dtype = dtype_to_c_type(dtype)
+__kernel void ceil_<%= dtype %>(const int M, const int N, __global const <%= c_dtype %> *A, __global <%= c_dtype %> *C) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+
+    C[globalRow * N + globalCol] = ceil(A[globalRow * N + globalCol]);
+}

data/lib/tensor_stream/evaluator/opencl/kernels/floor.cl

@@ -0,0 +1,8 @@
+% c_dtype = dtype_to_c_type(dtype)
+__kernel void floor_<%= dtype %>(const int M, const int N, __global const <%= c_dtype %> *A, __global <%= c_dtype %> *C) {
+    // Get the index of the current element to be processed
+    const int globalRow = get_global_id(0); // Row ID of C (0..M)
+    const int globalCol = get_global_id(1); // Col ID of C (0..N)
+
+    C[globalRow * N + globalCol] = floor(A[globalRow * N + globalCol]);
+}

data/lib/tensor_stream/evaluator/opencl/opencl_buffer.rb

@@ -20,7 +20,14 @@ module TensorStream
         return buffer[0]
       end
 
+      if dirty
+        op.command_queue.enqueue_read_buffer(cl_buffer, buffer, event_wait_list: [op].compact)
+        op.command_queue.finish
+        self.dirty = false
+      end
+
       result = buffer.reshape(*shape.reverse).to_a
+
       if data_type == :boolean
         result = process_function_op(result, ->(a, _b) { a != 0 })
       end

data/lib/tensor_stream/evaluator/opencl/opencl_evaluator.rb

@@ -51,7 +51,7 @@ module TensorStream
 
       def self.fetch_device(query = [])
         devices = query_devices_with_score
-        platform_devices = devices.select { |d| d[0].platform.to_s.downcase =~ /#{query[0].downcase}/ }
+        platform_devices = devices.select { |d| d[0].platform.to_s.gsub(' ','_').downcase =~ /#{query[0].downcase}/ }
         opencl_to_device(platform_devices[[query[1].to_i, platform_devices.size - 1].min])
       end
 
@@ -215,9 +215,7 @@ module TensorStream
 
       def _run(tensor, execution_context)
         return tensor if tensor.is_a?(OpenCLBuffer)
-        if tensor.is_a?(Array) && tensor.size > 0 && tensor[0].is_a?(Tensor)
-          return tensor.map { |t| _run(t, execution_context) }
-        end
+        return tensor.map { |t| _run(t, execution_context) } if tensor.is_a?(Array) && !tensor.size.empty? && tensor[0].is_a?(Tensor)
 
         tensor = tensor.call if tensor.is_a?(Proc)
 
@@ -246,12 +244,11 @@ module TensorStream
         tensor.buffer
       end
 
-      register_op :log do |context, tensor, inputs|
-        execute_func('log', tensor, inputs[0], context)
+      register_op :no_op do |_context, _tensor, _inputs|
       end
 
-      register_op :sin do |context, tensor, inputs|
-        execute_func('sin', tensor, inputs[0], context)
+      register_op :log do |context, tensor, inputs|
+        execute_func('log', tensor, inputs[0], context)
       end
 
       register_op :cond do |context, tensor, inputs|
@@ -347,7 +344,7 @@ module TensorStream
         end
       end
 
-      %i[sign exp tan cos abs sqrt negate square reciprocal tanh tanh_grad sigmoid log1p round].each do |op|
+      %i[sign exp tan sin cos abs sqrt negate square reciprocal tanh tanh_grad sigmoid log1p round floor ceil].each do |op|
         register_op op, noop: true do |context, tensor, inputs|
           execute_func(op.to_s, tensor, inputs[0], context)
         end
@@ -385,30 +382,6 @@ module TensorStream
         output_buffer
       end
 
-      register_op :truncate do |context, tensor, inputs|
-        a, b = inputs
-        if a.shape.size.zero?
-          a
-        else
-          input_b = read_final_result(b)
-          if a.shape == input_b
-            a
-          else
-            input_a = read_final_result(a)
-            if input_b == []
-              if a.buffer.size == 1
-                a.shape = input_b
-                a
-              else
-                wrap_opencl(a.buffer[0], data_type: a.data_type, name: tensor.name)
-              end
-            else
-              wrap_opencl(truncate(input_a, input_b), data_type: a.data_type, name: tensor.name)
-            end
-          end
-        end
-      end
-
       register_op :check_numerics, noop: true do |context, tensor, inputs|
         a = complete_eval(inputs[0], context)
         name = tensor.options[:name]
@@ -433,6 +406,30 @@ module TensorStream
         end
       end
 
+      register_op :truncate do |_context, tensor, inputs|
+        a, b = inputs
+        if a.shape.size.zero?
+          a
+        else
+          input_b = read_final_result(b)
+          if a.shape == input_b
+            a
+          else
+            input_a = read_final_result(a)
+            if input_b == []
+              if a.buffer.size == 1
+                a.shape = input_b
+                a
+              else
+                wrap_opencl(a.buffer[0], data_type: a.data_type, name: tensor.name)
+              end
+            else
+              wrap_opencl(truncate(input_a, input_b), data_type: a.data_type, name: tensor.name)
+            end
+          end
+        end
+      end
+
       register_op :print do |context, tensor, inputs|
         a, b = inputs
         input_b = complete_eval(b, context)
@@ -610,12 +607,16 @@ module TensorStream
         buffer = complete_eval(b, child_context)
 
         if assign.buffer
-          buffer = type_cast(buffer, assign.data_type, name: "#{tensor.name}/cast_#{tensor.name}_#{tensor.data_type}")
+          # buffer = type_cast(buffer, assign.data_type, name: "#{tensor.name}/cast_#{tensor.name}_#{tensor.data_type}")
           if assign.buffer.cl_buffer != buffer.cl_buffer
             assign.buffer.op = _opencl_queue.enqueue_copy_buffer(buffer.cl_buffer, assign.buffer.cl_buffer, event_wait_list: [buffer.op, assign.buffer.op])
+          else
+            assign.buffer.op = buffer.op
           end
         else
-          assign.buffer = convert_to_opencl(read_final_result(buffer), buffer.shape, data_type: tensor.data_type, name: tensor.name)
+          value = read_final_result(buffer)
+          assign.buffer = convert_to_opencl(value, buffer.shape, data_type: tensor.data_type, name: assign.name)
+          assign.value = value
         end
         assign.buffer.dirty = true
         assign.buffer

data/lib/tensor_stream/evaluator/ruby_evaluator.rb

@@ -96,6 +96,10 @@ module TensorStream
         end
       end
 
+      register_op(:no_op, no_eval: true) do |_context, _tensor, inputs|
+        inputs
+      end
+
       register_op(:const) do |context, _tensor, inputs|
         inputs[0]
       end
@@ -232,6 +236,14 @@ module TensorStream
         call_op(:sqrt, inputs[0], context, ->(t, _b) { Math.sqrt(t) })
       end
 
+      register_op :floor, no_eval: true do |context, _tensor, inputs|
+        call_op(:floor, inputs[0], context, ->(t, _b) { t.floor })
+      end
+
+      register_op :ceil, no_eval: true do |context, _tensor, inputs|
+        call_op(:ceil, inputs[0], context, ->(t, _b) { t.ceil })
+      end
+
       register_op :square, no_eval: true  do |context, tensor, inputs|
         call_op(:square, inputs[0], context, ->(t, _b) {  t * t  })
       end

data/lib/tensor_stream/graph.rb

@@ -120,8 +120,15 @@ module TensorStream
       add_node(node)
     end
 
-    def control_dependencies(_dependencies = [], &_block)
-      raise 'not implemented'
+    def control_dependencies(control_inputs = [], &block)
+      Thread.current["ts_graph_#{object_id}"] ||= {}
+      Thread.current["ts_graph_#{object_id}"][:control_dependencies] ||= []
+      Thread.current["ts_graph_#{object_id}"][:control_dependencies] << Operation.new(:no_op, *control_inputs)
+      begin
+        block.call
+      ensure
+        Thread.current["ts_graph_#{object_id}"][:control_dependencies].pop
+      end
     end
 
     def enable_eager_execution
@@ -178,6 +185,12 @@ module TensorStream
       graph_thread_storage[:current_scope].join('/')
     end
 
+    def get_dependency_scope
+      graph_thread_storage = Thread.current["ts_graph_#{object_id}"]
+      return nil if graph_thread_storage.nil? || graph_thread_storage[:control_dependencies].nil?
+      graph_thread_storage[:control_dependencies].last
+    end
+
     def get_device_scope
       graph_thread_storage = Thread.current["ts_graph_#{object_id}"]
       return :default if graph_thread_storage.nil? || graph_thread_storage[:default_device].nil?

data/lib/tensor_stream/helpers/op_helper.rb

@@ -2,7 +2,12 @@ module TensorStream
   # module that contains helper functions useful for ops
   module OpHelper
     def _op(code, t_a, t_b = nil, options = {})
-      Operation.new(code.to_sym, t_a, t_b, options)
+      op = Operation.new(code.to_sym, t_a, t_b, options)
+      if !TensorStream.get_default_graph.get_dependency_scope.nil?
+        i_op(:identity, op, TensorStream.get_default_graph.get_dependency_scope, name: [op.name, 'tuple', 'control_dependency'].join('/'))
+      else
+        op
+      end
     end
 
     # same as op but with a marker that it was internal generated

data/lib/tensor_stream/math_gradients.rb

@@ -186,6 +186,9 @@ module TensorStream
           i_op(:sigmoid_grad, x, grad)
         when :softmax
           i_op(:softmax_grad, x, grad)
+        when :floor, :ceil
+          # non differentiable
+          nil
         when :zeros_like
           # non differentiable
           nil

data/lib/tensor_stream/operation.rb

@@ -4,7 +4,15 @@ module TensorStream
     attr_accessor :name, :operation, :inputs, :rank, :options
     attr_reader :outputs
 
-    def initialize(operation, input_a, input_b, options = {})
+    def initialize(operation, *args)
+      options = if args.last.is_a?(Hash)
+        args.pop
+      else
+        {}
+      end
+
+      inputs = args
+
       setup_initial_state(options)
 
       @operation = operation
@@ -15,7 +23,7 @@ module TensorStream
 
       @options = options
 
-      @inputs = [input_a, input_b].map { |i| options[:preserve_params_type] ? i : TensorStream.convert_to_tensor(i) }
+      @inputs = inputs.map { |i| options[:preserve_params_type] ? i : TensorStream.convert_to_tensor(i) }
       @data_type = set_data_type(options[:data_type])
       @is_const = infer_const
       @shape = TensorShape.new(infer_shape)

data/lib/tensor_stream/ops.rb

@@ -146,6 +146,20 @@ module TensorStream
       _op(:ones, shape, nil, data_type: dtype, name: name)
     end
 
+    ##
+    # Returns element-wise largest integer not greater than x.
+    def floor(input, name: nil)
+      check_allowed_types(input, FLOATING_POINT_TYPES)
+      _op(:floor, input, name: name)
+    end
+
+    ##
+    # Returns element-wise smallest integer in not less than x
+    def ceil(input, name: nil)
+      check_allowed_types(input, FLOATING_POINT_TYPES)
+      _op(:ceil, input, name: name)
+    end
+
     ##
     # Returns the truth value of (x < y) element-wise.
     # This operation supports broadcasting

data/lib/tensor_stream/session.rb

@@ -73,9 +73,6 @@ module TensorStream
         value = delegate_to_evaluator(e, context, {})
         value.respond_to?(:to_ruby) ? value.to_ruby : value
       end
-
- 
-
       result.size == 1 ? result.first : result
     end
 

data/lib/tensor_stream/tensor.rb

@@ -55,80 +55,80 @@ module TensorStream
     end
 
     def +(other)
-      _a, b = TensorStream.check_data_types(self, other)
-      TensorStream::Operation.new(:add, self, b)
+      _a, other = TensorStream.check_data_types(self, other)
+      _op(:add, self, other)
     end
 
     def [](index)
-      TensorStream::Operation.new(:index, self, index)
+      _op(:index, self, index)
     end
 
     def *(other)
-      TensorStream.check_data_types(self, other)
-      TensorStream::Operation.new(:mul, self, TensorStream.convert_to_tensor(other, dtype: data_type))
+      _a, other = TensorStream.check_data_types(self, other)
+      _op(:mul, self, TensorStream.convert_to_tensor(other, dtype: data_type))
     end
 
     def **(other)
-      TensorStream.check_data_types(self, other)
-      TensorStream::Operation.new(:pow, self, TensorStream.convert_to_tensor(other, dtype: data_type))
+      _a, other = TensorStream.check_data_types(self, other)
+      _op(:pow, self, TensorStream.convert_to_tensor(other, dtype: data_type))
     end
 
     def /(other)
-      TensorStream.check_data_types(self, other)
-      TensorStream::Operation.new(:div, self, TensorStream.convert_to_tensor(other, dtype: data_type))
+      _a, other = TensorStream.check_data_types(self, other)
+      _op(:div, self, TensorStream.convert_to_tensor(other, dtype: data_type))
     end
 
     def -(other)
-      TensorStream.check_data_types(self, other)
-      TensorStream::Operation.new(:sub, self, TensorStream.convert_to_tensor(other, dtype: data_type))
+      _a, other = TensorStream.check_data_types(self, other)
+      _op(:sub, self, TensorStream.convert_to_tensor(other, dtype: data_type))
     end
 
     def -@
-      TensorStream::Operation.new(:negate, self, nil)
+      _op(:negate, self, nil)
     end
 
     def ==(other)
-      TensorStream.check_data_types(self, other)
+      _a, other = TensorStream.check_data_types(self, other)
       _op(:equal, self, other)
     end
 
     def <(other)
-      TensorStream.check_data_types(self, other)
+      _a, other = TensorStream.check_data_types(self, other)
       _op(:less, self, other)
     end
 
     def !=(other)
-      TensorStream.check_data_types(self, other)
+      _a, other = TensorStream.check_data_types(self, other)
       _op(:not_equal, self, other)
     end
 
     def >(other)
-      TensorStream.check_data_types(self, other)
+      _a, other = TensorStream.check_data_types(self, other)
       _op(:greater, self, other)
     end
 
     def >=(other)
-      TensorStream.check_data_types(self, other)
+      _a, other = TensorStream.check_data_types(self, other)
       _op(:greater_equal, self, other)
     end
 
     def <=(other)
-      TensorStream.check_data_types(self, other)
+      _a, other = TensorStream.check_data_types(self, other)
       _op(:less_equal, self, other)
     end
 
     def and(other)
-      TensorStream.check_data_types(self, other)
+      _a, other = TensorStream.check_data_types(self, other)
       _op(:logical_and, self, other)
     end
 
     def matmul(other)
-      TensorStream.check_data_types(self, other)
+      _a, other = TensorStream.check_data_types(self, other)
       _op(:matmul, self, other)
     end
 
     def dot(other)
-      TensorStream.check_data_types(self, other)
+      _a, other = TensorStream.check_data_types(self, other)
       _op(:matmul, self, other)
     end
 

data/lib/tensor_stream/utils.rb

@@ -149,6 +149,11 @@ module TensorStream
       Graph.get_default_graph.get_collection(name, options)
     end
 
+    def assign(ref, value, name: nil)
+      raise "#{ref.name} not a variable" unless ref.is_a?(Variable)
+      ref.assign(value, name: name)
+    end
+
     def placeholder(dtype, shape: nil, name: nil)
       TensorStream::Placeholder.new(dtype, nil, shape, name: name)
     end
@@ -169,6 +174,10 @@ module TensorStream
       TensorStream.get_default_graph.random_seed = seed
     end
 
+    def control_dependencies(control_inputs, &block)
+      TensorStream.get_default_graph.control_dependencies(control_inputs, &block)
+    end
+
     def convert_to_tensor(value, dtype: nil, name: nil, preferred_dtype: nil)
       return convert_to_tensor(value.call) if value.is_a?(Proc)
 

data/lib/tensor_stream/variable.rb

@@ -32,21 +32,21 @@ module TensorStream
       assign(init_op)
     end
 
-    def assign(value)
-      Operation.new(:assign, self, value)
+    def assign(value, name: nil)
+      _a, value = TensorStream.check_data_types(self, value)
+      Operation.new(:assign, self, value, name: name)
     end
 
     def read_value
-      if buffer && buffer.dirty
+      if buffer
         @value = buffer.to_ruby
-        buffer.dirty = false
       end
 
       @value
     end
 
     def assign_add(value)
-      value = Tensor.cast_dtype(value, data_type)
+      _a, value = TensorStream.check_data_types(self, value)
       Operation.new(:assign_add, self, value, data_type: data_type)
     end
 
@@ -55,6 +55,7 @@ module TensorStream
     end
 
     def assign_sub(value)
+      _a, value = TensorStream.check_data_types(self, value)
       Operation.new(:assign_sub, self, value)
     end
 

data/lib/tensor_stream/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tensor_stream
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Joseph Emmanuel Dayo
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-06-25 00:00:00.000000000 Z
+date: 2018-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -248,10 +248,12 @@ files:
 - 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/ceil.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/floor.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
@@ -340,7 +342,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.10
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: A Pure ruby tensorflow implementation