tensor_stream 1.0.8 → 1.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 712b5d17b1b84d5289970fa578a8385c80e2a499033a42df8aadefdad654276c
-  data.tar.gz: ed74482c5913ea6debc5d0902d01c180b52f5028ae1ed7be726bafede9671982
+  metadata.gz: 8f7d54f45a96ee2ed86af5916339747701171476e2b1cd6197f4f78d3f7f2eb3
+  data.tar.gz: f8a1c615ebf5f67de35e0e6ac84ac531fc5306b62787ac0d2d952f474eb97bad
 SHA512:
-  metadata.gz: 95b1715323930f35aeec861efa7b5dd96f9b61c8ea2d45343306798506cbbbc64e0092fed77c615a27e53b219610b7b14384726b5fb976b800c7ce57bcfc1539
-  data.tar.gz: 45e92e91167a39ca02cc5a1c04022c0dc1942ad863b650710b93862400174dbddd0bbe1889659ef55651bf1ca0b779420fd48811f862c8707be068cd02abed9f
+  metadata.gz: 4607a3c117c98f21594bcbf12b98a1e927dab88c2847d4516c4f3dd3502b821e8d4b2b8e17e085c3ed122eec1e339baced66e3822fed2c5c6e3c8e10d0121e08
+  data.tar.gz: dd2f7b6c971a25b90a4404319231de6386aef0b536a1df9eca84a3a881e6e9e2faa903fd7fb72b9a05ba8588ec5ffdd153be0072e6c850960fff9ecaecf7b6bc

data/lib/tensor_stream/evaluator/base_evaluator.rb

@@ -228,11 +228,25 @@ module TensorStream
 
     def self.register_evaluator(klass, name, index = 0)
       @evaluators ||= {}
+      @storage_managers ||= {}
       @evaluators[name] = {name: name, class: klass, index: index}
+      @storage_managers[klass] = klass.get_storage_manager
     end
 
     def self.default_evaluators
       evaluators.values.sort { |v| v[:index] }.reverse.map { |v| v[:class] }
     end
+
+    def self.clear_storages(graph)
+      @storage_managers.values.each { |manager| manager.clear_variables(graph) }
+    end
+
+    def self.read_variable(graph, name)
+      @storage_managers.values.each do |manager|
+        return manager.read_value(graph, name) if manager.exists?(graph, name)
+      end
+
+      nil
+    end
   end
 end

data/lib/tensor_stream/evaluator/evaluator.rb

@@ -1,5 +1,6 @@
 require "tensor_stream/evaluator/ruby_evaluator"
 require "tensor_stream/evaluator/buffer"
+require "tensor_stream/evaluator/evaluator_utils"
 
 module TensorStream
   module Evaluator

data/lib/tensor_stream/evaluator/evaluator_utils.rb

@@ -0,0 +1,20 @@
+module TensorStream
+  class EvaluatorUtils
+    extend TensorStream::StringHelper
+
+    def self.get_evaluator_classes(evaluators)
+      @evaluator_classes ||= if evaluators.is_a?(Array)
+        if evaluators.empty?
+          TensorStream::Evaluator.default_evaluators
+        else
+          evaluators.collect { |name| Object.const_get("TensorStream::Evaluator::#{camelize(name.to_s)}") }
+        end
+      elsif evaluators.nil?
+        TensorStream::Evaluator.default_evaluators
+      else
+        [Object.const_get("TensorStream::Evaluator::#{camelize(evaluators.to_s)}")]
+      end
+      @evaluator_classes
+    end
+  end
+end

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

@@ -58,11 +58,19 @@ module TensorStream
           channels = 3 if channels.zero?
 
           image = Jpeg::Image.open_buffer(content)
+          source_channels = image.color_info == :gray ? 1 : 3
+
           image_data = image.raw_data.map do |pixel|
-            pixel.map!(&:to_f) if fp_type?(tensor.data_type)
+            if source_channels == channels
+              pixel
+            elsif source_channels = 1 && channels == 3
+              [pixel, pixel, pixel]
+            elsif source_channels = 3 && channels == 1
+              raise TensorStream::ValueError, "color to grayscale not supported for jpg"
+            end
+          end.flatten
 
-            pixel
-          end
+          image_data.map!(&:to_f) if fp_type?(tensor.data_type)
 
           TensorShape.reshape(image_data, [image.height, image.width, channels])
         end

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

