tensor_stream 1.0.0 → 1.0.1

data/lib/tensor_stream/tensor.rb

@@ -1,4 +1,4 @@
-require 'ostruct'
+require "ostruct"
 
 module TensorStream
   # Base class that defines a tensor like interface
@@ -8,7 +8,7 @@ module TensorStream
 
     attr_reader :graph, :value
     attr_accessor :name, :data_type, :shape, :rank, :native_buffer, :is_const,
-                  :internal, :source, :given_name, :outputs, :op
+      :internal, :source, :given_name, :outputs, :op
 
     def inspect
     end

data/lib/tensor_stream/tensor_shape.rb

@@ -11,9 +11,9 @@ module TensorStream
     def to_s
       return "?" if @shape.nil?
 
-      dimensions = @shape.collect do |r|
+      dimensions = @shape.collect { |r|
         "Dimension(#{r})"
-      end.join(',')
+      }.join(",")
       "TensorShape([#{dimensions}])"
     end
 
@@ -53,14 +53,14 @@ module TensorStream
       reversed_a = shape_a.reverse
       reversed_b = shape_b.reverse
 
-      reversed_a.each_with_index.collect do |s, index|
+      reversed_a.each_with_index.collect { |s, index|
         next s if index >= reversed_b.size
         next nil if s.nil? || reversed_b[index].nil?
         next nil if s.is_a?(Tensor) || reversed_b[index].is_a?(Tensor)
         next reversed_b[index] if reversed_b[index] > s
 
         s
-      end.reverse
+      }.reverse
     end
 
     def self.reshape(arr, new_shape)

data/lib/tensor_stream/train/adadelta_optimizer.rb

@@ -38,14 +38,14 @@ module TensorStream
         accum = get_slot(var, "accum")
         accum_update = get_slot(var, "accum_update")
         _op(:apply_adadelta,
-            var,
-            accum,
-            accum_update,
-            TensorStream.cast(@learning_rate_tensor, var.data_type),
-            TensorStream.cast(@rho_t, var.data_type),
-            TensorStream.cast(@epsilon_t, var.data_type),
-            grad,
-            use_locking: @use_locking)
+          var,
+          accum,
+          accum_update,
+          TensorStream.cast(@learning_rate_tensor, var.data_type),
+          TensorStream.cast(@rho_t, var.data_type),
+          TensorStream.cast(@epsilon_t, var.data_type),
+          grad,
+          use_locking: @use_locking)
       end
     end
   end

data/lib/tensor_stream/train/adagrad_optimizer.rb

@@ -7,7 +7,7 @@ module TensorStream
       attr_accessor :learning_rate
 
       def initialize(learning_rate, initial_accumulator_value = 0.1,
-                     use_locking: false, name: "Adagrad")
+        use_locking: false, name: "Adagrad")
         @learning_rate = learning_rate
         @initial_accumulator_value = initial_accumulator_value
         @learning_rate_tensor = nil
@@ -38,8 +38,8 @@ module TensorStream
       def apply_dense(grad, var)
         acc = get_slot(var, "accumulator")
         _op(:apply_adagrad,
-            var, acc, TensorStream.cast(@learning_rate_tensor, var.data_type),
-            grad, use_locking: @use_locking)
+          var, acc, TensorStream.cast(@learning_rate_tensor, var.data_type),
+          grad, use_locking: @use_locking)
       end
     end
   end

data/lib/tensor_stream/train/adam_optimizer.rb

@@ -22,7 +22,7 @@ module TensorStream
       # name: Optional name for the operations created when applying gradients.
       #   Defaults to "Adam".
       def initialize(learning_rate = 0.001, beta1 = 0.9, beta2 = 0.999, epsilon = 1e-8,
-                     use_locking: false, name: "Adam")
+        use_locking: false, name: "Adam")
         @learning_rate = learning_rate
         @beta1 = beta1
         @beta2 = beta2
@@ -44,7 +44,7 @@ module TensorStream
       def get_beta_accumulators
         graph = TensorStream.get_default_graph
         [get_non_slot_variable("beta1_power", graph: graph),
-         get_non_slot_variable("beta2_power", graph: graph)]
+         get_non_slot_variable("beta2_power", graph: graph),]
       end
 
       def prepare
