tensor_stream 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b5b9fcecbe7b27fadeaf403d886ebd0bbdaff531
-  data.tar.gz: b33ee60d3a4fc3c182a2984b8caaac80b7559435
+  metadata.gz: adb3c1e45383170db2d5c9f5f3568c251cdddb64
+  data.tar.gz: 99cd0f23353e8f72af2bda3bb84cf4b61c615445
 SHA512:
-  metadata.gz: f847e4d908f8c1b77f331caa45ddfec15554c44076d8e49b1d5520a61bdfe4294542c5a50433699cfa9e8e88eee3ae5780c00f02d2451282f1143fb5a92822be
-  data.tar.gz: 0ce481db0db30fc53921f011be4d4f294b7f9b78d9fc6a91690f694a912d4d3cbd4cf452290162d8af88b4916bc0a3a7738cf58a5f2082292e833bb8325c92b4
+  metadata.gz: 62eb911e080ba894d6c349870d86286fecbd02f8ad0b762fe33ca311ffbd500f18f78f80520d5e875dc821b1c0f8d556f45fe913142bc02ae33d931af0fb840c
+  data.tar.gz: d599f839bd0d6ba706d3c7fafb3e903a17070af7dfd5dbe733ce21e2641bc4428f8e0d204f649f7f80c843aa48ff2e3c98880c36822a071279de5cd62a39b3dc

data/README.md

@@ -6,10 +6,11 @@ The goal of this gem is to have a high performance machine learning and compute
 
 ## Features
 
-- Replicates most of the commonly used low-level tensorflow ops
+- Replicates most of the commonly used low-level tensorflow ops (tf.add, tf.constant, tf.placeholder, tf.matmul, tf.sin etc...)
 - Supports auto-differentiation via tf.gradients (mostly)
 - Provision to use your own opcode evaluator (opencl, sciruby and tensorflow backends planned)
 - Goal is to be as close to TensorFlow in behavior but with some freedom to add ruby specific enhancements (with lots of test cases)
+- eager execution (experimental)
 
 Since this is a pure ruby implementation for now, performance is not there yet. However it should be a good enough environment to learn about tensorflow and experiment with some models.
 
