tensor_stream 0.9.10 → 1.0.0.pre.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e57a53a50a03509858b23387c5b82c114168c519aba871f04b86ddda9d5ed58d
-  data.tar.gz: 7a1e662d373c57caa997e7c1d7031e7757576c93eddda016a3cc714608f88ef3
+  metadata.gz: db2ea87e941f738407781b7f63b7cf120d62a87bc1c950f6f272942fa5eed6a2
+  data.tar.gz: b81949fb1e4ed9bca63d9a7ef07f21ce634e4939b032f299cb96afb3016ad6bb
 SHA512:
-  metadata.gz: c284011b3fc7ff7bafeb82a994bffbe4963d0300fb771b5f16fa3bedbc5afeef1c4f44f55e8f9801f9b6410866b5b93fcddabdc5ce797931c599be57f6dda539
-  data.tar.gz: 8a83b49f4d7bde1612466a1db8348114a899058b5dc744041478649972005b59ce773b84714d0023761615b04f1966ae37afd0f1cc25ab3d4a9686be4c73ab6f
+  metadata.gz: fb5f081aac256b4d17222850727bbdd55ce327fd20f384d960c823abc0b7c6aa8f09888136df71e530af7bac835c57383cbe5cef88a959c55b02afb91bc21b13
+  data.tar.gz: 9dd9111eca29f8f3d3f99b94f92a2b8ffbdb2cad686cc9acc9eeda737b0e88483667072191dc77958b92948dd570015720ee2e410f6fdeb7afcfce90b1b561f5

data/README.md

@@ -365,34 +365,45 @@ File.write("model.pbtext", result.graph.as_graph_def)
 ## Performance notes
 
 Comparative performance with respect to other ruby libraries have not yet been performed. However it is
-notable that TruffleRuby and ruby-2.6.0-preview2 with the --jit flag performs considerably better with respect
+notable that TruffleRuby and ruby-2.6.0 performs considerably better with respect
 to previous versions of ruby(< 2.6)
 
-Benchmarks running samples/linear_regression.rb on an Intel(R) Core(TM) i5-6200U CPU @ 2.30GHz
+Benchmarks running samples/linear_regression.rb with tensor_stream 1.0.0 on an AMD(R) Ryzen(TM) 3 1300X CPU
 
-ruby 2.4
+
+ruby 2.5
 
 ```
 $ ruby -v
-ruby 2.4.0p0 (2016-12-24 revision 57164) [x86_64-linux]
+ruby 2.5.1p57 (2018-03-29 revision 63029) [x86_64-linux]
 $ ruby samples/linear_regression.rb
-495 seconds 10000 epochs
+296 seconds 3000 epochs
 ```
 
-ruby 2.6.0-preview2
+ruby 2.6.0
 
 ```
 $ ruby -v
-ruby 2.6.0preview2 (2018-05-31 trunk 63539) [x86_64-linux]
-$ ruby --jit samples/linear_regression.rb
-394 seconds 10000 epochs
+ruby 2.6.0p0 (2018-12-25 revision 66547) [x86_64-linux]
+$ ruby samples/linear_regression.rb
+232 seconds 10000 epochs
+
+ruby --jit samples/linear_regression.rb
+222 seconds 10000 epochs
 ```
 
 truffleruby
 ```
 $ ruby -v
-truffleruby 1.0.0-rc5, like ruby 2.4.4, GraalVM CE Native [x86_64-linux]
-219 seconds 10000 epochs
+truffleruby 1.0.0-rc10, like ruby 2.4.4, GraalVM CE Native [x86_64-linux]
+246 seconds 10000 epochs
+```
+
+jruby
+```
+$ ruby -v
+jruby 9.2.0.0 (2.5.0) 2018-05-24 81156a8 OpenJDK 64-Bit Server VM 25.191-b12 on 1.8.0_191-8u191-b12-0ubuntu0.18.04.1-b12 +jit [linux-x86_64]
+205 seconds 10000 epochs
 ```
 
 For training large networks that works on images, the opencl evaluator is the only way to go.

data/exe/model_utils

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "tensor_stream"
+require 'tensor_stream/utils/freezer'
+
+if ARGV[0].nil?
+  puts "source checkpoint folder not specified"
+  puts "usage: model_utils <checkpoint folder> <target yaml>"
+  puts "example: model_utils sample_model/ frozen.yml"
+  exit(1)
+end
+
+if ARGV[1].nil?
+  puts "dest YAML file for frozen model not specified"
+  puts "usage: model_utils <checkpoint folder> <target yaml>"
+  puts "example: model_utils sample_model/ frozen.yml"
+  exit(1)
+end
+
+sess = TensorStream.session
+freezer = TensorStream::Freezer.new
+freezer.convert(sess, ARGV[0], ARGV[1])
+exit(0)

data/lib/tensor_stream/evaluator/operation_helpers/array_ops_helper.rb

@@ -100,18 +100,18 @@ module TensorStream
     end
 
     # handle 2 tensor math operations
-    def vector_op(vector, vector2, op = ->(a, b) { a + b }, switch = false, safe = true)
+    def vector_op(vector, vector2, switch = false, safe = true, &block)
       if get_rank(vector) < get_rank(vector2) # upgrade rank of A
         duplicated = Array.new(vector2.size) do
           vector
         end
-        return vector_op(duplicated, vector2, op, switch)
+        return vector_op(duplicated, vector2, switch, &block)
       end
 
-      return op.call(vector, vector2) unless vector.is_a?(Array)
+      return yield(vector, vector2) unless vector.is_a?(Array)
 
       vector.each_with_index.collect do |input, index|
-        next vector_op(input, vector2, op, switch) if input.is_a?(Array) && get_rank(vector) > get_rank(vector2)
+        next vector_op(input, vector2, switch, &block) if input.is_a?(Array) && get_rank(vector) > get_rank(vector2)
 
         if safe && vector2.is_a?(Array)
           next nil if vector2.size != 1 && index >= vector2.size
@@ -129,9 +129,9 @@ module TensorStream
             end
 
         if input.is_a?(Array)
-          vector_op(input, z, op, switch)
+          vector_op(input, z, switch, &block)
         else