@@ -76,14 +76,14 @@ module TensorStream
         v = get_slot(var, "v")
         beta1_power, beta2_power = get_beta_accumulators
         _op(:apply_adam,
-            var, m, v,
-            TensorStream.cast(beta1_power, var.data_type),
-            TensorStream.cast(beta2_power, var.data_type),
-            TensorStream.cast(@lr_t, var.data_type),
-            TensorStream.cast(@beta1_t, var.data_type),
-            TensorStream.cast(@beta2_t, var.data_type),
-            TensorStream.cast(@epsilon_t, var.data_type),
-            grad, use_locking: @use_locking)
+          var, m, v,
+          TensorStream.cast(beta1_power, var.data_type),
+          TensorStream.cast(beta2_power, var.data_type),
+          TensorStream.cast(@lr_t, var.data_type),
+          TensorStream.cast(@beta1_t, var.data_type),
+          TensorStream.cast(@beta2_t, var.data_type),
+          TensorStream.cast(@epsilon_t, var.data_type),
+          grad, use_locking: @use_locking)
       end
 
       def finish(update_ops, name_scope)
@@ -99,4 +99,4 @@ module TensorStream
       end
     end
   end
-end
+end

data/lib/tensor_stream/train/learning_rate_decay.rb

@@ -12,7 +12,7 @@ module TensorStream
       def exponential_decay(learning_rate, global_step, decay_steps, decay_rate, staircase: false, name: nil)
         raise TensorStream::ValueError, "global_step is required for exponential_decay." if global_step.nil?
 
-        name_scope(name, default: 'ExponentialDecay', values: [learning_rate, global_step, decay_steps, decay_rate]) do
+        name_scope(name, default: "ExponentialDecay", values: [learning_rate, global_step, decay_steps, decay_rate]) do
           learning_rate = convert_to_tensor(learning_rate, name: "learning_rate")
           data_type = learning_rate.data_type
           decay_steps = cast(decay_steps, data_type)
@@ -26,4 +26,4 @@ module TensorStream
       end
     end
   end
-end
+end

data/lib/tensor_stream/train/momentum_optimizer.rb

@@ -13,7 +13,7 @@ module TensorStream
       #   name: Optional name prefix
       #   use_nesterov: boolean - Flag that indicates if nesterov momentum is to be used. http://jmlr.org/proceedings/papers/v28/sutskever13.pdf
       #   use_locking: boolean - filler argument for compatibility, not used at the moment
-      def initialize(learning_rate, momentum, name: 'momentum', use_nesterov: false, use_locking: false)
+      def initialize(learning_rate, momentum, name: "momentum", use_nesterov: false, use_locking: false)
         @learning_rate = learning_rate
         @momentum = momentum
         @use_nesterov = use_nesterov
@@ -37,12 +37,12 @@ module TensorStream
         mom = get_slot(var, "momentum")
 
         _op(:apply_momentum, var, mom,
-            TensorStream.cast(@learning_rate_tensor, var.data_type),
-            grad,
-            TensorStream.cast(@momentum_tensor, var.data_type),
-            use_locking: @use_locking,
-            use_nesterov: @use_nesterov)
+          TensorStream.cast(@learning_rate_tensor, var.data_type),
+          grad,
+          TensorStream.cast(@momentum_tensor, var.data_type),
+          use_locking: @use_locking,
+          use_nesterov: @use_nesterov)
       end
     end
   end
-end
+end

data/lib/tensor_stream/train/optimizer.rb

@@ -29,11 +29,11 @@ module TensorStream
         create_slots(varlist)
         TensorStream.name_scope(name, default: @name) do
           prepare
-          apply_ops = grads_and_vars.map do |grad, var|
+          apply_ops = grads_and_vars.map { |grad, var|
             TensorStream.name_scope("update_" + var.op.name) do
               apply_dense(grad, var)
             end
-          end
+          }
 
           if global_step.nil?
             finish(apply_ops, name)
@@ -51,14 +51,14 @@ module TensorStream
       # This is the first part of minimize(). It returns a list of (gradient, variable) pairs where "gradient" is the gradient for "variable".
       def compute_gradients(loss, var_list: nil, grad_loss: nil)
         trainable_vars = if var_list
-                           raise "var_list must be an array" unless var_list.is_a?(Array)
+          raise "var_list must be an array" unless var_list.is_a?(Array)
 
-                           var_list.each_with_index { |var, index| raise "var #{index} not a Variable" unless var.is_a?(Variable) }
+          var_list.each_with_index { |var, index| raise "var #{index} not a Variable" unless var.is_a?(Variable) }
 
