tensor_stream 1.0.0 → 1.0.1

data/lib/tensor_stream/constant.rb

@@ -11,7 +11,7 @@ module TensorStream
       @options = options
       @is_const = true
       @internal = options[:internal]
-      @name = [@graph.get_name_scope, options[:name] || build_name].compact.reject(&:empty?).join('/')
+      @name = [@graph.get_name_scope, options[:name] || build_name].compact.reject(&:empty?).join("/")
       @given_name = @name
 
       if options[:value]
@@ -42,4 +42,4 @@ module TensorStream
       "Const"
     end
   end
-end
+end

data/lib/tensor_stream/control_flow.rb

@@ -8,7 +8,7 @@ module TensorStream
       @options = options
       @operation = :"flow_#{flow_type}"
       @inputs = inputs
-      @name = [@graph.get_name_scope, options[:name] || set_name].compact.join('/')
+      @name = [@graph.get_name_scope, options[:name] || set_name].compact.join("/")
       @ops = ops
       @consumers = Set.new
       @shape = TensorShape.new([inputs.size])

data/lib/tensor_stream/debugging/debugging.rb

@@ -12,7 +12,7 @@ module TensorStream
           next input if input.is_a?(Variable)
 
           if input.is_a?(Tensor) && TensorStream::Ops::FLOATING_POINT_TYPES.include?(input.data_type)
-            TensorStream.check_numerics(input, "#{node.name}/#{input.name}", name: "check/#{node.name}/#{input.name}" )
+            TensorStream.check_numerics(input, "#{node.name}/#{input.name}", name: "check/#{node.name}/#{input.name}")
           else
             input
           end
@@ -20,4 +20,4 @@ module TensorStream
       end
     end
   end
-end
+end

data/lib/tensor_stream/dynamic_stitch.rb

@@ -12,7 +12,7 @@ module TensorStream
 
       @consumers = Set.new
       @data_type = Tensor.detect_type(inputs[1])
-      @name = [@graph.get_name_scope, options[:name] || set_name].compact.join('/')
+      @name = [@graph.get_name_scope, options[:name] || set_name].compact.join("/")
       @ops = ops
       @shape = TensorShape.new(nil)
       @graph.add_node(self)
@@ -26,4 +26,4 @@ module TensorStream
       eval
     end
   end
-end
+end

data/lib/tensor_stream/evaluator/base_evaluator.rb

@@ -34,20 +34,20 @@ module TensorStream
       ##
       # Query all supported devices
       def self.query_supported_devices
-        [Device.new('cpu', :cpu, self)]
+        [Device.new("cpu", :cpu, self)]
       end
 
       ##
       # Select the best device available in the system for this evaluator
       def self.default_device
-        Device.new('cpu', :cpu, self)
+        Device.new("cpu", :cpu, self)
       end
 
       ##
       # Selects the best device with the specified query, query can
       # be evaluator specific
       def self.fetch_device(_query = [])
-        Device.new('cpu', :cpu, self)
+        Device.new("cpu", :cpu, self)
       end
 
       ##
@@ -56,12 +56,12 @@ module TensorStream
         return default_device if query.nil? || query == :default
 
         all_devices = query_supported_devices
-        substrs = query.split('/')
+        substrs = query.split("/")
         substrs.each do |q|
-          components = q.split(':')
+          components = q.split(":")
           next if components.size.zero?
 
-          if components[0] == 'device' # use tensorflow convention
+          if components[0] == "device" # use tensorflow convention
             device_type = components[1]
             select_index = components[2].to_i
 
@@ -79,7 +79,7 @@ module TensorStream
 
             select_index = [devices.size - 1, select_index].min
             return devices[select_index]
-          elsif components[0] == 'ts' # tensorstream specific
+          elsif components[0] == "ts" # tensorstream specific
             evaluator_class = TensorStream::Evaluator.evaluators[components[1]][:class]
             return nil unless self == evaluator_class
             return evaluator_class.fetch_device(components[2..components.size]) if evaluator_class.respond_to?(:fetch_device)
@@ -95,10 +95,10 @@ module TensorStream
         @ops ||= {}
         if opcode.is_a?(Array)
           opcode.each do |op|
-            @ops[op.to_sym] = { options: options, block: block }
+            @ops[op.to_sym] = {options: options, block: block}
           end
         else
-          @ops[opcode.to_sym] = { options: options, block: block }
+          @ops[opcode.to_sym] = {options: options, block: block}
         end
       end
 