-          switch ? op.call(z, input) : op.call(input, z)
+          switch ? yield(z, input) : yield(input, z)
         end
       end.compact
     end
@@ -165,12 +165,12 @@ module TensorStream
       end
     end
 
-    def process_function_op(a, op)
+    def process_function_op(a, &block)
       # ruby scalar
       if (a.is_a?(Tensor) && a.shape.rank > 0) || a.is_a?(Array)
-        vector_op(a, 0, op)
+        vector_op(a, 0, &block)
       else
-        op.call(a, 0)
+        yield a, 0
       end
     end
 
@@ -264,11 +264,11 @@ module TensorStream
       [new_arr, new_shape]
     end
 
-    def reduce_axis(current_axis, axis, val, keep_dims, f)
+    def reduce_axis(current_axis, axis, val, keep_dims, &block)
       return val unless val.is_a?(Array)
 
       r = val.collect do |v|
-        reduce_axis(current_axis + 1, axis, v, keep_dims, f)
+        reduce_axis(current_axis + 1, axis, v, keep_dims, &block)
       end
 
       should_reduce_axis = axis.nil? || (axis.is_a?(Array) && axis.include?(current_axis)) || (current_axis == axis)
@@ -276,9 +276,13 @@ module TensorStream
       if should_reduce_axis
         reduced_val = r[0]
         if r.size > 1
-          reduced_val = f.call(r[0..val.size])
+          if block_given?
+            reduced_val = yield(r[0..val.size])
+          else
+            reduced_val = r[0..val.size].reduce(:+)
+          end
         elsif r.empty?
-          reduced_val = f.call(nil)
+          reduced_val = yield(nil)
         end
         keep_dims ? [reduced_val] : reduced_val
       else
@@ -286,18 +290,10 @@ module TensorStream
       end
     end
 
-    def reduce(val, axis, keep_dims, func = nil)
+    def reduce(val, axis, keep_dims, &block)
       rank = get_rank(val)
       return val if axis && axis.is_a?(Array) && axis.empty?
 
-      func = lambda do |arr|
-        reduced_val = arr[0]
-        arr[1..arr.size].each do |v|
-          reduced_val = vector_op(reduced_val, v, ->(t, u) { t + u })
-        end
-        reduced_val
-      end if func.nil?
-
       axis = if axis.nil?
                nil
              elsif axis.is_a?(Array)
@@ -308,7 +304,7 @@ module TensorStream
                axis < 0 ? rank - axis.abs : axis
              end
 
-      reduce_axis(0, axis, val, keep_dims, func)
+      reduce_axis(0, axis, val, keep_dims, &block)
     end
 
     def arr_pad(arr, paddings, data_type = :float32, rank = 0)

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

@@ -335,7 +335,7 @@ module TensorStream
 
         register_op %i[select where] do |context, tensor, inputs|
           pred = inputs[0]
-          call_3way_vector_op(pred, inputs[1], inputs[2], context, ->(t, u, v) { t ? u : v })
+          call_3way_vector_op(pred, inputs[1], inputs[2], context) { |t, u, v| t ? u : v }
         end
 
         register_op :shape do |_context, tensor, inputs|

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

@@ -3,7 +3,7 @@ module TensorStream
     def CheckOps.included(klass)
       klass.class_eval do
         register_op :assert_equal do |context, tensor, inputs|
-          result = call_vector_op(tensor, :equal, inputs[0], inputs[1], context, ->(t, u) { t == u })
+          result = call_vector_op(tensor, :equal, inputs[0], inputs[1], context) { |t, u| t == u }
 
           result = result.is_a?(Array) ? result.flatten.uniq : [result]
           prefix = tensor.options[:message] || ""

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

@@ -3,24 +3,24 @@ module TensorStream
     def MathOps.included(klass)
       klass.class_eval do
         register_op :tanh, no_eval: true do |context, _tensor, inputs|
-          call_op(inputs[0], context, ->(t, _b) { Math.tanh(t) })
+          call_op(inputs[0], context) { |t, _b| Math.tanh(t) }
         end
 
         register_op :tan, no_eval: true do |context, tensor, inputs|
-          call_op(inputs[0], context, ->(t, _b) { Math.tan(t) })
+          call_op(inputs[0], context) { |t, _b| Math.tan(t) } 
         end
 
         register_op :atan, no_eval: true do |context, _tensor, inputs|
-          call_op(inputs[0], context, ->(t, _b) { Math.atan(t) })
+          call_op(inputs[0], context) { |t, _b| Math.atan(t) }
         end
 
         register_op :sin, no_eval: true do |context, _tensor, inputs|
-          call_op(inputs[0], context, ->(t, _b) { Math.sin(t) })
+          call_op(inputs[0], context) { |t, _b| Math.sin(t) }
         end
 
         register_op :add, no_eval: true do |context, tensor, inputs|
           a, b = inputs
-          call_vector_op(tensor, :add, a, b, context, ->(t, u) { t + u })
+          call_vector_op(tensor, :add, a, b, context) { |t, u|  t + u }
         end
 
         register_op :add_n, no_eval: true do |context, tensor, inputs|
@@ -31,7 +31,7 @@ module TensorStream
             a = inputs.pop
             until inputs.empty?
               b = inputs.pop
-              a = call_vector_op(tensor, :add, a, b, context, ->(t, u) { t + u })
+              a = call_vector_op(tensor, :add, a, b, context) { |t, u| t + u }
             end
             a
           end
@@ -39,100 +39,100 @@ module TensorStream
 
         register_op :sub, no_eval: true do |context, tensor, inputs|
           a, b = inputs
-          call_vector_op(tensor, :sub, a, b, context, ->(t, u) { t - u })
+          call_vector_op(tensor, :sub, a, b, context) { |t, u| t - u }
         end
 
         register_op %i[floor_mod mod], no_eval: true do |context, tensor, inputs|
           a, b = inputs
-          call_vector_op(tensor, :mod, a, b, context, ->(t, u) { t % u })
+          call_vector_op(tensor, :mod, a, b, context) { |t, u| t % u }
         end
 
         register_op %i[floor_div], no_eval: true do |context, tensor, inputs|
           a, b = inputs
           if fp_type?(tensor.data_type)