@@ -7,22 +7,20 @@ 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
+          var_assign_value(assign, process_vector_math_op(tensor, target_var, delta, context) { |t, u| t - u * learning_rate })
         end
 
         register_op :apply_momentum do |_context, tensor, inputs|
           target_var, momentum_var, learning_rate, grad, momentum = inputs
           assign = tensor.inputs[0] || tensor
           assign_acc = tensor.inputs[1]
-          assign_acc.container = multi_array_op(->(t, u) { t * momentum + u }, momentum_var, grad)
-          assign.container = if tensor.options[:use_nesterov]
-            multi_array_op(->(v, g, acc) { v - (g * learning_rate + acc * momentum * learning_rate) }, target_var, grad, momentum_var)
-          else
-            multi_array_op(->(v, acc) { v - acc * learning_rate }, target_var, momentum_var)
-          end
-
-          assign.container
+          var_assign_value(assign_acc, multi_array_op(->(t, u) { t * momentum + u }, momentum_var, grad))
+          var = if tensor.options[:use_nesterov]
+                  multi_array_op(->(v, g, acc) { v - (g * learning_rate + acc * momentum * learning_rate) }, target_var, grad, momentum_var)
+                else
+                  multi_array_op(->(v, acc) { v - acc * learning_rate }, target_var, momentum_var)
+                end
+          var_assign_value(assign, var)
         end
 
         register_op :apply_adadelta do |_context, tensor, inputs|
@@ -30,19 +28,18 @@ module TensorStream
           assign = tensor.inputs[0] || tensor
           assign_acc = tensor.inputs[1]
           assign_acc_update = tensor.inputs[2]
-          assign_acc.container = multi_array_op(->(acc_t, grad_t) { acc_t * rho + (grad_t * grad_t) * (1.0 - rho) }, accum, grad)
-          update = multi_array_op(->(acc_update_t, acc_t, grad_t) { Math.sqrt(acc_update_t + epsilon) * (1.0 / Math.sqrt(acc_t + epsilon)) * grad_t }, accum_update, assign_acc.container, grad)
-          assign.container = multi_array_op(->(v, u) { v - (u * lr) }, target_var, update)
-          assign_acc_update.container = multi_array_op(->(acc_update_t, u) { acc_update_t * rho + (u * u) * (1.0 - rho) }, accum_update, update)
+          acc_val = var_assign_value(assign_acc, multi_array_op(->(acc_t, grad_t) { acc_t * rho + (grad_t * grad_t) * (1.0 - rho) }, accum, grad))
+          update = multi_array_op(->(acc_update_t, acc_t, grad_t) { Math.sqrt(acc_update_t + epsilon) * (1.0 / Math.sqrt(acc_t + epsilon)) * grad_t }, accum_update, acc_val, grad)
+          result = var_assign_value(assign, multi_array_op(->(v, u) { v - (u * lr) }, target_var, update))
+          var_assign_value(assign_acc_update,multi_array_op(->(acc_update_t, u) { acc_update_t * rho + (u * u) * (1.0 - rho) }, accum_update, update))
 
-          assign.container
+          result
         end
 
         register_op :apply_adagrad do |_context, tensor, inputs|
           target_var, accum, lr, grad = inputs
           assign = tensor.inputs[0] || tensor
-          assign.container = multi_array_op(->(v, a, g) { v - (g * lr * (1.0 / Math.sqrt(a))) }, target_var, accum, grad)
-          assign.container
+          var_assign_value(assign, multi_array_op(->(v, a, g) { v - (g * lr * (1.0 / Math.sqrt(a))) }, target_var, accum, grad))
         end
 
         register_op :apply_adam do |_context, tensor, inputs|
@@ -52,10 +49,9 @@ module TensorStream
           assign_m = tensor.inputs[1]
           assign_v = tensor.inputs[2]
 