@@ -115,7 +115,7 @@ module TensorStream
         op = self.class.ops[tensor.operation.to_sym]
         op_options = op[:options]
 
-        resolved_inputs = tensor.inputs.map do |i|
+        resolved_inputs = tensor.inputs.map { |i|
           next if i.nil?
           next i if op_options[:noop]
 
@@ -124,25 +124,25 @@ module TensorStream
           end
 
           global_eval(tensor, i, execution_context, op_options)
-        end
+        }
 
         start_time = if profile_enabled?
-                       time = Time.now
-                       time.to_i * (10**9) + time.nsec
-                     end
+          time = Time.now
+          time.to_i * (10**9) + time.nsec
+        end
 
         instance_exec(execution_context, tensor, resolved_inputs, &op[:block]).tap do
           if profile_enabled?
             time = Time.now
             end_time = time.to_i * (10**9) + time.nsec
-            @context[:profile] ||= { step: 0, operations: {} }
+            @context[:profile] ||= {step: 0, operations: {}}
             @context[:profile][:step] += 1
-            @context[:profile][:operations][tensor.name] = { op: tensor.operation,
+            @context[:profile][:operations][tensor.name] = {op: tensor.operation,
                                                              step: @context[:profile][:step],
                                                              eval_time: end_time - start_time,
                                                              shape: tensor.shape ? tensor.shape.shape : nil,
                                                              data_type: tensor.data_type,
-                                                             tensor: tensor }
+                                                             tensor: tensor,}
           end
         end
       end
@@ -222,7 +222,7 @@ module TensorStream
 
     def self.register_evaluator(klass, name, index = 0)
       @evaluators ||= {}
-      @evaluators[name] = { name: name, class: klass, index: index }
+      @evaluators[name] = {name: name, class: klass, index: index}
     end
 
     def self.default_evaluators

data/lib/tensor_stream/evaluator/buffer.rb

@@ -12,4 +12,4 @@ module TensorStream
       buffer
     end
   end
-end
+end

data/lib/tensor_stream/evaluator/evaluator.rb

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

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

@@ -16,10 +16,10 @@ module TensorStream
       start_index = start.shift
       current_size = size.shift
       dimen_size = if current_size == -1
-                     input.size - 1
-                   else
-                     start_index + current_size - 1
-                   end
+        input.size - 1
+      else
+        start_index + current_size - 1
+      end
 
       input[start_index..dimen_size].collect do |item|
         if item.is_a?(Array)
@@ -87,9 +87,9 @@ module TensorStream
       d = dims.shift
 
       if input.is_a?(Array) && (get_rank(input) - 1) == dims.size
-        row_to_dup = input.collect do |item|
+        row_to_dup = input.collect { |item|
           broadcast_dimensions(item, dims.dup)
-        end
+        }
 
         row_to_dup + Array.new(d) { row_to_dup }.flatten(1)
       elsif input.is_a?(Array)
@@ -102,15 +102,15 @@ module TensorStream
     # handle 2 tensor math operations
     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
+        duplicated = Array.new(vector2.size) {
           vector
-        end
+        }
         return vector_op(duplicated, vector2, switch, &block)
       end
 
       return yield(vector, vector2) unless vector.is_a?(Array)
 
-      vector.each_with_index.collect do |input, index|
+      vector.each_with_index.collect { |input, index|
         next vector_op(input, vector2, switch, &block) if input.is_a?(Array) && get_rank(vector) > get_rank(vector2)
 
         if safe && vector2.is_a?(Array)
@@ -118,22 +118,22 @@ module TensorStream
         end
 
         z = if vector2.is_a?(Array)
-              if index < vector2.size
-                vector2[index]
-              else
-                raise 'incompatible tensor shapes used during op' if vector2.size != 1
-                vector2[0]
-              end
-            else
-              vector2
-            end
+          if index < vector2.size
+            vector2[index]
+          else
+            raise "incompatible tensor shapes used during op" if vector2.size != 1
+            vector2[0]
+          end
+        else
+          vector2
+        end
 
         if input.is_a?(Array)
           vector_op(input, z, switch, &block)
         else
           switch ? yield(z, input) : yield(input, z)
         end
-      end.compact
+      }.compact
     end
 
     def shape_diff(shape_a, shape_b)
@@ -142,11 +142,11 @@ 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
         return nil if reversed_b[index] > s
         s - reversed_b[index]
-      end.reverse
+      }.reverse
     end
 
     def tile_arr(input, dimen, multiples)
@@ -155,9 +155,9 @@ module TensorStream
         return nil if t.zero?
         input * t # ruby array dup
       else