-            call_vector_op(tensor, :div, a, b, context, ->(t, u) { (t / u).to_i.to_f })
+            call_vector_op(tensor, :div, a, b, context) { |t, u| (t / u).to_i.to_f }
           else
-            call_vector_op(tensor, :div, a, b, context, ->(t, u) { t / u })
+            call_vector_op(tensor, :div, a, b, context) { |t, u| t / u }
           end
         end
 
         register_op :mul, no_eval: true do |context, tensor, inputs|
           a, b = inputs
-          call_vector_op(tensor, :mul, a, b, context, ->(t, u) { t * u })
+          call_vector_op(tensor, :mul, a, b, context)  { |t, u| t * u }
         end
 
         register_op :pow, no_eval: true do |context, tensor, inputs|
           a, b = inputs
-          call_vector_op(tensor, :pow, a, b, context, ->(t, u) { t**u })
+          call_vector_op(tensor, :pow, a, b, context) { |t, u| t**u }
         end
 
         register_op :squared_difference, no_eval: true do |context, tensor, inputs|
           a, b = inputs
-          call_vector_op(tensor, :squared_difference, a, b, context, ->(t, u) { (t - u) * (t - u) })
+          call_vector_op(tensor, :squared_difference, a, b, context) { |t, u| (t - u) * (t - u) }
         end
 
         register_op :round, no_eval: true do |context, _tensor, inputs|
-          call_op(inputs[0], context, ->(t, _b) { t.round })
+          call_op(inputs[0], context) { |t, _b|  t.round }
         end
 
         register_op :abs, no_eval: true do |context, _tensor, inputs|
-          call_op(inputs[0], context, ->(t, _b) { t.abs })
+          call_op(inputs[0], context) { |t, _b| t.abs }
         end
 
         register_op :asin, no_eval: true do |context, _tensor, inputs|
-          call_op(inputs[0], context, ->(t, _b) { Math.asin(t) })
+          call_op(inputs[0], context) { |t, _b| Math.asin(t) }
         end
 
         register_op :acos, no_eval: true do |context, _tensor, inputs|
-          call_op(inputs[0], context, ->(t, _b) { Math.acos(t) })
+          call_op(inputs[0], context) { |t, _b| Math.acos(t) }
         end
 
         register_op :cos, no_eval: true do |context, tensor, inputs|
-          call_op(inputs[0], context, ->(t, _b) { Math.cos(t) })
+          call_op(inputs[0], context) { |t, _b| Math.cos(t) }
         end
 
         register_op :log1p, no_eval: true do |context, _tensor, inputs|
-          call_op(inputs[0], context, ->(t, _b) { Math.log(1 + t) })
+          call_op(inputs[0], context) { |t, _b| Math.log(1 + t) }
         end
 
         register_op :log, no_eval: true do |context, _tensor, inputs|
-          call_op(inputs[0], context, ->(t, _b) { t < 0 ? Float::NAN : Math.log(t) })
+          call_op(inputs[0], context) { |t, _b| t < 0 ? Float::NAN : Math.log(t) }
         end
 
         register_op :exp, no_eval: true do |context, _tensor, inputs|
-          call_op(inputs[0], context, ->(t, _b) { Math.exp(t) })
+          call_op(inputs[0], context) { |t, _b| Math.exp(t) }
         end
 
         register_op :sigmoid, no_eval: true do |context, _tensor, inputs|
-          call_op(inputs[0], context, ->(t, _b) { sigmoid(t) })
+          call_op(inputs[0], context) { |t, _b| sigmoid(t) }
         end
 
         register_op :sqrt, no_eval: true do |context, _tensor, inputs|
-          call_op(inputs[0], context, ->(t, _b) { Math.sqrt(t) })
+          call_op(inputs[0], context) { |t, _b| Math.sqrt(t) }
         end
 
         register_op :floor, no_eval: true do |context, _tensor, inputs|
-          call_op(inputs[0], context, ->(t, _b) { t.floor })
+          call_op(inputs[0], context) { |t, _b| t.floor }
         end
 
         register_op :ceil, no_eval: true do |context, _tensor, inputs|
-          call_op(inputs[0], context, ->(t, _b) { t.ceil })
+          call_op(inputs[0], context) { |t, _b| t.ceil }
         end
 
         register_op :square, no_eval: true do |context, _tensor, inputs|
-          call_op(inputs[0], context, ->(t, _b) { t * t })
+          call_op(inputs[0], context) { |t, _b| t * t }
         end
 
         register_op :reciprocal, no_eval: true do |context, _tensor, inputs|
-          call_op(inputs[0], context, ->(t, _b) { 1 / t })
+          call_op(inputs[0], context) { |t, _b| 1 / t }
         end
 
         register_op %i[neg negate], no_eval: true do |context, tensor, inputs|
-          call_vector_op(tensor, :negate, inputs[0], nil, context, ->(t, _u) { -t })
+          call_vector_op(tensor, :negate, inputs[0], nil, context) { |t, _u| -t }
         end
 
         register_op :tanh_grad, no_eval: true do |context, _tensor, inputs|
-          call_op(inputs[0], context, ->(t, _b) { 1 - Math.tanh(t) * Math.tanh(t) })
+          call_op(inputs[0], context) { |t, _b| 1 - Math.tanh(t) * Math.tanh(t) }
         end
 
         register_op(%i[argmax arg_max]) do |_context, tensor, inputs|
@@ -169,70 +169,70 @@ module TensorStream
           c = fp_type?(tensor.data_type) ? 1.0 : 1
           reverse_option = tensor.options[:reverse]
           exclusive = tensor.options[:exclusive]
-          func = lambda do |arr|
-            return c if arr.nil?
-
-            count = arr.size
-            arr = arr.reverse if reverse_option
-            arr = [1] + arr if exclusive
 
-            start_prod = arr[0]
-            mapped = arr[1...count].map do |v|
-              start_prod = vector_op(start_prod, v, ->(a, b) { a * b })
+          reduction(context, tensor) do |arr|
+            if arr.nil?
+              c
+            else
+              count = arr.size
+              arr = arr.reverse if reverse_option
+              arr = [1] + arr if exclusive
+
+              start_prod = arr[0]
+              mapped = arr[1...count].map do |v|
+                start_prod = vector_op(start_prod, v) { |a, b| a * b }
+              end
+
+              arr = [arr[0]] + mapped
+              reverse_option ? arr.reverse : arr
             end