-          assign_m.container = multi_array_op(->(u_d, g) { u_d + (g - u_d) * (1.0 - beta1_t) }, m, grad)
-          assign_v.container = multi_array_op(->(u_d, v_d) { u_d + (v_d**2 - u_d) * (1.0 - beta2_t)}, v, grad)
-          assign.container = multi_array_op(->(t, m_d, v_d) { t - ((m_d * alpha) / (Math.sqrt(v_d) + epsilon_t)) }, target_var, assign_m.container, assign_v.container)
-          assign.container
+          m_val = var_assign_value(assign_m, multi_array_op(->(u_d, g) { u_d + (g - u_d) * (1.0 - beta1_t) }, m, grad))
+          v_val = var_assign_value(assign_v, multi_array_op(->(u_d, v_d) { u_d + (v_d**2 - u_d) * (1.0 - beta2_t)}, v, grad))
+          var_assign_value(assign, multi_array_op(->(t, m_d, v_d) { t - ((m_d * alpha) / (Math.sqrt(v_d) + epsilon_t)) }, target_var, m_val, v_val))
         end
 
         register_op :apply_rms_prop do |_context, tensor, inputs|
@@ -63,9 +59,9 @@ module TensorStream
           assign = tensor.inputs[0]
           assign_ms = tensor.inputs[1]
           assign_mom = tensor.inputs[2]
-          assign_ms.container = multi_array_op(->(g, m) { m + (g * g - m) * (1.0 - rho)}, grad, ms)
-          assign_mom.container = multi_array_op(->(mom_t, g, m) { mom_t * momentum + (g * lr) / Math.sqrt(m + epsilon)}, mom, grad, assign_ms.container)
-          assign.container = multi_array_op(->(v, m) { v - m }, var, assign_mom.container)
+          ms_val = var_assign_value(assign_ms, multi_array_op(->(g, m) { m + (g * g - m) * (1.0 - rho)}, grad, ms))
+          mom_val = var_assign_value(assign_mom, multi_array_op(->(mom_t, g, m) { mom_t * momentum + (g * lr) / Math.sqrt(m + epsilon)}, mom, grad, ms_val))
+          var_assign_value(assign, multi_array_op(->(v, m) { v - m }, var, mom_val))
         end
 
         register_op :apply_centered_rms_prop do |_context, tensor, inputs|
@@ -75,11 +71,11 @@ module TensorStream
           assign_ms = tensor.inputs[2]
           assign_mom = tensor.inputs[3]
 
-          assign_ms.container = multi_array_op(->(g, m) { m + (g * g - m) * (1.0 - rho) }, grad, ms)
-          assign_mg.container = multi_array_op(->(g, mg_t) {  (g - mg_t) * (1.0 - rho) }, grad, mg)
-          denom =  multi_array_op(->(s, mg_t) { (s - mg_t * mg_t) + epsilon }, assign_ms.container, mg)
-          assign_mom.container = multi_array_op(->(mom_t, g, d) { mom_t * momentum + (g * lr) / Math.sqrt(d)}, mom, grad, denom)
-          assign.container = multi_array_op(->(v, m) { v - m }, var, assign_mom.container)
+          val_ms = var_assign_value(assign_ms, multi_array_op(->(g, m) { m + (g * g - m) * (1.0 - rho) }, grad, ms))
+          var_assign_value(assign_mg, multi_array_op(->(g, mg_t) {  (g - mg_t) * (1.0 - rho) }, grad, mg))
+          denom =  multi_array_op(->(s, mg_t) { (s - mg_t * mg_t) + epsilon }, val_ms, mg)
+          val_mom = var_assign_value(assign_mom, multi_array_op(->(mom_t, g, d) { mom_t * momentum + (g * lr) / Math.sqrt(d)}, mom, grad, denom))
+          var_assign_value(assign, multi_array_op(->(v, m) { v - m }, var, val_mom))
         end
 
         register_op %i[softmax_cross_entropy_with_logits_v2 softmax_cross_entropy_with_logits] do |_context, tensor, inputs|

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