-        new_arr = input.collect do |sub|
+        new_arr = input.collect { |sub|
           tile_arr(sub, dimen + 1, multiples)
-        end.compact
+        }.compact
 
         return nil if new_arr.empty?
 
@@ -234,13 +234,13 @@ module TensorStream
     # general case transposition with flat arrays
     def transpose_with_perm(arr, new_arr, shape, new_shape, perm)
       arr_size = shape.reduce(:*)
-      divisors = shape.dup.drop(1).reverse.inject([1]) do |a, s|
+      divisors = shape.dup.drop(1).reverse.inject([1]) { |a, s|
         a << s * a.last
-      end.reverse
+      }.reverse
 
-      multipliers = new_shape.dup.drop(1).reverse.inject([1]) do |a, s|
+      multipliers = new_shape.dup.drop(1).reverse.inject([1]) { |a, s|
         a << s * a.last
-      end.reverse
+      }.reverse
 
       arr_size.times do |p|
         ptr = p
@@ -267,19 +267,19 @@ module TensorStream
     def reduce_axis(current_axis, axis, val, keep_dims, &block)
       return val unless val.is_a?(Array)
 
-      r = val.collect do |v|
+      r = val.collect { |v|
         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)
 
       if should_reduce_axis
         reduced_val = r[0]
         if r.size > 1
-          if block_given?
-            reduced_val = yield(r[0..val.size])
+          reduced_val = if block_given?
+            yield(r[0..val.size])
           else
-            reduced_val = r[0..val.size].reduce(:+)
+            r[0..val.size].reduce(:+)
           end
         elsif r.empty?
           reduced_val = yield(nil)
@@ -292,17 +292,17 @@ module TensorStream
 
     def reduce(val, axis, keep_dims, &block)
       rank = get_rank(val)
-      return val if axis && axis.is_a?(Array) && axis.empty?
+      return val if axis&.is_a?(Array) && axis&.empty?
 
       axis = if axis.nil?
-               nil
-             elsif axis.is_a?(Array)
-               return val if axis.empty?
+        nil
+      elsif axis.is_a?(Array)
+        return val if axis.empty?
 
-               axis.map { |a| a < 0 ? rank - a.abs : a }
-             else
-               axis < 0 ? rank - axis.abs : axis
-             end
+        axis.map { |a| a < 0 ? rank - a.abs : a }
+      else
+        axis < 0 ? rank - axis.abs : axis
+      end
 
       reduce_axis(0, axis, val, keep_dims, &block)
     end
@@ -332,4 +332,4 @@ module TensorStream
       end
     end
   end
-end
+end

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

@@ -6,4 +6,4 @@ module TensorStream
       1 / (1 + Math.exp(-val))
     end
   end
-end
+end

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

@@ -1,6 +1,6 @@
 module TensorStream
   module ArrayOps
-    def ArrayOps.included(klass)
+    def self.included(klass)
       klass.class_eval do
         register_op :slice do |context, tensor, inputs|
           input = inputs[0]
@@ -41,17 +41,17 @@ module TensorStream
           new_shape = [inputs.size]
           shape.inject(new_shape) { |ns, s| ns << s }
 
-          divisors = new_shape.dup.drop(1).reverse.inject([1]) do |a, s|
+          divisors = new_shape.dup.drop(1).reverse.inject([1]) { |a, s|
             a << s * a.last
-          end.reverse
+          }.reverse
 
           axis = rank + axis if axis < 0
           rotated_shape = Array.new(axis + 1) { new_shape.shift }
           new_shape = rotated_shape.rotate! + new_shape
 
-          multipliers = new_shape.dup.drop(1).reverse.inject([1]) do |a, s|
+          multipliers = new_shape.dup.drop(1).reverse.inject([1]) { |a, s|
             a << s * a.last
-          end.reverse
+          }.reverse
 
           inputs.each_with_index do |input, index|
             raw_input = input.is_a?(Array) ? input.flatten : [input]
@@ -85,18 +85,18 @@ module TensorStream
           new_shape = shape_eval(inputs[0])
           rank = new_shape.size - 1
 
-          divisors = new_shape.dup.drop(1).reverse.inject([1]) do |a, s|
+          divisors = new_shape.dup.drop(1).reverse.inject([1]) { |a, s|
             a << s * a.last
-          end.reverse
+          }.reverse
 
           axis = rank + axis if axis < 0
           rotated_shape = Array.new(axis + 1) { new_shape.shift }
           new_shape = rotated_shape.rotate!(-1) + new_shape
           output_buffer = Array.new(new_shape.reduce(:*)) { 0 }
 