-
-            arr = [arr[0]] + mapped
-            reverse_option ? arr.reverse : arr
           end
-          reduction(context, tensor, func)
         end
 
         register_op :sum, noop: true do |context, tensor, _inputs|
-          func = lambda do |arr|
+
+          reduction(context, tensor) do |arr|
             reduced_val = arr[0]
             arr[1..arr.size].each do |v|
-              reduced_val = vector_op(reduced_val, v, ->(t, u) { t + u })
+              reduced_val = vector_op(reduced_val, v) { |t, u| t + u }
             end
             reduced_val
           end
-          reduction(context, tensor, func)
         end
 
         register_op :prod, noop: true do |context, tensor, _inputs|
           c = fp_type?(tensor.data_type) ? 1.0 : 1
-
-          func = lambda do |arr|
-            return c if arr.nil?
-
-            reduced_val = arr[0]
-            arr[1..arr.size].each do |v|
-              reduced_val = vector_op(reduced_val, v, ->(a, b) { a * b })
+          reduction(context, tensor) do |arr|
+            if arr.nil?
+              c
+            else
+              reduced_val = arr[0]
+              arr[1..arr.size].each do |v|
+                reduced_val = vector_op(reduced_val, v) { |a, b| a * b }
+              end
+              reduced_val
             end
-            reduced_val
           end
-
-          reduction(context, tensor, func)
         end
 
         register_op :sigmoid_grad, no_eval: true do |context, tensor, inputs|
           a, b = inputs
-          call_vector_op(tensor, :sigmoid_grad, a, b, context, ->(t, u) { u * sigmoid(t) * (1 - sigmoid(t)) })
+          call_vector_op(tensor, :sigmoid_grad, a, b, context) { |t, u| u * sigmoid(t) * (1 - sigmoid(t)) }
         end
 
         register_op :mean, noop: true do |context, tensor, _inputs|
           c = fp_type?(tensor.data_type) ? 0.0 : 0
-          func = lambda do |arr|
+
+          reduction(context, tensor) do |arr|
             return c if arr.nil?
 
             reduced_val = arr[0]
             arr[1..arr.size].each do |v|
-              reduced_val = vector_op(reduced_val, v, ->(a, b) { a + b })
+              reduced_val = vector_op(reduced_val, v) { |a, b| a + b }
             end
 
-            vector_op(reduced_val, nil, ->(a, _b) { a / arr.size })
+            vector_op(reduced_val, nil) { |a, _b| a / arr.size }
           end
-
-          reduction(context, tensor, func)
         end
 
         register_op :mat_mul do |_context, tensor, inputs|
@@ -252,19 +252,19 @@ module TensorStream
         end
 
         register_op %i[max maximum], noop: true do |context, tensor, inputs|
-          call_vector_op(tensor, :max, inputs[0], inputs[1], context, ->(t, u) { [t, u].max })
+          call_vector_op(tensor, :max, inputs[0], inputs[1], context) { |t, u| [t, u].max }
         end
 
         register_op %i[min minimum], noop: true do |context, tensor, inputs|
-          call_vector_op(tensor, :min, inputs[0], inputs[1], context, ->(t, u) { [t, u].min })
+          call_vector_op(tensor, :min, inputs[0], inputs[1], context) { |t, u| [t, u].min }
         end
 
-        def reduction(child_context, tensor, func)
+        def reduction(child_context, tensor, &block)
           val = global_eval(tensor, tensor.inputs[0], child_context)
           axis = global_eval(tensor, tensor.inputs[1], child_context)
           keep_dims = global_eval(tensor, tensor.options[:keepdims], child_context)
 
-          reduce(val, axis, keep_dims, func)
+          reduce(val, axis, keep_dims, &block)
         end
       end
     end

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

@@ -7,7 +7,7 @@ module TensorStream
           target_var, learning_rate, delta = inputs
           assign = tensor.inputs[0] || tensor
 
-          assign.container = process_vector_math_op(tensor, target_var, delta, context, ->(t, u) { t - u * learning_rate })
+          assign.container = process_vector_math_op(tensor, target_var, delta, context) { |t, u| t - u * learning_rate }
           assign.container
         end
 
@@ -111,7 +111,7 @@ module TensorStream
             end
             reshaped_losses = TensorShape.reshape(losses.flatten, input_shape)
             reshaped_backprops = TensorShape.reshape(backprobs.flatten, input_shape)
-            reshaped_losses = reduce(reshaped_losses, rank, false)
+            reshaped_losses = reduce(reshaped_losses, rank, false) { |a| a.reduce(:+) }
             TensorStream::Evaluator::OutputGroup.new([reshaped_losses, reshaped_backprops], [tensor.inputs[0].data_type, tensor.inputs[0].data_type])
           end
         end
@@ -210,7 +210,7 @@ module TensorStream
         end
 
         register_op :relu6 do |context, tensor, inputs|
-          call_vector_op(tensor, :relu6, inputs[0], inputs[1], context, ->(t, u) { [[t, 0].max, 6].min })
+          call_vector_op(tensor, :relu6, inputs[0], inputs[1], context) { |t, u| [[t, 0].max, 6].min }
         end
 
         register_op :conv2d do |_context, tensor, inputs|

data/lib/tensor_stream/evaluator/ruby_evaluator.rb

@@ -102,11 +102,11 @@ module TensorStream
       end
 
       register_op(:cast) do |context, tensor, inputs|
-        call_op(inputs[0], context, ->(t, _b) { Tensor.cast_dtype(t, tensor.data_type) })
+        call_op(inputs[0], context)  { |t, _b| Tensor.cast_dtype(t, tensor.data_type) }
       end
 
       register_op(:sign) do |context, tensor, inputs|