@@ -0,0 +1,40 @@
+module TensorStream
+  class RubyStorageManager
+    def self.current_storage_manager
+      @storage_manager ||= RubyStorageManager.new
+    end
+
+    def initialize
+      @variables = {}
+    end
+
+    def exists?(graph, name)
+      return false if !@variables.key?(graph.object_id)
+
+      @variables[graph.object_id].key?(name.to_sym)
+    end
+
+    def create_variable(graph, name, value)
+      raise "no name specified" if name.nil?
+
+      @variables[graph.object_id][name.to_sym] = value
+    end
+
+    def assign_value(graph, name, value)
+      raise "no name specified" if name.nil?
+
+      @variables[graph.object_id] ||= {}
+      @variables[graph.object_id][name.to_sym] = value
+    end
+
+    def read_value(graph, name)
+      raise "no name specified" if name.nil?
+
+      @variables[graph.object_id][name.to_sym]
+    end
+
+    def clear_variables(graph)
+      @variables[graph.object_id] = {}
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module TensorStream
+  ## Collection of machine learning related ops
+  module VariableOps
+    def self.included(klass)
+      klass.class_eval do
+        register_op :variable_v2 do |_context, tensor, _inputs|
+          value = var_read_value(tensor)
+          raise "variable #{tensor.options[:var_name]} not initalized" if value.nil?
+
+          value
+        end
+
+        register_op :assign do |context, tensor, inputs|
+          var_assign_value(tensor, inputs[0])
+        end
+
+        register_op :assign_add, no_eval: true do |context, tensor, inputs|
+          current_val = var_read_value(tensor)
+
+          raise "variable #{tensor.options[:var_name]} not initialized" if current_val.nil?
+          eval_a, eval_b = broadcast(current_val, inputs[0])
+          result = multi_array_op(->(var, val) { var + val }, eval_a, eval_b)
+          var_assign_value(tensor, result)
+        end
+
+        register_op :assign_sub do |context, tensor, inputs|
+          current_val = var_read_value(tensor)
+          raise "variable #{tensor.options[:var_name]} not initialized" if current_val.nil?
+          eval_a, eval_b = broadcast(current_val, inputs[0])
+          result = multi_array_op(->(var, val) { var - val }, eval_a, eval_b)
+          var_assign_value(tensor, result)
+        end
+
+        register_op :save_ts do |_context, tensor, inputs|
+          outputfile = inputs[0]
+          inputs = tensor.inputs.dup
+
+          inputs.shift
+          variables = {}
+          inputs.each do |savable|
+            val = var_read_value(savable)
+
+            packed_data = Zlib::Deflate.deflate(TensorStream::Packer.pack(val, savable.data_type))
+            variables[savable.options[:var_name]] = {
+              "shape" => shape_eval(val),
+              "data" => Base64.strict_encode64(packed_data),
+            }
+          end
+
+          File.write(outputfile, {"variables" => variables}.to_yaml)
+          nil
+        end
+
+        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
+            var_assign_value(variable, TensorShape.reshape(data, shape))
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/tensor_stream/evaluator/ruby_evaluator.rb

@@ -2,12 +2,14 @@ require "tensor_stream/evaluator/operation_helpers/random_gaussian"
 require "tensor_stream/evaluator/operation_helpers/array_ops_helper"
 require "tensor_stream/evaluator/operation_helpers/math_helper"
 require "tensor_stream/evaluator/base_evaluator"
+require "tensor_stream/evaluator/ruby/storage_manager"
 require "tensor_stream/evaluator/ruby/math_ops"
 require "tensor_stream/evaluator/ruby/nn_ops"
 require "tensor_stream/evaluator/ruby/array_ops"
 require "tensor_stream/evaluator/ruby/random_ops"
 require "tensor_stream/evaluator/ruby/images_ops"
 require "tensor_stream/evaluator/ruby/check_ops"
+require "tensor_stream/evaluator/ruby/variable_ops"
 
 module TensorStream
   module Evaluator
@@ -41,6 +43,11 @@ module TensorStream
       include TensorStream::RandomOps
       include TensorStream::ImagesOps
       include TensorStream::CheckOps
+      include TensorStream::VariableOps
+
+      def self.get_storage_manager
+        RubyStorageManager.current_storage_manager
+      end
 
       def run(tensor, execution_context)
         return tensor.map { |t| run(t, execution_context) } if tensor.is_a?(Array) && !tensor.empty? && tensor[0].is_a?(Tensor)
@@ -82,6 +89,18 @@ module TensorStream
 
       protected
 
+      def var_read_value(tensor)
+        @storage_manager ||= TensorStream::RubyStorageManager.current_storage_manager
+        @storage_manager.read_value(tensor.graph, tensor.options[:var_name])
+      end
+
+      def var_assign_value(tensor, value)
+        @storage_manager ||= TensorStream::RubyStorageManager.current_storage_manager
+        @storage_manager.assign_value(tensor.graph, tensor.options[:var_name] || tensor.name, value)
+
+        value
+      end
+
       def prepare_input(tensor, context, options = {})
         return nil unless tensor
 