-                           var_list
-                         else
-                           loss.graph.get_collection(TensorStream::GraphKeys::TRAINABLE_VARIABLES)
-                         end
+          var_list
+        else
+          loss.graph.get_collection(TensorStream::GraphKeys::TRAINABLE_VARIABLES)
+        end
         all_grads = grad_loss || TensorStream.gradients(loss, trainable_vars)
         trainable_vars.each_with_index.collect do |var, index|
           [all_grads[index], var]
@@ -162,4 +162,4 @@ module TensorStream
       end
     end
   end
-end
+end

data/lib/tensor_stream/train/rmsprop_optimizer.rb

@@ -12,7 +12,7 @@ module TensorStream
       #
       # [paper](http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf).
       def initialize(learning_rate, decay = 0.9, momentum = 0.0, epsilon = 1e-10, centered: false,
-                     use_locking: false, name: "RMSProp")
+        use_locking: false, name: "RMSProp")
         @learning_rate = learning_rate
         @decay = decay
         @momentum = momentum
@@ -46,10 +46,10 @@ module TensorStream
         # Create slots for the first and second moments.
         var_list.each do |v|
           init_rms = if v.shape.known?
-                       TensorStream.ones_initializer(dtype: v.data_type)
-                     else
-                       TensorStream.ones_like(v)
-                     end
+            TensorStream.ones_initializer(dtype: v.data_type)
+          else
+            TensorStream.ones_like(v)
+          end
 
           get_or_make_slot_with_initializer(v, init_rms, v.shape, v.data_type, "rms", @name)
 
@@ -65,20 +65,20 @@ module TensorStream
         if @centered
           mg = get_slot(var, "mg")
           _op(:apply_centered_rms_prop, var, mg, rms, mom,
-              TensorStream.cast(@learning_rate_tensor, var.data_type),
-              TensorStream.cast(@decay_tensor, var.data_type),
-              TensorStream.cast(@momentum_tensor, var.data_type),
-              TensorStream.cast(@epsilon_tensor, var.data_type),
-              grad, use_locking: @use_locking)
+            TensorStream.cast(@learning_rate_tensor, var.data_type),
+            TensorStream.cast(@decay_tensor, var.data_type),
+            TensorStream.cast(@momentum_tensor, var.data_type),
+            TensorStream.cast(@epsilon_tensor, var.data_type),
+            grad, use_locking: @use_locking)
         else
           _op(:apply_rms_prop, var, rms, mom,
-              TensorStream.cast(@learning_rate_tensor, var.data_type),
-              TensorStream.cast(@decay_tensor, var.data_type),
-              TensorStream.cast(@momentum_tensor, var.data_type),
-              TensorStream.cast(@epsilon_tensor, var.data_type),
-              grad, use_locking: @use_locking)
+            TensorStream.cast(@learning_rate_tensor, var.data_type),
+            TensorStream.cast(@decay_tensor, var.data_type),
+            TensorStream.cast(@momentum_tensor, var.data_type),
+            TensorStream.cast(@epsilon_tensor, var.data_type),
+            grad, use_locking: @use_locking)
         end
       end
     end
   end
-end
+end

data/lib/tensor_stream/train/saver.rb

@@ -1,4 +1,4 @@
-require 'json'
+require "json"
 require "zlib"
 
 module TensorStream
@@ -11,18 +11,18 @@ module TensorStream
         graph = TensorStream::Graph.get_default_graph
         vars = graph.get_collection(GraphKeys::GLOBAL_VARIABLES)
 
-        @filename = graph['ts_filename'] || TensorStream.placeholder(:string, name: 'ts_filename', shape: [])
+        @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',
-               write_meta_graph: true,
-               write_state: true,
-               strip_default_attrs: false)
+        latest_filename: nil,
+        meta_graph_suffix: "meta",
+        write_meta_graph: true,
+        write_state: true,
+        strip_default_attrs: false)
         graph = TensorStream::Graph.get_default_graph
         vars = graph.get_collection(GraphKeys::GLOBAL_VARIABLES)
 
@@ -31,10 +31,10 @@ module TensorStream
         gs = eval_global_step(session, global_step)
 
         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('-'))
-        session.run(@save_op, feed_dict: { @filename => new_filename })
+        basename = "model"
+        File.write(File.join(outputdir, "#{basename}.meta"), {"gs" => gs}.to_json)
+        new_filename = File.join(outputdir, [basename, gs, ".ckpt"].compact.join("-"))
+        session.run(@save_op, feed_dict: {@filename => new_filename})
 
         if write_meta_graph
           graph_filename = "#{basename}.yaml"