-        func = lambda { |x, _b|
+        call_op(inputs[0], context) do |x, _b|
           if x.zero? || (x.is_a?(Float) && x.nan?)
             0
           elsif x < 0
@@ -116,21 +116,19 @@ module TensorStream
           else
             raise 'assert: cannot be here'
           end
-        }
-
-        call_op(inputs[0], context, func)
+        end
       end
 
       register_op(:logical_and) do |context, tensor, inputs|
-        call_vector_op(tensor, :logical_and, inputs[0], inputs[1], context, ->(t, u) { t && u })
+        call_vector_op(tensor, :logical_and, inputs[0], inputs[1], context) { |t, u| t && u }
       end
 
       register_op(:equal) do |context, tensor, inputs|
-        call_vector_op(tensor, :equal, inputs[0], inputs[1], context, ->(t, u) { t == u })
+        call_vector_op(tensor, :equal, inputs[0], inputs[1], context) { |t, u| t == u }
       end
 
       register_op(:not_equal) do |context, tensor, inputs|
-        call_vector_op(tensor, :not_equal, inputs[0], inputs[1], context, ->(t, u) { t != u })
+        call_vector_op(tensor, :not_equal, inputs[0], inputs[1], context) { |t, u| t != u }
       end
 
       register_op :placeholder, no_eval: true do |context, tensor, _inputs|
@@ -175,35 +173,35 @@ module TensorStream
       register_op :assign_add, noop: true do |context, tensor, _inputs|
         assign = tensor.inputs[0] || tensor
 
-        assign.container = process_vector_math_op(tensor, tensor.inputs[0], tensor.inputs[1], context, ->(t, u) { t + u })
+        assign.container = process_vector_math_op(tensor, tensor.inputs[0], tensor.inputs[1], context) { |t, u| t + u }
         assign.container
       end
 
       register_op :assign_sub, noop: true do |context, tensor, _inputs|
         assign = tensor.inputs[0] || tensor
 
-        assign.container = process_vector_math_op(tensor, tensor.inputs[0], tensor.inputs[1], context, ->(t, u) { t - u })
+        assign.container = process_vector_math_op(tensor, tensor.inputs[0], tensor.inputs[1], context) { |t, u| t - u }
         assign.container
       end
 
       register_op :less do |context, tensor, inputs|
         a, b = inputs
-        call_vector_op(tensor, :less, a, b, context, ->(t, u) { t < u })
+        call_vector_op(tensor, :less, a, b, context) { |t, u| t < u }
       end
 
       register_op :greater do |context, tensor, inputs|
         a, b = inputs
-        call_vector_op(tensor, :greater, a, b, context, ->(t, u) { t > u })
+        call_vector_op(tensor, :greater, a, b, context) { |t, u| t > u }
       end
 
       register_op :greater_equal do |context, tensor, inputs|
         a, b = inputs
-        call_vector_op(tensor, :greater_equal, a, b, context, ->(t, u) { t >= u })
+        call_vector_op(tensor, :greater_equal, a, b, context) { |t, u| t >= u }
       end
 
       register_op :less_equal do |context, tensor, inputs|
         a, b = inputs
-        call_vector_op(tensor, :greater_equal, a, b, context, ->(t, u) { t <= u })
+        call_vector_op(tensor, :greater_equal, a, b, context) { |t, u| t <= u }
       end
 
       register_op :broadcast_transform do |_context, _tensor, inputs|
@@ -220,7 +218,7 @@ module TensorStream
       end
 
       register_op %i[div real_div], noop: true do |context, tensor, inputs|
-        process_vector_math_op(tensor, inputs[0], inputs[1], context, ->(t, u) { t / u })
+        process_vector_math_op(tensor, inputs[0], inputs[1], context) { |t, u| t / u }
       end
 
       register_op :broadcast_gradient_args do |_context, tensor, inputs|
@@ -241,30 +239,46 @@ module TensorStream
         outputfile = inputs[0]
         inputs = tensor.inputs.dup
 
-        basename = File.basename(outputfile)
-        path = File.dirname(outputfile)
-
-        new_filename = File.join(path, [basename, gs].compact.join('-'))
-
         inputs.shift
         variables = {}
         inputs.each do |savable|
-          variables[savable.name] = TensorStream::Packer.pack(savable.read_value, savable.data_type)
+          val = savable.container
+          packed_data = Zlib::Deflate.deflate(TensorStream::Packer.pack(val, savable.data_type))
+          variables[savable.name] = {
+            'shape' => shape_eval(val),
+            'data' => Base64.strict_encode64(packed_data)
+          }
         end
-        File.write(new_filename, variables.to_yaml)
+
+        File.write(outputfile, { 'variables' => variables }.to_yaml)
+        nil
       end
 
-      register_op :restore_v2 do |context, tensor, inputs|
-        # prefix, tensor_names, shape_and_slices = inputs[0..3]
+      register_op :restore_ts do |_context, tensor, inputs|
+        inputs = inputs.dup
+        filename = inputs.shift
+        tensor_names = inputs
+
+        input_dump = YAML.safe_load(File.read(filename), [Symbol])
+        vars = tensor.graph.get_collection(GraphKeys::GLOBAL_VARIABLES)
+
+        vars.select! { |v| input_dump['variables'].key?(v.name) && tensor_names.include?(v.name) }
+        vars.each do |variable|
+          data = TensorStream::Packer.unpack(Zlib::Inflate.inflate(Base64.decode64(input_dump['variables'][variable.name]['data'])), variable.data_type)
+          shape = input_dump['variables'][variable.name]['shape']
+          variable.buffer = nil
+          variable.value = TensorShape.reshape(data, shape)
+        end
+
+        nil
       end
 
       register_op :check_numerics do |context, tensor, inputs|
         message = tensor.options[:message]
-        f = lambda { |t, _b|
+        call_op(inputs[0], context) do |t, _b|
           raise TensorStream::InvalidArgumentError, "#{message} Invalid argument" if t.nan? || t.infinite?
           t
-        }
-        call_op(inputs[0], context, f)
+        end
       end
 
       def eval_operation(tensor, child_context)
@@ -342,18 +356,18 @@ module TensorStream
         end
       end
 
-      def call_op(a, child_context, func)
+      def call_op(a, child_context, &block)
         a = complete_eval(a, child_context)
-        process_function_op(a, func)
+        process_function_op(a, &block)
       end
 