@@ -93,6 +94,76 @@ tf.session do |sess|
 end
 ```
 
+## python to ruby guide
+
+Not all ops are available. Available ops are defined in lib/tensor_stream/ops.rb, corresponding gradients are found at lib/tensor_stream/math_gradients.
+
+There are also certain differences with regards to naming conventions, and named parameters:
+
+# Variables
+
+To make referencing python examples easier it is recommended to use "tf" as the TensorStream namespace
+
+At the beginning
+```ruby
+tf = TensorStream # recommended to use tf since most sample models on the net use this
+ts = TensorStream # use this if you plan to use TensorStream only features, so other devs will know about that
+```
+
+Note the difference in named and optional parameters
+
+Python
+
+```python
+w = tf.Variable(0, name='weights')
+w = tf.Variable(0, 'weights')
+```
+
+Ruby
+
+```ruby
+w =tf.variable(0, name: 'weights')
+```
+
+# Shapes
+
+Python
+```python
+x = tf.placeholder(tf.float32, shape=(1024, 1024))
+x = tf.placeholder(tf.float32, shape=(None, 1024))
+```
+
+ruby supports symbols for specifying data types, nil can be used for None
+
+Ruby
+```ruby
+x = tf.placeholder(:float32, shape: [1024, 1024])
+x = tf.placeholder(:float32, shape: [nil, 1024])
+```
+
+For debugging, each operation or tensor supports the to_math method
+
+```ruby
+X = tf.placeholder("float")
+Y = tf.placeholder("float")
+W = tf.variable(rand, name: "weight")
+b = tf.variable(rand, name: "bias")
+pred = X * W + b
+cost = tf.reduce_sum(tf.pow(pred - Y, 2)) / ( 2 * 10)
+cost.to_math # "(reduce_sum(|((((Placeholder: * weight) + bias) - Placeholder_2:)^2)|) / 10.0)"
+```
+
+breakpoints can also be set, block will be evaluated during computation
+
+```ruby
+a = tf.constant([2,2])
+b = tf.constant([3,3])
+
+f = tf.matmul(a, b).breakpoint! { |tensor, a, b, result_value| binding.pry }
+
+tf.session.run(f)
+```
+
 ## Roadmap
 
 - Docs

data/lib/tensor_stream/evaluator/ruby_evaluator.rb

@@ -175,8 +175,7 @@ module TensorStream
 
           generate_vector(tensor.options[:shape], generator: generator)
         when :flow_group
-          threads = tensor.items.collect { |item| Concurrent::Future.execute(executor: @thread_pool) { run(item, child_context) } }
-          threads.collect(&:value)
+          tensor.items.collect { |item| run(item, child_context) }
         when :assign
           assign = tensor.items[0] || tensor
           assign.value = complete_eval(tensor.items[1], child_context)
@@ -634,7 +633,16 @@ module TensorStream
         raise FullEvalNotPossible.new, "full eval not possible for #{eval_vector.name}" if eval_vector.is_a?(Tensor) || constant.is_a?(Tensor)
 
         eval_vector.each_with_index.collect do |item, index|
-          c = constant.is_a?(Array) ? constant[index] : constant
+          c = if constant.is_a?(Array)
+              if index < constant.size
+                constant[index]
+              else
+                raise "incompatible tensor shapes used during op" if constant.size != 1
+                constant[0]
+              end
+            else
+              constant
+            end
           if item.is_a?(Array)
             constant_op(item, c, child_context, op, switch)
           elsif item.respond_to?(:value)

data/lib/tensor_stream/math_gradients.rb

@@ -51,9 +51,9 @@ module TensorStream
         when :cos
           -i_op(:sin, tensor.items[0]) * grad
         when :add
-          grad_with_broadcast(tensor, wrt_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, wrt_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
 
@@ -66,10 +66,10 @@ module TensorStream
           gx = i_op(:div, grad, _ds(tensor.items[1]))
           gy = grad2 * i_op(:div, i_op(:div, -_ds(tensor.items[0]), _ds(tensor.items[1])), _ds(tensor.items[1]))
 
-          gx + gy
+          _reduce_when_necessary(gx + gy, wrt_dx)
         when :mul
           # apply the product rule
-          grad * _ds(tensor.items[1]) + _ds(tensor.items[0]) * grad2
+          _reduce_when_necessary(grad * _ds(tensor.items[1]) + _ds(tensor.items[0]) * grad2, wrt_dx)
         when :reduce_mean
           input_size = i_op(:reduce_prod, i_op(:shape, tensor.items[0]))
           output_size = i_op(:reduce_prod, i_op(:shape, tensor))
@@ -115,6 +115,7 @@ module TensorStream
           # norm_b = i_op(:cond, norm_b[0], norm_b, pred: i_op(:rank, matmul_db) > i_op(:rank, derivative_b))
 
           i_op(:cond, norm_a, zero_vect, pred: i_op(:reduce_sum, norm_a) != 0) + i_op(:cond, norm_b, zero_vect, pred: i_op(:reduce_sum, norm_b) != 0)
+          #  m.breakpoint! { |t, a, b, v|  binding.pry }
         else
           raise "no derivative implementation found for op #{tensor.operation}"
         end
@@ -140,18 +141,25 @@ module TensorStream
       end
     end
 
-    def self.grad_with_broadcast(tensor, wrt_dx, func, 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
-      func.call(grad, grad2 * multiplier)
+      _reduce_when_necessary(func.call(grad, grad2 * multiplier), wrt_dx)
     end
 
     def self._include?(arr, obj)
       arr.each { |a| return true if a.equal?(obj) }
       false
     end
+
+    def self._reduce_when_necessary(tensor, wrt_dx)
+      rank = op(:rank, tensor)
+      dx_rank = op(:rank, wrt_dx)
+      reduced = op(:reduce_sum, tensor, nil, axis: 0)
+      op(:cond, ->{ reduced }, tensor, pred: rank > dx_rank)
+    end
   end
 end

data/lib/tensor_stream/version.rb

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

data/samples/iris.rb

@@ -83,7 +83,7 @@ biases = {
 # Create model
 def neural_net(x, weights, biases)
     # Hidden fully connected layer with 256 neurons
-    layer_1 =  TensorStream.add(TensorStream.matmul(x, weights[:h1]), biases[:b1] , name: 'layer1_add')
+    layer_1 =  TensorStream.add(TensorStream.matmul(x, weights[:h1]), biases[:b1], name: 'layer1_add')
     # Hidden fully connected layer with 256 neurons
     layer_2 = TensorStream.add(TensorStream.matmul(layer_1, weights[:h2]), biases[:b2], name: 'layer2_add')
     # Output fully connected layer with a neuron for each class

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tensor_stream
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Joseph Emmanuel Dayo
@@ -193,7 +193,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: A Pure ruby tensorflow implementation