@@ -48,10 +48,10 @@ module TensorStream
         return unless File.exist?(meta_file)
 
         meta_data = JSON.parse(File.read(meta_file))
-        gs = meta_data['gs']
-        filename = File.join(modelpath, ['model', gs, '.ckpt'].compact.join('-'))
+        gs = meta_data["gs"]
+        filename = File.join(modelpath, ["model", gs, ".ckpt"].compact.join("-"))
 
-        session.run(@restore_op, feed_dict: { @filename => filename })
+        session.run(@restore_op, feed_dict: {@filename => filename})
       end
 
       private

data/lib/tensor_stream/train/slot_creator.rb

@@ -54,14 +54,14 @@ module TensorStream
         dtype = primary.data_type if dtype.nil?
         slot_shape = primary.shape
         slot_shape = if slot_shape.fully_defined?
-                       slot_shape.shape
-                     else
-                       TensorStream.shape(primary.initialized_value)
-                     end
+          slot_shape.shape
+        else
+          TensorStream.shape(primary.initialized_value)
+        end
         val = TensorStream.zeros(slot_shape, dtype: dtype)
         create_slot(primary, val, name,
-                           colocate_with_primary: colocate_with_primary)
+          colocate_with_primary: colocate_with_primary)
       end
     end
   end
-end
+end

data/lib/tensor_stream/train/utils.rb

@@ -11,24 +11,24 @@ module TensorStream
                                                                                        initializer: TensorStream.zeros_initializer,
                                                                                        trainable: false,
                                                                                        collections: [TensorStream::GraphKeys::GLOBAL_VARIABLES,
-                                                                                                     TensorStream::GraphKeys::GLOBAL_STEP])
+                                                                                                     TensorStream::GraphKeys::GLOBAL_STEP,])
       end
 
       def get_global_step(graph = nil)
         target_graph = graph || TensorStream.get_default_graph
         global_step_tensors = target_graph.get_collection(TensorStream::GraphKeys::GLOBAL_STEP)
         global_step_tensor = if global_step_tensors.nil? || global_step_tensors.empty?
-                               begin
-                                 target_graph.get_tensor_by_name('global_step:0')
-                               rescue TensorStream::KeyError
-                                 nil
-                               end
-                             elsif global_step_tensors.size == 1
-                               global_step_tensors[0]
-                             else
-                               TensorStream.logger.error("Multiple tensors in global_step collection.")
-                               nil
-                             end
+          begin
+            target_graph.get_tensor_by_name("global_step:0")
+          rescue TensorStream::KeyError
+            nil
+          end
+        elsif global_step_tensors.size == 1
+          global_step_tensors[0]
+        else
+          TensorStream.logger.error("Multiple tensors in global_step collection.")
+          nil
+        end
         global_step_tensor
       end
     end

data/lib/tensor_stream/trainer.rb

@@ -1,13 +1,13 @@
-require 'tensor_stream/train/slot_creator'
-require 'tensor_stream/train/optimizer'
-require 'tensor_stream/train/gradient_descent_optimizer'
-require 'tensor_stream/train/momentum_optimizer'
-require 'tensor_stream/train/adam_optimizer'
-require 'tensor_stream/train/adadelta_optimizer'
-require 'tensor_stream/train/adagrad_optimizer'
-require 'tensor_stream/train/rmsprop_optimizer'
-require 'tensor_stream/train/saver'
-require 'tensor_stream/train/learning_rate_decay'
+require "tensor_stream/train/slot_creator"
+require "tensor_stream/train/optimizer"
+require "tensor_stream/train/gradient_descent_optimizer"
+require "tensor_stream/train/momentum_optimizer"
+require "tensor_stream/train/adam_optimizer"
+require "tensor_stream/train/adadelta_optimizer"
+require "tensor_stream/train/adagrad_optimizer"
+require "tensor_stream/train/rmsprop_optimizer"
+require "tensor_stream/train/saver"
+require "tensor_stream/train/learning_rate_decay"
 
 module TensorStream
   module Trainer

data/lib/tensor_stream/types.rb

@@ -1,4 +1,4 @@
-require 'ostruct'
+require "ostruct"
 
 module TensorStream
   # Convenience class for specifying valid data_types

data/lib/tensor_stream/utils.rb

@@ -33,12 +33,12 @@ module TensorStream
     # Returns:
     # - An array containing the names of those devices
     def list_local_devices