-      def call_vector_op(tensor, op, a, b, child_context, func)
-        process_vector_math_op(tensor, a, b, child_context, func)
+      def call_vector_op(tensor, op, a, b, child_context, &block)
+        process_vector_math_op(tensor, a, b, child_context, &block)
       rescue FullEvalNotPossible
         TensorStream.send(op.to_sym, a, b)
       end
 
-      def process_vector_math_op(tensor, a, b,  child_context, op)
+      def process_vector_math_op(tensor, a, b,  child_context, &block)
         eval_a = global_eval(tensor, a, child_context) unless a.nil?
         eval_b = global_eval(tensor, b, child_context) unless b.nil?
 
@@ -361,7 +375,7 @@ module TensorStream
 
         # ruby scalar
         eval_a, eval_b = broadcast(eval_a, eval_b)
-        vector_op(eval_a, eval_b, op)
+        vector_op(eval_a, eval_b, &block)
         # if get_rank(eval_a).zero?
         #   if get_rank(eval_b).zero?
         #     op.call(eval_a, eval_b)
@@ -411,16 +425,16 @@ module TensorStream
       end
 
       # handle 3 tensor math operations
-      def call_3way_vector_op(v_a, v_b, v_c, child_context, op = ->(a, b, c) { a + b + c })
-        return op.call(v_a, v_b, v_c) unless v_a.is_a?(Array)
+      def call_3way_vector_op(v_a, v_b, v_c, child_context, &block)
+        return yield(v_a, v_b, v_c) unless v_a.is_a?(Array)
 
         v_a.each_with_index.collect do |v1, index|
           v2 = v_b[index]
           v3 = v_c.is_a?(Array) ? v_c[index] : v_c
           if v1.is_a?(Array)
-            call_3way_vector_op(v1, v2, v3, child_context, op)
+            call_3way_vector_op(v1, v2, v3, child_context, &block)
           else
-            op.call(v1, v2, v3)
+            yield(v1, v2, v3)
           end
         end
       end

data/lib/tensor_stream/graph.rb

@@ -118,6 +118,10 @@ module TensorStream
       get_node(name)
     end
 
+    def [](name)
+      get_node(name)
+    end
+
     def add_node!(name, node)
       @nodes[name] = node
       node
@@ -219,6 +223,7 @@ module TensorStream
       @placeholder_counter += 1
 
       return '' if @placeholder_counter == 1
+
       "_#{@placeholder_counter}"
     end
 

data/lib/tensor_stream/graph_deserializers/yaml_loader.rb

@@ -1,15 +1,36 @@
 module TensorStream
+  ##
+  # Class for deserialization from a YAML file
   class YamlLoader
     def initialize(graph = nil)
       @graph = graph || TensorStream.get_default_graph
     end
 
+    ##
+    # Loads a model Yaml file and builds the model from it
+    #
+    # Args:
+    # filename: String - Location of Yaml file
+    #
+    # Returns: Graph where model is restored to
+    def load_from_file(filename)
+      load_from_string(File.read(filename))
+    end
+
+    ##
+    # Loads a model Yaml file and builds the model from it
+    #
+    # Args:
+    # buffer: String - String in Yaml format of the model
+    #
+    # Returns: Graph where model is restored to
     def load_from_string(buffer)
-      serialized_ops = YAML.safe_load(buffer, [Symbol])
+      serialized_ops = YAML.safe_load(buffer, [Symbol], [], true)
       serialized_ops.each do |op_def|
         inputs = op_def[:inputs].map { |i| @graph.get_tensor_by_name(i) }
         options = {}
 
+        new_var = nil
         if op_def.dig(:attrs, :container)
           new_var = Variable.new(op_def.dig(:attrs, :data_type))
           var_shape = op_def.dig(:attrs, :container, :shape)
@@ -30,9 +51,11 @@ module TensorStream
         new_op.data_type = new_op.set_data_type(op_def.dig(:attrs, :data_type))
         new_op.is_const = new_op.infer_const
         new_op.given_name = new_op.name
+        new_var.op = new_op if new_var
 
         @graph.add_node(new_op)
       end
+      @graph
     end
   end
 end

data/lib/tensor_stream/graph_serializers/pbtext.rb

@@ -91,7 +91,6 @@ module TensorStream
         @lines << "#{spaces}}"
       when 'TensorStream::Variable'
       else
-        binding.pry
         raise "unknown type #{val.class}"
       end
     end

data/lib/tensor_stream/monkey_patches/op_patch.rb

@@ -0,0 +1,68 @@
+module TensorStream
+  module OpPatch
+    def self.included(klass)
+      ops = if klass == Array
+              {:+ => 'add', :- => 'sub', :* => 'mul'}
+            else
+              {:+ => 'add', :- => 'sub', :/ => 'div', :% => 'mod', :* => 'mul', :** => 'pow' }
+            end
+
+      ops.each do |m, name|
+        klass.send(:alias_method, :"_tensor_stream_#{name}_orig", m)
+        klass.send(:remove_method, m)
+      end
+    end
+
+    def +(other)
+      if other.is_a?(TensorStream::Tensor)
+        TensorStream.convert_to_tensor(self, dtype: other.data_type) + other
+      else
+        _tensor_stream_add_orig(other)
+      end
+    end
+
+    def -(other)
+      if other.is_a?(TensorStream::Tensor)
+        TensorStream.convert_to_tensor(self, dtype: other.data_type) - other
+      else
+        _tensor_stream_sub_orig(other)
+      end
+    end
+
+    def *(other)
+      if other.is_a?(TensorStream::Tensor)
+        TensorStream.convert_to_tensor(self, dtype: other.data_type) * other
+      else
+        _tensor_stream_mul_orig(other)
+      end
+    end
+
+    def /(other)
+      if other.is_a?(TensorStream::Tensor)
+        TensorStream.convert_to_tensor(self, dtype: other.data_type) * other
+      else
+        _tensor_stream_div_orig(other)
+      end
+    end
+
+    def %(other)
+      if other.is_a?(TensorStream::Tensor)
+        TensorStream.convert_to_tensor(self, dtype: other.data_type) % other
+      else
+        _tensor_stream_mod_orig(other)
+      end
+    end
+
+    def **(other)
+      if other.is_a?(TensorStream::Tensor)
+        TensorStream.convert_to_tensor(self, dtype: other.data_type)**other
+      else
+        _tensor_stream_pow_orig(other)
+      end
+    end
+  end
+end
+
+Integer.include TensorStream::OpPatch
+Float.include TensorStream::OpPatch
+Array.include TensorStream::OpPatch