@@ -154,37 +173,10 @@ module TensorStream
         end
       end
 
-      register_op :variable_v2, no_eval: true do |_context, tensor, _inputs|
-        value = tensor.options[:container].read_value
-        raise "variable #{tensor.options[:container].name} not initalized" if value.nil?
-
-        value
-      end
-
       register_op :stop_gradient, no_eval: true do |_context, _tensor, inputs|
         inputs[0]
       end
 
-      register_op :assign, noop: true do |context, tensor, _inputs|
-        assign = tensor.inputs[0] || tensor
-        assign.container = global_eval(tensor, tensor.inputs[1], context)
-        assign.container
-      end
-
-      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
-      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
-      end
-
       register_op :less do |context, tensor, inputs|
         a, b = inputs
         call_vector_op(tensor, :less, a, b, context) { |t, u| t < u }
@@ -236,44 +228,6 @@ module TensorStream
         softmax(inputs[0])
       end
 
-      register_op :save_ts do |_context, tensor, inputs|
-        outputfile = inputs[0]
-        inputs = tensor.inputs.dup
-
-        inputs.shift
-        variables = {}
-        inputs.each do |savable|
-          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(outputfile, {"variables" => variables}.to_yaml)
-        nil
-      end
-
-      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]
         call_op(inputs[0], context) do |t, _b|
@@ -379,7 +333,7 @@ module TensorStream
         elem = args[0]
         if elem.is_a?(Array)
           elem.each_with_index.collect do |_item, index|
-            indexed_args = args.collect { |a| a[index] }
+            indexed_args = args.collect { |a| a = a.is_a?(Array) ? a : [a]; a[index] }
             multi_array_op(func, *indexed_args)
           end
         else

data/lib/tensor_stream/graph.rb

@@ -30,6 +30,7 @@ module TensorStream
         :"#{GraphKeys::TRAINABLE_VARIABLES}" => [],
       }
       @constants = {}
+      TensorStream::Evaluator.clear_storages(self)
     end
 
     def as_default
@@ -129,7 +130,7 @@ module TensorStream
 
     def add_op(operation, *args)
       options = if args.last.is_a?(Hash)
-        args.pop
+        args.pop || {}
       else
         {}
       end
@@ -180,8 +181,7 @@ module TensorStream
 
     def add_variable!(node, options = {})
       node = add_variable(node, options)
-      op = Graph.get_default_graph.add_op!(:variable_v2, container: node, internal_name: node.name, shape: options[:shape], data_type: options[:data_type])
-      node.name = op.name
+      op = Graph.get_default_graph.add_op!(:variable_v2, var_name: node.name, shape: options[:shape], data_type: options[:data_type])
       op
     end
 

data/lib/tensor_stream/graph_deserializers/yaml_loader.rb

@@ -31,15 +31,13 @@ module TensorStream
         options = {}
 
         new_var = nil
-        if op_def.dig(:attrs, :container)
+        if op_def[:op].to_sym == :variable_v2
           new_var = Variable.new(op_def.dig(:attrs, :data_type))
-          var_shape = op_def.dig(:attrs, :container, :shape)
-          var_options = op_def.dig(:attrs, :container, :options)
-          var_options[:name] = op_def[:name]
 
-          new_var.prepare(var_shape.size, var_shape, TensorStream.get_variable_scope, var_options)
-          options[:container] = new_var
+          var_options = {}
+          var_options[:name] = op_def.dig(:attrs, :var_name)
 
+          new_var.prepare(nil, nil, TensorStream.get_variable_scope, var_options)
           @graph.add_variable(new_var, var_options)
         end
 

data/lib/tensor_stream/helpers/infer_shape.rb

@@ -10,13 +10,7 @@ module TensorStream
     def self.infer_shape(tensor)
       case tensor.operation
       when :assign
-        possible_shape = if tensor.inputs[0]&.shape&.shape
-          tensor.inputs[0].shape.shape
-        else
-          tensor.inputs[1].shape.shape
-        end
-
-        possible_shape
+        tensor.inputs[0]&.shape&.shape
       when :const
         shape_eval(tensor.options[:value])
       when :variable_v2

data/lib/tensor_stream/operation.rb