-      local_name = 'job:localhost'
-      TensorStream::Evaluator.evaluators.collect do |k, v|
+      local_name = "job:localhost"
+      TensorStream::Evaluator.evaluators.collect { |k, v|
         v[:class].query_supported_devices.collect do |device_str|
-          [local_name, "ts:#{k}:#{device_str.name}"].join('/')
+          [local_name, "ts:#{k}:#{device_str.name}"].join("/")
         end
-      end.flatten
+      }.flatten
     end
 
     ##
@@ -51,17 +51,17 @@ module TensorStream
         name: name,
         graph: graph,
         dtype: dtype,
-        trainable: trainable
+        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
+        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)
       tensor
@@ -70,7 +70,7 @@ module TensorStream
     ##
     # Defines a variable context manager
     def variable_scope(scope = nil, default_name = nil, reuse: nil, initializer: nil)
-      Thread.current[:tensor_stream_variable_scope] ||= [ VariableScope.new ]
+      Thread.current[:tensor_stream_variable_scope] ||= [VariableScope.new]
 
       # uniquenifier
       if scope.nil? && default_name
@@ -117,7 +117,7 @@ module TensorStream
     end
 
     def get_variable_scope
-      if !Thread.current[:tensor_stream_variable_scope]
+      unless Thread.current[:tensor_stream_variable_scope]
         variable_scope = VariableScope.new
         Thread.current[:tensor_stream_variable_scope] = [variable_scope]
         return variable_scope
@@ -127,7 +127,7 @@ module TensorStream
     end
 
     def __v_scope_name
-      Thread.current[:tensor_stream_variable_scope].map(&:name).compact.reject(&:empty?).join('/')
+      Thread.current[:tensor_stream_variable_scope].map(&:name).compact.reject(&:empty?).join("/")
     end
 
     ##
@@ -160,8 +160,8 @@ module TensorStream
       TensorStream::Layers
     end
 
-    def constant(value, dtype: nil, shape: nil, internal: false, name: 'Const')
-      shared_options = { const: true, value: value, name: name, internal: internal }
+    def constant(value, dtype: nil, shape: nil, internal: false, name: "Const")
+      shared_options = {const: true, value: value, name: name, internal: internal}
 
       if value.is_a?(Float)
         TensorStream::Constant.new(dtype || :float32, 0, shape || [], shared_options)
@@ -275,24 +275,25 @@ module TensorStream
       return input unless input.is_a?(Tensor)
       return input if input.data_type.nil?
 
-      raise "#{input.source}: Parameter data type #{input.data_type} passed not in #{types.join(',')}" unless types.include?(input.data_type.to_sym)
+      raise "#{input.source}: Parameter data type #{input.data_type} passed not in #{types.join(",")}" unless types.include?(input.data_type.to_sym)
     end
 
-    def check_data_types(input_a, input_b)
-      if !input_a.is_a?(Tensor) && input_b.is_a?(Tensor)
-        input_a = convert_to_tensor(input_a, dtype: input_b.data_type)
-      elsif !input_b.is_a?(Tensor) && input_a.is_a?(Tensor)
-        input_b = convert_to_tensor(input_b, dtype: input_a.data_type)
-      else
-        input_a = convert_to_tensor(input_a)
-        input_b = convert_to_tensor(input_b)
-      end
+    def check_data_types(*args)
+      unique_types = args.select { |a| a.is_a?(Tensor) }. map { |a| norm_dtype(a.data_type) }.uniq
 
-      if norm_dtype(input_a.data_type) != norm_dtype(input_b.data_type)
-        raise TensorStream::ValueError, "Value Error: Tensor conversion requested dtype #{input_a.data_type} for tensor type #{input_b.data_type}"
+      if unique_types.size > 1
+        raise TensorStream::ValueError, "Value Error: Tensor conversion requested dtypes are different -> #{unique_types}"
       end
 
-      [input_a, input_b]
+      unique_types.first
+    end
+
+    ##
+    # Auto cast ruby constant data types to the same
+    # tensor types of other operands
+    def apply_data_type_coercion(*args)
+      coerced_type = check_data_types(*args)
+      args.map { |a| a.is_a?(Tensor) ? a : convert_to_tensor(a, dtype: coerced_type) }
     end
 
     def norm_dtype(dtype)
@@ -307,4 +308,4 @@ module TensorStream
       end
     end
   end
-end
+end