-          multipliers = new_shape.dup.drop(1).reverse.inject([1]) do |a, s|
+          multipliers = new_shape.dup.drop(1).reverse.inject([1]) { |a, s|
             a << s * a.last
-          end.reverse
+          }.reverse
 
           inputs.each_with_index do |input, index|
             raw_input = input.is_a?(Array) ? input.flatten : [input]
@@ -249,16 +249,16 @@ module TensorStream
 
         register_op %i[zeros ones zeros_like ones_like] do |_context, tensor, inputs|
           shape = if %i[zeros_like ones_like].include?(tensor.operation)
-                    shape_eval(inputs[0])
-                  else
-                    inputs[0] || tensor.shape.shape
-                  end
+            shape_eval(inputs[0])
+          else
+            inputs[0] || tensor.shape.shape
+          end
 
           func = if %i[zeros zeros_like].include?(tensor.operation)
-                   -> { int_type?(tensor.data_type) ? 0 : 0.0 }
-                 else
-                   -> { int_type?(tensor.data_type) ? 1 : 1.0 }
-                 end
+            -> { int_type?(tensor.data_type) ? 0 : 0.0 }
+          else
+            -> { int_type?(tensor.data_type) ? 1 : 1.0 }
+          end
           if shape.is_a?(Array) && shape.size.zero?
             func.call
           else
@@ -288,23 +288,23 @@ module TensorStream
 
           value_shape = shape_eval(value)
           res = if num_split.is_a?(Array)
-                  begin_index = 0
-                  num_split.collect do |num|
-                    end_index = begin_index + num
-                    arr = split_tensor(value, begin_index, end_index, axis)
-                    begin_index = end_index
-                    arr
-                  end
-                else
-                  raise TensorStream::ValueError, "#{num_split} does not divide #{value_shape[axis]} evenly" if value_shape[axis] % num_split != 0
-
-                  piece_sizes = value_shape[axis] / num_split
-                  Array.new(num_split) do |num|
-                    begin_index = num * piece_sizes
-                    end_index = begin_index + piece_sizes
-                    split_tensor(value, begin_index, end_index, axis)
-                  end
-                end
+            begin_index = 0
+            num_split.collect do |num|
+              end_index = begin_index + num
+              arr = split_tensor(value, begin_index, end_index, axis)
+              begin_index = end_index
+              arr
+            end
+          else
+            raise TensorStream::ValueError, "#{num_split} does not divide #{value_shape[axis]} evenly" if value_shape[axis] % num_split != 0
+
+            piece_sizes = value_shape[axis] / num_split
+            Array.new(num_split) do |num|
+              begin_index = num * piece_sizes
+              end_index = begin_index + piece_sizes
+              split_tensor(value, begin_index, end_index, axis)
+            end
+          end
           TensorStream::Evaluator::OutputGroup.new(res, res.map { tensor.inputs[0].data_type })
         end
 
@@ -326,7 +326,7 @@ module TensorStream
         register_op :tile do |_context, _tensor, inputs|
           input, multiples = inputs
           rank = get_rank(input)
-          raise '1D or higher tensor required' if rank.zero?
+          raise "1D or higher tensor required" if rank.zero?
           raise "invalid multiple size passed #{rank} != #{multiples.size}" if rank != multiples.size
 
           tile = tile_arr(input, 0, multiples)
@@ -343,9 +343,9 @@ module TensorStream
         end
 
         register_op :shape_n do |_context, tensor, inputs|
-          shapes = inputs.collect do |input|
+          shapes = inputs.collect { |input|
             shape_eval(input)
-          end
+          }
           TensorStream::Evaluator::OutputGroup.new(shapes, shapes.map { tensor.options[:out_type] })
         end
 
@@ -372,7 +372,7 @@ module TensorStream
 
           if tensor.options[:exclusive]
             p_true = pred.each_with_index.collect { |p, index| [p, index] }.select { |a| a[0] }
-            raise TensorStream::ValueError, "more than one predicate returns true pos #{p_true.map { |a| a[1] }.join(',')}" if p_true.size > 1
+            raise TensorStream::ValueError, "more than one predicate returns true pos #{p_true.map { |a| a[1] }.join(",")}" if p_true.size > 1
           end
 
           pred.each_with_index do |p, index|
@@ -412,4 +412,4 @@ module TensorStream
       end
     end
   end
-end
+end