@@ -7,7 +7,7 @@ module TensorStream
     attr_accessor :name, :operation, :inputs, :rank, :device, :consumers, :breakpoint
     attr_reader :outputs, :options, :is_const, :data_type, :shape
 
-    def initialize(graph, inputs:, options:)
+    def initialize(graph, inputs: [], options: {})
       @consumers = Set.new
       @outputs = []
       @op = self
@@ -42,14 +42,6 @@ module TensorStream
       @options[:container] ? @options[:container].buffer : nil
     end
 
-    def container
-      @options[:container].read_value
-    end
-
-    def container=(value)
-      @options[:container].value = value
-    end
-
     def set_input(index, value)
       @inputs[index] = value
       @shape = TensorShape.new(TensorStream::InferShape.infer_shape(self))
@@ -58,6 +50,10 @@ module TensorStream
       @data_type = set_data_type(@options[:data_type])
     end
 
+    def set_option(key, value)
+      @options.merge!(key.to_sym => value)
+    end
+
     def infer_const
       return false if breakpoint
 
@@ -68,7 +64,7 @@ module TensorStream
         true
       when :placeholder
         false
-      when :variable_v2
+      when :variable_v2, :assign, :assign_add, :assign_sub
         false
       else
         non_const = @inputs.compact.find { |input| !input.is_const }

data/lib/tensor_stream/session.rb

@@ -18,17 +18,7 @@ module TensorStream
     end
 
     def get_evaluator_classes(evaluators)
-      @evaluator_classes = if evaluators.is_a?(Array)
-        if evaluators.empty?
-          TensorStream::Evaluator.default_evaluators
-        else
-          evaluators.collect { |name| Object.const_get("TensorStream::Evaluator::#{camelize(name.to_s)}") }
-        end
-      elsif evaluators.nil?
-        TensorStream::Evaluator.default_evaluators
-      else
-        [Object.const_get("TensorStream::Evaluator::#{camelize(evaluators.to_s)}")]
-      end
+      @evaluator_classes = TensorStream::EvaluatorUtils.get_evaluator_classes(evaluators)
     end
 
     def clear_session_cache
@@ -58,7 +48,8 @@ module TensorStream
       # scan for placeholders and assign value
       options[:feed_dict]&.each_key do |k|
         if k.is_a?(Placeholder)
-          context[k.name.to_sym] = options[:feed_dict][k]
+          ph = options[:feed_dict][k]
+          context[k.name.to_sym] = ph.is_a?(Tensor) ? ph.op : ph
         elsif k.is_a?(String)
           target_graph = args[0].graph
           node = target_graph.get_node(k)

data/lib/tensor_stream/tensor.rb

@@ -4,6 +4,7 @@ module TensorStream
   # Base class that defines a tensor like interface
   class Tensor
     include OpHelper
+    extend OpHelper
     include TensorMixins
 
     attr_reader :graph, :value

data/lib/tensor_stream/train/saver.rb

@@ -50,7 +50,6 @@ module TensorStream
         meta_data = JSON.parse(File.read(meta_file))
         gs = meta_data["gs"]
         filename = File.join(modelpath, ["model", gs, ".ckpt"].compact.join("-"))
-
         session.run(@restore_op, feed_dict: {@filename => filename})
       end
 

data/lib/tensor_stream/utils.rb

@@ -45,25 +45,22 @@ module TensorStream
     # Creates a variable
     # A variable maintains state across sessions
     def variable(value, name: nil, initializer: nil, graph: nil, dtype: nil, trainable: true)
-      op = Graph.get_default_graph.add_op(:assign, nil, value)
       common_options = {
-        initializer: initializer || op,
+        initializer: TensorStream.convert_to_tensor(initializer || value),
         name: name,
         graph: graph,
         dtype: dtype,
         trainable: trainable,
       }
       tensor = if value.is_a?(String)
