tensor_stream 0.8.6 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0168aeff699a7490174f164370f6cef9dbc3413f23352a696c3a468832bd1b24'
-  data.tar.gz: f62926f3b919cbf5001872d6fab23095807d6c5028de5d885256449e1dd52a01
+  metadata.gz: d5c4d8c8c2e586ef8c9cce0b57d31b68d9b30ddba682c79e0de5e0c905c76a22
+  data.tar.gz: c503cbef1dd51f563479a248b209f62b035fc076a531269b1d26656521a928a0
 SHA512:
-  metadata.gz: ce886b38d14603f9c3f5dbfc6d96f89041350cd7cfa40a2cb2178e2845a43e22e98bca8bd689b72a2b0acceb5da8b3988d88632d601c2da701b0979375e84200
-  data.tar.gz: 6dac48e933a46144fb78433e17077b2c9d9fbe68e4297a0958a752276e51401279460c6ac47adc88ac0b3890a0bb535bfb0f889b64b2439c2ea38c68fb9d1665
+  metadata.gz: 8a9fb88f5ac1c4f8ec47809405370f28009630155b56e6f1f9e0b1cf0d975188bcfe522216226d425c135a43551e08ddc9603c6ccf2c37e6d78ea3321c52ff5d
+  data.tar.gz: '080d79da1a32290f9ee5b411270835a80f9dd9d1b9d1d10ee28d67ad82c856f2bb3b31bfd122812ba6ff3206b3ff25ccf5294a5a2837d22cd038940229161ce4'

data/README.md