data/lib/tensor_stream/monkey_patches/patch.rb

@@ -2,19 +2,6 @@
 module TensorStream
   # various monkey patches to FixNum types
   module MonkeyPatch
-    def self.included(klass)
-      ops = if klass == Array
-              {:+ => 'add', :- => 'sub', :* => 'mul'}
-            else
-              {:+ => 'add', :- => 'sub', :/ => 'div', :% => 'mod', :* => 'mul', :** => 'pow' }
-            end
-
-      ops.each do |m, name|
-        klass.send(:alias_method, :"_tensor_stream_#{name}_orig", m)
-        klass.send(:remove_method, m)
-      end
-    end
-
     def shape
       TensorStream.shape_eval(self)
     end
@@ -22,53 +9,5 @@ module TensorStream
     def t(name = nil, dtype: nil)
       TensorStream.convert_to_tensor(self, name: name, dtype: dtype)
     end
-
-    def +(other)
-      if other.is_a?(TensorStream::Tensor)
-        TensorStream.convert_to_tensor(self, dtype: other.data_type) + other
-      else
-        _tensor_stream_add_orig(other)
-      end
-    end
-
-    def -(other)
-      if other.is_a?(TensorStream::Tensor)
-        TensorStream.convert_to_tensor(self, dtype: other.data_type) - other
-      else
-        _tensor_stream_sub_orig(other)
-      end
-    end
-
-    def *(other)
-      if other.is_a?(TensorStream::Tensor)
-        TensorStream.convert_to_tensor(self, dtype: other.data_type) * other
-      else
-        _tensor_stream_mul_orig(other)
-      end
-    end
-
-    def /(other)
-      if other.is_a?(TensorStream::Tensor)
-        TensorStream.convert_to_tensor(self, dtype: other.data_type) * other
-      else
-        _tensor_stream_div_orig(other)
-      end
-    end
-
-    def %(other)
-      if other.is_a?(TensorStream::Tensor)
-        TensorStream.convert_to_tensor(self, dtype: other.data_type) % other
-      else
-        _tensor_stream_mod_orig(other)
-      end
-    end
-
-    def **(other)
-      if other.is_a?(TensorStream::Tensor)
-        TensorStream.convert_to_tensor(self, dtype: other.data_type)**other
-      else
-        _tensor_stream_pow_orig(other)
-      end
-    end
   end
 end

data/lib/tensor_stream/ops.rb

@@ -137,7 +137,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).op }
       else
         res = _op(:shape_n, *inputs, out_type: out_type, name: name)
         Array.new(inputs.size) do |index|

data/lib/tensor_stream/profile/report_tool.rb

@@ -5,13 +5,13 @@ module TensorStream
     def self.profile_for(session, order_by: :slowest)
       context = session.last_session_context
       eval_times = context[:profile][:operations].map do |name, profile|
-        [name, profile[:eval_time], profile[:shape], profile[:tensor].source]
+        [name, profile[:op], profile[:eval_time], profile[:shape]]
       end
 
       if order_by == :slowest
-        eval_times.sort_by { |a| a[1] }.reverse!
+        eval_times.sort_by { |a| a[2] }.reverse!
       else
-        eval_times.sort_by { |a| a[1] }
+        eval_times.sort_by { |a| a[2] }
       end
     end
   end

data/lib/tensor_stream/session.rb

@@ -51,7 +51,8 @@ module TensorStream
 
       context = {
         _cache: @session_cache,
-        _options: options.merge(@evaluator_options)
+        _options: options.merge(@evaluator_options),
+        profile: { step: 0, operations: {} },
       }
 
       # scan for placeholders and assign value
@@ -62,18 +63,17 @@ module TensorStream
           elsif k.is_a?(String)
             target_graph = args[0].graph
             node = target_graph.get_node(k)
-            if node.operation == :placeholder
-              context[k.to_sym] = options[:feed_dict][k]
-            else
-              raise "Cannot find placeholder with the name of #{k}"
-            end
+            raise "Cannot find placeholder with the name of #{k}" if node.operation != :placeholder
+
+            context[k.to_sym] = options[:feed_dict][k]
+          elsif k.is_a?(Operation) && k.operation == :placeholder
+            context[k.name.to_sym] = options[:feed_dict][k]
           else
             raise "Invalid placeholder type passed key must be a string or a placeholder type"
           end
         end
       end
 
-
       args.each { |t| prepare_evaluators(t, context) }
       @last_session_context = context
 
@@ -119,6 +119,7 @@ module TensorStream
       graph = tensor.graph
       graph.nodes.select { |k, v| selector.call(k, v) }.collect do |k, node|
         next unless @last_session_context[node.name]
+
         "#{k} #{node.to_math(true, 1)} = #{@last_session_context[node.name]}"
       end.compact
     end

data/lib/tensor_stream/train/saver.rb

@@ -7,6 +7,16 @@ module TensorStream
     class Saver
       include TensorStream::OpHelper
 