-        i_var(dtype || :string, 0, [], get_variable_scope, common_options)
-      elsif value.is_a?(Integer)
-        i_var(dtype || :int32, 0, [], get_variable_scope, common_options)
-      elsif value.is_a?(Float)
-        i_var(dtype || :float32, 0, [], get_variable_scope, common_options)
-      else
-        i_var(dtype || :float32, 0, nil, get_variable_scope, common_options)
-      end
-      op.set_input(0, tensor.op)
-      Graph.get_default_graph.add_node(op)
+                 i_var(dtype || :string, 0, [], get_variable_scope, common_options)
+               elsif value.is_a?(Integer)
+                 i_var(dtype || :int32, 0, [], get_variable_scope, common_options)
+               elsif value.is_a?(Float)
+                 i_var(dtype || :float32, 0, [], get_variable_scope, common_options)
+               else
+                 i_var(dtype || :float32, 0, nil, get_variable_scope, common_options)
+               end
       tensor
     end
 

data/lib/tensor_stream/utils/freezer.rb

@@ -19,7 +19,11 @@ module TensorStream
           node = graph.get_tensor_by_name(node_key)
           case node.operation
           when :variable_v2
-            value = node.container
+            value = Evaluator.read_variable(node.graph, node.options[:var_name])
+           if value.nil?
+             raise "#{node.options[:var_name]} has no value"
+           end
+
             options = {
               value: value,
               data_type: node.data_type,

data/lib/tensor_stream/variable.rb

@@ -46,17 +46,16 @@ module TensorStream
 
     def assign(value, name: nil, use_locking: false)
       TensorStream.check_data_types(self, value)
-      _op(:assign, self, value, name: name)
+      _op(:assign, value, name: name, var_name: @name)
     end
 
     def read_value
-      @value = buffer.to_ruby if buffer
-      @value
+      Evaluator.read_variable(@graph, @name)
     end
 
     def assign_add(value, name: nil)
       TensorStream.check_data_types(self, value)
-      _op(:assign_add, self, value, data_type: data_type, name: name)
+      _op(:assign_add, value, data_type: data_type, name: name, var_name: @name)
     end
 
     def to_math(_tensor, _name_only = false, _max_depth = 99, _unused = 0)
@@ -65,11 +64,15 @@ module TensorStream
 
     def assign_sub(value)
       TensorStream.check_data_types(self, value)
-      _op(:assign_sub, self, value)
+      _op(:assign_sub, value, data_type: data_type, name: name, var_name: @name)
     end
 
     def self.variables_initializer(collection)
-      TensorStream.group(TensorStream.get_default_graph.get_collection(collection).map(&:initializer))
+      global_variables_ops = TensorStream.get_default_graph.get_collection(collection).map do |variable|
+        _op(:assign, variable.initializer, var_name: variable.name)
+      end
+
+      TensorStream.group(global_variables_ops)
     end
 
     def self.global_variables_initializer

data/lib/tensor_stream/version.rb

@@ -1,5 +1,5 @@
 module TensorStream
-  VERSION = "1.0.8".freeze
+  VERSION = "1.0.9".freeze
 
   def self.version
     VERSION

data/tensor_stream.gemspec

@@ -32,7 +32,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake", "~> 12.3"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "awesome_print"
   spec.add_development_dependency "rubocop"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tensor_stream
 version: !ruby/object:Gem::Version
-  version: 1.0.8
+  version: 1.0.9
 platform: ruby
 authors:
 - Joseph Emmanuel Dayo
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-06-12 00:00:00.000000000 Z
+date: 2020-12-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.3'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -317,6 +317,7 @@ files:
 - lib/tensor_stream/evaluator/base_evaluator.rb
 - lib/tensor_stream/evaluator/buffer.rb
 - lib/tensor_stream/evaluator/evaluator.rb
+- lib/tensor_stream/evaluator/evaluator_utils.rb
 - lib/tensor_stream/evaluator/operation_helpers/array_ops_helper.rb
 - lib/tensor_stream/evaluator/operation_helpers/math_helper.rb
 - lib/tensor_stream/evaluator/operation_helpers/random_gaussian.rb
@@ -326,6 +327,8 @@ files:
 - lib/tensor_stream/evaluator/ruby/math_ops.rb
 - lib/tensor_stream/evaluator/ruby/nn_ops.rb
 - lib/tensor_stream/evaluator/ruby/random_ops.rb
+- lib/tensor_stream/evaluator/ruby/storage_manager.rb
+- lib/tensor_stream/evaluator/ruby/variable_ops.rb
 - lib/tensor_stream/evaluator/ruby_evaluator.rb
 - lib/tensor_stream/exceptions.rb
 - lib/tensor_stream/generated_stub/ops.rb