@@ -1,6 +1,4 @@
-[![Gem Version](https://badge.fury.io/rb/tensor_stream.svg)](https://badge.fury.io/rb/tensor_stream)
-
-[![CircleCI](https://circleci.com/gh/jedld/tensor_stream.svg?style=svg)](https://circleci.com/gh/jedld/tensor_stream)
+[![Gem Version](https://badge.fury.io/rb/tensor_stream.svg)](https://badge.fury.io/rb/tensor_stream)[![CircleCI](https://circleci.com/gh/jedld/tensor_stream.svg?style=svg)](https://circleci.com/gh/jedld/tensor_stream) [![Join the chat at https://gitter.im/tensor_stream/Lobby](https://badges.gitter.im/tensor_stream/Lobby.svg)](https://gitter.im/tensor_stream/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 # TensorStream
 

data/lib/tensor_stream/evaluator/ruby/array_ops.rb

@@ -122,7 +122,7 @@ module TensorStream
 
           res = TensorShape.reshape(output_buffer, new_shape)
 
-          TensorStream::Evaluator::OutputGroup.new(res)
+          TensorStream::Evaluator::OutputGroup.new(res, res.map { tensor.inputs[0].data_type })
         end
 
         register_op :squeeze do |_context, tensor, inputs|
@@ -302,7 +302,7 @@ module TensorStream
               split_tensor(value, begin_index, end_index, axis)
             end
           end
-          TensorStream::Evaluator::OutputGroup.new(res)
+          TensorStream::Evaluator::OutputGroup.new(res, res.map { tensor.inputs[0].data_type })
         end
 
         register_op :reshape do |_context, _tensor, inputs|
@@ -352,11 +352,11 @@ module TensorStream
           shape_eval(inputs[0], tensor.options[:out_type])
         end
 
-        register_op :shape_n do |_context, _tensor, inputs|
+        register_op :shape_n do |_context, tensor, inputs|
           shapes = inputs.collect do |input|
             shape_eval(input)
           end
-          TensorStream::Evaluator::OutputGroup.new(shapes)
+          TensorStream::Evaluator::OutputGroup.new(shapes, shapes.map { tensor.options[:out_type] })
         end
       end
     end

data/lib/tensor_stream/evaluator/ruby/nn_ops.rb

@@ -40,6 +40,7 @@ module TensorStream
         register_op :apply_adagrad do |_context, tensor, inputs|
           target_var, accum, lr, grad = inputs
           assign = tensor.inputs[0] || tensor
+
           assign.value = multi_array_op(->(v, a, g) { v - (g * lr * (1.0 / Math.sqrt(a))) }, target_var, accum, grad)
           assign.value
         end

data/lib/tensor_stream/operation.rb

@@ -224,7 +224,7 @@ module TensorStream
       when :index
         input_shape = inputs[0].shape.shape
         return nil if input_shape.nil?
-        return input_shape[1, input_shape.size]
+        input_shape[1, input_shape.size]
       when :mean, :prod, :sum
         return [] if inputs[1].nil?
         return nil if inputs[0].nil?
@@ -235,7 +235,7 @@ module TensorStream
         axis = inputs[1].is_a?(Tensor) ? inputs[1].value : inputs[1]
 
         axis = [axis] unless axis.is_a?(Array)
-        return input_shape.each_with_index.map do |s, index|
+        input_shape.each_with_index.map do |s, index|
           next nil if axis.include?(index)
           s
         end.compact
@@ -246,27 +246,27 @@ module TensorStream
 
         input_shape = inputs[0].shape.shape
         return new_shape if input_shape.nil?
-
-        return TensorShape.fix_inferred_elements(new_shape, input_shape.reduce(:*))
+        return nil if input_shape.include?(nil)
+        TensorShape.fix_inferred_elements(new_shape, input_shape.reduce(:*))
       when :flow_group
-        return []
+        []
       when :zeros, :ones, :fill
-        return inputs[0] ? inputs[0].value : options[:shape]
+        inputs[0] ? inputs[0].value : options[:shape]
       when :zeros_like, :ones_like
         inputs[0].shape.shape
       when :shape
-        return inputs[0].shape.shape ? [inputs[0].shape.shape.size] : nil
+        inputs[0].shape.shape ? [inputs[0].shape.shape.size] : nil
       when :mat_mul
         shape1 = inputs[0].shape.shape.nil? ? nil : inputs[0].shape.shape[0]
         shape2 = inputs[1].shape.shape.nil? ? nil : inputs[1].shape.shape[1]
-        return [shape1, shape2]
+        [shape1, shape2]
       when :transpose
         return nil unless shape_full_specified(inputs[0])
         return nil if inputs[1].is_a?(Tensor)
 
         rank = inputs[0].shape.shape.size
         perm = inputs[1] || (0...rank).to_a.reverse
-        return perm.map { |p| inputs[0].shape.shape[p] }
+        perm.map { |p| inputs[0].shape.shape[p] }
       when :stack
         return nil unless shape_full_specified(inputs[0])
 
@@ -276,7 +276,7 @@ module TensorStream
         rank = inputs[0].shape.shape.size + 1
         axis = rank + axis if axis < 0
         rotated_shape = Array.new(axis + 1) { new_shape.shift }
-        return rotated_shape.rotate! + new_shape
+        rotated_shape.rotate! + new_shape
       when :concat
         return nil if inputs[0].value.nil?
 
@@ -293,18 +293,16 @@ module TensorStream
 
         new_shape = inputs[1].shape.shape.dup
         new_shape[axis] = axis_size
-        return new_shape
+        new_shape
       when :slice, :squeeze
-        return nil
+        nil
       when :tile
-        return nil
+        nil
       else
         return nil if inputs[0].nil?
         return inputs[0].shape.shape if inputs.size == 1
-        return TensorShape.infer_shape(inputs[0].shape.shape, inputs[1].shape.shape) if inputs.size == 2 && inputs[0] && inputs[1]
+        TensorShape.infer_shape(inputs[0].shape.shape, inputs[1].shape.shape) if inputs.size == 2 && inputs[0] && inputs[1]
       end
-
-      nil
     end
 
     def propagate_consumer(consumer)

data/lib/tensor_stream/ops.rb

@@ -115,7 +115,7 @@ module TensorStream
       end
 
       if shapes_known
-        inputs.collect { |input| cons(input.shape.shape dtype: out_type) }
+        inputs.collect { |input| cons(input.shape.shape, dtype: out_type) }
       else
         res = _op(:shape_n, *inputs, out_type: out_type, name: name)
         Array.new(inputs.size) do |index|

data/lib/tensor_stream/version.rb

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

data/samples/mnist_data.rb

@@ -11,7 +11,7 @@ require 'tensor_stream'
 require 'mnist-learn'
 
 # Enable OpenCL hardware accelerated computation, not using OpenCL can be very slow
-require 'tensor_stream/evaluator/opencl/opencl_evaluator'
+# require 'tensor_stream/opencl'
 
 tf = TensorStream
 
@@ -20,11 +20,11 @@ puts "downloading minst data"
 mnist = Mnist.read_data_sets('/tmp/data', one_hot: true)
 puts "downloading finished"
 
-x = tf.placeholder(:float32, shape: [nil, 28, 28, 1])
+x = tf.placeholder(:float32, shape: [nil, 784])
 w = tf.variable(tf.zeros([784, 10]))
 b = tf.variable(tf.zeros([10]))
 
-init = tf.global_variables_initializer
+
 
 # model
 y = tf.nn.softmax(tf.matmul(tf.reshape(x, [-1, 784]), w) + b)
@@ -37,10 +37,11 @@ cross_entropy = -tf.reduce_sum(y_ * tf.log(y))
 is_correct = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
 accuracy =  tf.reduce_mean(tf.cast(is_correct, :float32))
 
-optimizer = TensorStream::Train::GradientDescentOptimizer.new(0.01)
+optimizer = TensorStream::Train::AdamOptimizer.new
 train_step = optimizer.minimize(cross_entropy)
 
 sess = tf.session
+init = tf.global_variables_initializer
 sess.run(init)
 
 (0...1000).each do |i|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tensor_stream
 version: !ruby/object:Gem::Version
-  version: 0.8.6
+  version: 0.9.0
 platform: ruby
 authors:
 - Joseph Emmanuel Dayo
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-09-11 00:00:00.000000000 Z
+date: 2018-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -243,7 +243,6 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- benchmark/benchmark.rb
 - benchmark_intel.txt
 - benchmark_nvidia.txt
 - benchmark_ryzen_amd.txt
@@ -314,7 +313,6 @@ files:
 - samples/multigpu.rb
 - samples/nearest_neighbor.rb
 - samples/raw_neural_net_sample.rb
-- samples/rnn.rb
 - tensor_stream.gemspec
 homepage: http://www.github.com/jedld/tensor_stream
 licenses:
@@ -337,7 +335,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 3.0.0.beta1
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: A Pure ruby tensorflow implementation

data/benchmark/benchmark.rb

@@ -1,88 +0,0 @@
-require "bundler/setup"
-require 'tensor_stream'
-require 'benchmark'
-require 'pry-byebug'
-require 'awesome_print'
-require 'tensor_stream/evaluator/opencl/opencl_evaluator'
-
-def tr(t, places = 1)
-  if t.is_a?(Array)
-    return t.collect do |v|
-      tr(v, places)
-    end
-  end
-
-  return t unless t.is_a?(Float)
-
-  t.round(places)
-end
-
-tf = TensorStream
-
-srand(5)
-seed = 5
-tf.set_random_seed(seed)
-
-SHAPES = [32, 32]
-
-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],
-  [3, 2, 3, 4, 0, 1, 1, 2, 1, 1, 2, 1],
-  [4, 2, 3, 4, 0, 1, 1, 0, 1, 1, 3, 1],
-  [4, 2, 3, 4, 0, 1, 1, 0, 1, 1, 4, 1],
-  [4, 2, 3, 4, 0, 1, 1, 0, 0, 1, 5, 1],
-  [4, 2, 3, 4, 0, 1, 1, 0, 0, 1, 6, 1],
-  [4, 2, 3, 4, 0, 1, 1, 0, 0, 0, 0, 1],
-  [4, 2, 3, 4, 0, 1, 1, 0, 0, 2, 6, 1],
-  [4, 2, 3, 4, 0, 1, 1, 0, 0, 2, 1, 1],
-  [4, 2, 3, 4, 0, 1, 1, 0, 0, 2, 1, 2],
-  [4, 2, 3, 4, 0, 1, 1, 0, 0, 2, 1, 2],
-])
-
-b = tf.constant(sess.run(tf.random_uniform(SHAPES)))
-
-c = tf.constant(sess.run(tf.random_uniform(SHAPES)))
-
-d = tf.constant(sess.run(tf.random_uniform(SHAPES)))
-
-p = tf.placeholder('float')
-q = tf.placeholder('float')
-
-model = -tf.sin(a.dot(b + p) + c).dot(a) + tf.cos(a.dot(d + q))
-single_function_test = (tf.sigmoid(a * p) * tf.sigmoid(b * q)) + c
-pow_f = tf.pow(a, 3)
-pow_i = tf.pow(a_int, 3)
-matmul = tf.matmul(a, b)
-out_of_order = tf.matmul(a, b) + tf.matmul(a, c)
-softmax = tf.nn.softmax(a)
-add_n = tf.add_n([a,b,c,d])
-
-puts TensorStream::Evaluator.default_evaluators
-
-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 add_n          :") { 100.times do sess.run(add_n) end }
-  x.report("opencl ruby add_n        :") { 100.times do sess2.run(add_n) end }
-  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 }
-  x.report("pure ruby softmax        :") { 100.times do sess.run(softmax) end }
-  x.report("opencl    softmax        :") { 100.times do sess2.run(softmax) end }
-  x.report("pure ruby matmul         :") { 100.times do sess.run(matmul) end }
-  x.report("opencl    matmul         :") { 100.times do sess2.run(matmul) end }
-  x.report("pure ruby                :") { 100.times do sess.run(model, feed_dict: { p => rand, q => rand }) end }
-  x.report("opencl                   :") { 100.times do sess2.run(model, feed_dict: { p => rand, q => rand }) end }
-  x.report("pure ruby single function:") { 100.times do sess.run(single_function_test, feed_dict: { p => rand, q => rand }) end }
-  x.report("opencl     singlefunction:") { 100.times do sess2.run(single_function_test, feed_dict: { p => rand, q => rand }) end }
-  x.report("pure ruby pow float:") { 100.times do sess.run(pow_f, feed_dict: { p => rand, q => rand }) end }
-  x.report("opencl pow float:") { 100.times do sess2.run(pow_f, feed_dict: { p => rand, q => rand }) end }
-  x.report("pure ruby pow int:") { 100.times do sess.run(pow_i, feed_dict: { p => rand, q => rand }) end }
-  x.report("opencl pow int:") { 100.times do sess2.run(pow_i, feed_dict: { p => rand, q => rand }) end }
-end

data/samples/rnn.rb

@@ -1,105 +0,0 @@
-# RNN sample
-#
-# Ruby port Example based on article by Erik Hallström
-# https://medium.com/@erikhallstrm/hello-world-rnn-83cd7105b767
-#
-#
-
-require "bundler/setup"
-require 'tensor_stream'
-
-tf = TensorStream
-
-num_epochs = 100
-total_series_length = 50000
-truncated_backprop_length = 15
-state_size = 4
-num_classes = 2
-echo_step = 3
-batch_size = 5
-num_batches = total_series_length / batch_size / truncated_backprop_length
-randomizer = TensorStream.random_uniform([total_series_length], minval: 0, maxval: 2)
-
-
-def generate_data(randomizer, total_series_length, batch_size, echo_step)
-  x = randomizer.eval
-  y = x.rotate(-echo_step)
-
-  y[echo_step] = 0
-
-  x = TensorStream::TensorShape.reshape(x, [batch_size, -1])  # The first index changing slowest, subseries as rows
-  y = TensorStream::TensorShape.reshape(y, [batch_size, -1])
-  [x, y]
-end
-
-batchX_placeholder = tf.placeholder(:float32, shape: [batch_size, truncated_backprop_length], name: 'batch_x')
-batchY_placeholder = tf.placeholder(:int32, shape: [batch_size, truncated_backprop_length], name: 'batch_y')
-
-init_state = tf.placeholder(:float32, shape: [batch_size, state_size], name: 'init_state')
-
-
-W = tf.variable(tf.random_uniform([state_size+1, state_size]), dtype: :float32, name: 'W')
-b = tf.variable(tf.zeros([state_size]), dtype: :float32, name: 'b')
-
-W2 = tf.variable(tf.random_uniform([state_size, num_classes]), dtype: :float32, name: 'W2')
-b2 = tf.variable(tf.zeros([num_classes]), dtype: :float32, name: 'b2')
-
-
-inputs_series = tf.unpack(batchX_placeholder, axis: 1)
-labels_series = tf.unpack(batchY_placeholder, axis: 1)
-
-current_state = init_state
-states_series = []
-
-inputs_series.each do |current_input|
-  current_input = tf.reshape(current_input, [batch_size, 1])
-  input_and_state_concatenated = tf.concat([current_input, current_state], 1)  # Increasing number of columns
-  next_state = tf.tanh(tf.matmul(input_and_state_concatenated, W) + b)  # Broadcasted addition
-  states_series << next_state
-  current_state = next_state
-end
-
-logits_series = states_series.collect do |state|
-  tf.matmul(state, W2) + b2
-end
-
-predictions_series = logits_series.collect do |logits|
-  tf.nn.softmax(logits)
-end
-
-losses = logits_series.zip(labels_series).collect do |logits, labels|
-  tf.nn.sparse_softmax_cross_entropy_with_logits(logits: logits, labels: labels)
-end
-total_loss = tf.reduce_mean(losses)
-
-train_step = TensorStream::Train::AdagradOptimizer.new(0.3).minimize(total_loss)
-
-puts "#{tf.get_default_graph.nodes.keys.size} nodes created"
-zeros_state = tf.zeros([batch_size, state_size]).eval
-tf.session do |sess|
-  sess.run(tf.global_variables_initializer)
-  (0..num_epochs).each do |epoch_idx|
-    x, y = generate_data(randomizer, total_series_length, batch_size, echo_step)
-    _current_state = zeros_state
-    print("New data, epoch", epoch_idx, "\n")
-    (0..num_batches - 1).each do |batch_idx|
-      start_idx = batch_idx * truncated_backprop_length
-      end_idx = start_idx + truncated_backprop_length
-
-      batchX = x.map { |x| x[start_idx...end_idx] }
-      batchY = y.map { |y| y[start_idx...end_idx] }
-
-      _total_loss, _train_step, _current_state, _predictions_series = sess.run(
-          [total_loss, train_step, current_state, predictions_series],
-          feed_dict: {
-              batchX_placeholder => batchX,
-              batchY_placeholder => batchY,
-              init_state => _current_state
-          })
-
-      if batch_idx%100 == 0
-          print("Step",batch_idx, " Loss ", _total_loss, "\n")
-      end
-    end
-  end
-end