+      def initialize
+        graph = TensorStream::Graph.get_default_graph
+        vars = graph.get_collection(GraphKeys::GLOBAL_VARIABLES)
+
+        @filename = graph['ts_filename'] || TensorStream.placeholder(:string, name: 'ts_filename', shape: [])
+
+        @save_op = _op(:save_ts, @filename, *vars)
+        @restore_op = _op(:restore_ts, @filename, *vars.map(&:name))
+      end
+
       def save(session, outputdir, global_step: nil,
                latest_filename: nil,
                meta_graph_suffix: 'meta',
@@ -19,25 +29,13 @@ module TensorStream
         variables = {}
 
         gs = eval_global_step(session, global_step)
-        output_dump = {
-          'variables' => variables,
-          'global_step' => gs
-        }
-
-        vars.each do |variable|
-          val = variable.read_value
-          packed_data = Zlib::Deflate.deflate(TensorStream::Packer.pack(val, variable.data_type))
-          variables[variable.name] = {
-            'shape' => shape_eval(val),
-            'data' => Base64.strict_encode64(packed_data)
-          }
-        end
 
         FileUtils.mkdir_p(outputdir)
         basename = 'model'
         File.write(File.join(outputdir, "#{basename}.meta"), { "gs" => gs }.to_json)
         new_filename = File.join(outputdir, [basename, gs, '.ckpt'].compact.join('-'))
-        File.write(new_filename, output_dump.to_yaml)
+        session.run(@save_op, feed_dict: { @filename => new_filename })
+
         if write_meta_graph
           graph_filename = "#{basename}.yaml"
           TensorStream.train.write_graph(graph, outputdir, graph_filename, serializer: :yaml)
@@ -45,20 +43,15 @@ module TensorStream
         outputdir
       end
 
-      def restore(_session, modelpath)
-        meta_data = JSON.parse(File.read(File.join(modelpath, "model.meta")))
-        gs = meta_data['gs']
-        input_dump = YAML.safe_load(File.read(File.join(modelpath, ['model', gs, '.ckpt'].compact.join('-'))))
+      def restore(session, modelpath)
+        meta_file = File.join(modelpath, "model.meta")
+        return unless File.exist?(meta_file)
 
-        vars = TensorStream::Graph.get_default_graph.get_collection(GraphKeys::GLOBAL_VARIABLES)
-        vars.each do |variable|
-          next unless input_dump['variables'].key?(variable.name)
+        meta_data = JSON.parse(File.read(meta_file))
+        gs = meta_data['gs']
+        filename = File.join(modelpath, ['model', gs, '.ckpt'].compact.join('-'))
 
-          data = TensorStream::Packer.unpack(Zlib::Inflate.inflate(Base64.decode64(input_dump['variables'][variable.name]['data'])), variable.data_type)
-          shape = input_dump['variables'][variable.name]['shape']
-          variable.buffer = nil
-          variable.value = TensorShape.reshape(data, shape)
-        end
+        session.run(@restore_op, feed_dict: { @filename => filename })
       end
 
       private

data/lib/tensor_stream/utils/freezer.rb

@@ -1,18 +1,24 @@
 module TensorStream
   class Freezer
-    include OpHelper
+    include TensorStream::OpHelper
 
     ##
     # Utility class to convert variables to constants for production deployment
     #
-    def convert(model_file, checkpoint_file, output_file)
+    def convert(session, checkpoint_folder, output_file)
+      model_file = File.join(checkpoint_folder, 'model.yaml')
       TensorStream.graph.as_default do |current_graph|
         YamlLoader.new.load_from_string(File.read(model_file))
         saver = TensorStream::Train::Saver.new
-        saver.restore(nil, checkpoint_file)
+        saver.restore(session, checkpoint_folder)
+
+        # collect all assign ops and remove them from the graph
+        remove_nodes = Set.new(current_graph.nodes.values.select { |op| op.is_a?(TensorStream::Operation) && op.operation == :assign }.map { |op| op.consumers.to_a }.flatten.uniq)
+
         output_buffer = TensorStream::Yaml.new.get_string(current_graph) do |graph, node_key|
           node = graph.get_tensor_by_name(node_key)
-          if node.operation == :variable_v2
+          case node.operation
+          when :variable_v2
             value = node.container
             options = {
               value: value,
@@ -26,8 +32,10 @@ module TensorStream
             const_op.shape = TensorShape.new(shape_eval(value))
 
             const_op
+          when :assign
+            nil
           else
-            node
+            remove_nodes.include?(node.name) ? nil : node
           end
         end
         File.write(output_file, output_buffer)

data/lib/tensor_stream/version.rb

@@ -1,5 +1,5 @@
 module TensorStream
-  VERSION = '0.9.10'.freeze
+  VERSION = '1.0.0-rc1'.freeze
 
   def self.version
     VERSION

data/tensor_stream.gemspec

@@ -35,12 +35,13 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "awesome_print"
   spec.add_development_dependency "rubocop"
-  spec.add_development_dependency "pry-byebug"
-  spec.add_development_dependency "byepry"
+  if RUBY_ENGINE == 'ruby'
+    spec.add_development_dependency "pry-byebug"
+    spec.add_development_dependency "byepry"
+  end
   spec.add_development_dependency "colorize"
   spec.add_development_dependency "rspec_junit_formatter"
   spec.add_development_dependency "mnist-learn"
-  spec.add_development_dependency "opencl_ruby_ffi"
   spec.add_development_dependency "simplecov"
   spec.add_dependency "deep_merge"
   spec.add_dependency "concurrent-ruby"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tensor_stream
 version: !ruby/object:Gem::Version
-  version: 0.9.10
+  version: 1.0.0.pre.rc1
 platform: ruby
 authors:
 - Joseph Emmanuel Dayo
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-01-02 00:00:00.000000000 Z
+date: 2019-01-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -150,20 +150,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: opencl_ruby_ffi
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -226,7 +212,8 @@ description: A reimplementation of TensorFlow for ruby. This is a ground up impl
   well with support for an opencl evaluator.
 email:
 - joseph.dayo@gmail.com
-executables: []
+executables:
+- model_utils
 extensions: []
 extra_rdoc_files: []
 files:
@@ -253,6 +240,7 @@ files:
 - data_actual.json
 - data_expected.json
 - data_input.json
+- exe/model_utils
 - lib/tensor_stream.rb
 - lib/tensor_stream/constant.rb
 - lib/tensor_stream/control_flow.rb
@@ -293,6 +281,7 @@ files:
 - lib/tensor_stream/monkey_patches/array.rb
 - lib/tensor_stream/monkey_patches/float.rb
 - lib/tensor_stream/monkey_patches/integer.rb
+- lib/tensor_stream/monkey_patches/op_patch.rb
 - lib/tensor_stream/monkey_patches/patch.rb
 - lib/tensor_stream/nn/nn_ops.rb
 - lib/tensor_stream/operation.rb
@@ -348,9 +337,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.0.1
 signing_key: