tensor_stream 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fdcfc961fddc348440126986de425c0b1784c235
-  data.tar.gz: 35649e38711773b0caf91ed791166cc8a733c2a4
+  metadata.gz: b5b9fcecbe7b27fadeaf403d886ebd0bbdaff531
+  data.tar.gz: b33ee60d3a4fc3c182a2984b8caaac80b7559435
 SHA512:
-  metadata.gz: a2ac76af196eab64d2fadd327e724fd927f3de52d2fd1043896299f95022f92c5c5d833d0d18ed16ce1b5acac1fb29d292bb73f4036a15265ddea662af87a09c
-  data.tar.gz: bd0b0b4078bd9d347e984bc2dde41952cd268b75d5697a1f7b722792fc171ff19bb9aebc41ec0199c092494f1aa9e0e3f9e635d848cf0e7cdb68b132ce66ebd7
+  metadata.gz: f847e4d908f8c1b77f331caa45ddfec15554c44076d8e49b1d5520a61bdfe4294542c5a50433699cfa9e8e88eee3ae5780c00f02d2451282f1143fb5a92822be
+  data.tar.gz: 0ce481db0db30fc53921f011be4d4f294b7f9b78d9fc6a91690f694a912d4d3cbd4cf452290162d8af88b4916bc0a3a7738cf58a5f2082292e833bb8325c92b4

data/.gitignore

@@ -7,6 +7,7 @@
 /pkg/
 /spec/reports/
 /tmp/
+*.gem
 
 # rspec failure tracking
 .rspec_status

data/.rubocop.yml

@@ -0,0 +1,74 @@
+AllCops:
+  Exclude:
+    - samples/*
+    - bin/*
+    - spec/**/*
+    - tensor_stream.gemspec
+    - Rakefile
+
+Metrics/LineLength:
+  Max: 200
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Naming/AccessorMethodName:
+  Exclude:
+    - lib/tensor_stream.rb
+    - lib/tensor_stream/control_flow.rb
+    - lib/tensor_stream/graph.rb
+    - lib/tensor_stream/operation.rb
+
+Style/Documentation:
+  Exclude:
+    - lib/tensor_stream/version.rb
+    - lib/tensor_stream/trainer.rb
+    - lib/tensor_stream/nn/nn_ops.rb
+    - lib/tensor_stream/evaluator/evaluator.rb
+
+Lint/UnusedMethodArgument:
+  Exclude:
+    - lib/tensor_stream/train/saver.rb
+    - lib/tensor_stream/ops.rb
+
+Metrics/ParameterLists:
+  Max: 8
+
+Style/PerlBackrefs:
+  Enabled: false
+
+Style/RegexpLiteral:
+  Enabled: false
+
+Naming/MemoizedInstanceVariableName:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Max: 200
+
+Metrics/ClassLength:
+  Max: 250
+  Exclude:
+    - lib/tensor_stream/evaluator/ruby_evaluator.rb
+
+Naming/VariableNumber:
+  Enabled: false
+
+Style/DoubleNegation:
+  Enabled: false
+
+Style/TrailingCommaInHashLiteral:
+  Enabled: false
+
+Naming/UncommunicativeMethodParamName:
+  Exclude:
+    - lib/tensor_stream/evaluator/ruby_evaluator.rb

data/README.md

@@ -57,8 +57,8 @@ X = tf.placeholder("float")
 Y = tf.placeholder("float")
 
 # Set model weights
-W = tf.Variable(rand, name: "weight")
-b = tf.Variable(rand, name: "bias")
+W = tf.variable(rand, name: "weight")
+b = tf.variable(rand, name: "bias")
 
 # Construct a linear model
 pred = X * W + b
@@ -71,7 +71,7 @@ optimizer = TensorStream::Train::GradientDescentOptimizer.new(learning_rate).min
 # Initialize the variables (i.e. assign their default value)
 init = tf.global_variables_initializer()
 
-tf.Session do |sess|
+tf.session do |sess|
     start_time = Time.now
     sess.run(init)
     (0..training_epochs).each do |epoch|
@@ -105,6 +105,7 @@ end
 
 - This is an early preview release and many things still don't work
 - Performance is not great, at least until the opencl and/or sciruby backends are complete
+- However if you really need an op supported please feel free to file a pull request with the corresponding failing test (see spec/operation_spec.rb)
 
 ## Development
 

data/lib/tensor_stream.rb

@@ -1,4 +1,4 @@
-require "tensor_stream/version"
+require 'tensor_stream/version'
 require 'deep_merge'
 require 'matrix'
 require 'concurrent'
@@ -17,9 +17,10 @@ require 'tensor_stream/trainer'
 require 'tensor_stream/nn/nn_ops'
 require 'tensor_stream/evaluator/evaluator'
 # require 'tensor_stream/libraries/layers'
-require "tensor_stream/monkey_patches/integer"
+require 'tensor_stream/monkey_patches/integer'
 require 'tensor_stream/ops'
 
+# module that exposes TensorStream top level functions
 module TensorStream
   extend TensorStream::OpHelper
   extend TensorStream::Ops
@@ -48,8 +49,8 @@ module TensorStream
     TensorStream::Graph.get_default_graph.executing_eagerly?
   end
 
-  def self.Variable(value, options = {})
-    common_options= {
+  def self.variable(value, options = {})
+    common_options = {
       initializer: Operation.new(:assign, nil, value),
       name: options[:name]
     }
@@ -64,16 +65,15 @@ module TensorStream
     end
   end
 
-  def self.Session(evaluator = :ruby_evaluator, thread_pool_class: Concurrent::ImmediateExecutor)
+  def self.session(evaluator = :ruby_evaluator, thread_pool_class: Concurrent::ImmediateExecutor)
     session = TensorStream::Session.new(evaluator, thread_pool_class: thread_pool_class)
-    if block_given?
-      yield session
-    end
+    yield session if block_given?
+
     session
   end
 
   def self.program(&block)
-    block.(self)
+    block.call(self)
   end
 
   def self.layers
@@ -94,10 +94,11 @@ module TensorStream
       dimensions = []
       value_ptr = value
 
-      begin
-        dtype, rank, value_ptr, d = dtype_eval(dtype, rank, value_ptr)
+      Kernel.loop do
+        dtype, rank, value_ptr, d = dtype_eval(rank, value_ptr)
         dimensions << d
-      end while dtype == :array
+        break if dtype != :array
+      end
 
       TensorStream::Tensor.new(dtype, rank, options[:shape] || dimensions, shared_options)
     end
@@ -127,12 +128,10 @@ module TensorStream
     TensorStream::Trainer
   end
 
-  private
-
-  def self.check_allowed_types(t, types)
-    return t unless t.is_a?(Tensor)
-    return t if t.data_type.nil?
+  def self.check_allowed_types(input, types)
+    return input unless input.is_a?(Tensor)
+    return input if input.data_type.nil?
 
-    fail "Parameter data type #{t.data_type} passed not in #{types.join(',')}" if !types.map(&:to_sym).include?(t.data_type)
+    raise "Parameter data type #{input.data_type} passed not in #{types.join(',')}" unless types.map(&:to_sym).include?(input.data_type)
   end
 end

data/lib/tensor_stream/control_flow.rb

@@ -1,18 +1,21 @@
 module TensorStream
+  # Defines a TensorStream controlflow op
   class ControlFlow < Operation
     attr_accessor :ops
 
     def initialize(flow_type, items, ops = nil, options = {})
+      @graph = options[:graph] || TensorStream.get_default_graph
+
       @operation = :"flow_#{flow_type}"
       @items = items
       @name = set_name
       @ops = ops
-      @source = set_source(caller_locations)
-      @graph = options[:graph] || TensorStream.get_default_graph
+      @source = format_source(caller_locations)
+
       @graph.add_node(self)
     end
 
-    def set_data_type(passed_data_type)
+    def set_data_type(_passed_data_type)
       :unknown
     end
 
@@ -20,4 +23,4 @@ module TensorStream
       eval
     end
   end
-end
+end

data/lib/tensor_stream/evaluator/evaluator.rb

@@ -4,4 +4,4 @@ require 'tensor_stream/evaluator/ruby_evaluator'
 module TensorStream
   module Evaluator
   end
-end
+end

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

@@ -1,6 +1,6 @@
 # http://creativecommons.org/publicdomain/zero/1.0/
 class RandomGaussian
-  def initialize(mean, stddev, rand_helper = lambda { Kernel.rand })
+  def initialize(mean, stddev, rand_helper = -> { Kernel.rand })
     @rand_helper = rand_helper
     @mean = mean
     @stddev = stddev
@@ -9,24 +9,23 @@ class RandomGaussian
   end
 
   def rand
-    if @valid then
+    if @valid
       @valid = false
-      return @next
+      @next
     else
       @valid = true
       x, y = self.class.gaussian(@mean, @stddev, @rand_helper)
       @next = y
-      return x
+      x
     end
   end
 
-  private
   def self.gaussian(mean, stddev, rand)
     theta = 2 * Math::PI * rand.call
     rho = Math.sqrt(-2 * Math.log(1 - rand.call))
     scale = stddev * rho
     x = mean + scale * Math.cos(theta)
     y = mean + scale * Math.sin(theta)
-    return x, y
+    [x, y]
   end
-end
+end

data/lib/tensor_stream/evaluator/ruby_evaluator.rb

@@ -1,4 +1,4 @@
-require "tensor_stream/evaluator/operation_helpers/random_gaussian"
+require 'tensor_stream/evaluator/operation_helpers/random_gaussian'
 require 'tensor_stream/math_gradients'
 
 module TensorStream
@@ -57,9 +57,7 @@ module TensorStream
           old_tensor = tensor
           tensor = run(tensor, context)
 
-          if tensor.is_a?(Array) && !tensor.empty? && tensor[0].is_a?(Tensor)
-            tensor = tensor.map { |t| complete_eval(t, context) }
-          end
+          tensor = tensor.map { |t| complete_eval(t, context) } if tensor.is_a?(Array) && !tensor.empty? && tensor[0].is_a?(Tensor)
 
           return tensor if old_tensor.equal?(tensor)
           return tensor unless tensor.is_a?(Tensor)
@@ -104,7 +102,7 @@ module TensorStream
             elsif x > 0
               1
             else
-              fail 'assert: cannot be here'
+              raise 'assert: cannot be here'
             end
           }
 
@@ -128,7 +126,7 @@ module TensorStream
           input = complete_eval(a, child_context)
           start = complete_eval(b, child_context)
           size = complete_eval(tensor.options[:size], child_context)
-          fail "start index and size not of the same shape #{start.size} != #{size.size}" if start.size != size.size
+          raise "start index and size not of the same shape #{start.size} != #{size.size}" if start.size != size.size
           slice_tensor(input, start, size)
         when :negate
           call_vector_op(:negate, a, nil, child_context, ->(t, _u) { -t })
@@ -137,7 +135,7 @@ module TensorStream
         when :sub
           call_vector_op(:sub, a, b, child_context, ->(t, u) { t - u })
         when :mul
-          call_vector_op(:mul, a, b, child_context, ->(t, u) { binding.pry if t.nil? || u.nil?; t * u })
+          call_vector_op(:mul, a, b, child_context, ->(t, u) { t * u })
         when :pow
           call_vector_op(:pow, a, b, child_context, ->(t, u) { t**u })
         when :concat
@@ -156,13 +154,13 @@ module TensorStream
         when :cos
           call_op(:cos, a, child_context, ->(t, _b) { Math.cos(t) })
         when :log
-          call_op(:log, a, child_context, ->(t, _b) { t < 0 ? Float::NAN : Math.log(t)} )
+          call_op(:log, a, child_context, ->(t, _b) { t < 0 ? Float::NAN : Math.log(t) })
         when :exp
-          call_op(:exp, a, child_context, ->(t, _b) { Math.exp(t) } )
+          call_op(:exp, a, child_context, ->(t, _b) { Math.exp(t) })
         when :sqrt
-          call_op(:exp, a, child_context, ->(t, _b) { Math.sqrt(t) } )
+          call_op(:exp, a, child_context, ->(t, _b) { Math.sqrt(t) })
         when :square
-          call_op(:square, a, child_context, ->(t, _b) { t * t } )
+          call_op(:square, a, child_context, ->(t, _b) { t * t })
         when :stop_gradient
           run(a, child_context)
         when :random_uniform
@@ -184,13 +182,13 @@ module TensorStream
           assign.value = complete_eval(tensor.items[1], child_context)
           assign.value
         when :assign_add
-          tensor.items[0].value = process_vector_math_op(tensor.items[0], tensor.items[1], child_context, ->(a,b) { a + b })
+          tensor.items[0].value = process_vector_math_op(tensor.items[0], tensor.items[1], child_context, ->(t, u) { t + u })
           tensor.items[0].value
         when :assign_sub
-          tensor.items[0].value = process_vector_math_op(tensor.items[0], tensor.items[1], child_context, ->(a,b) { a - b })
+          tensor.items[0].value = process_vector_math_op(tensor.items[0], tensor.items[1], child_context, ->(t, u) { t - u })
           tensor.items[0].value
         when :reduce_mean
-          c = tensor.data_type == :float ? 0.0 : 0
+          c = fp_type?(tensor.data_type) ? 0.0 : 0
           func = lambda { |v|
             if v.is_a?(Array)
               v.empty? ? c : (v.reduce(:+) / v.size)
@@ -201,9 +199,9 @@ module TensorStream
 
           reduction(child_context, tensor, func)
         when :reduce_sum
-          c = tensor.data_type == :float ? 0.0 : 0
-          func = ->(v) { 
-            if v.kind_of?(Array)
+          c = fp_type?(tensor.data_type) ? 0.0 : 0
+          func = lambda { |v|
+            if v.is_a?(Array)
               v.empty? ? c : v.reduce(:+)
             else
               v
@@ -212,9 +210,9 @@ module TensorStream
 
           reduction(child_context, tensor, func)
         when :reduce_prod
-          c = tensor.data_type == :float ? 1.0 : 1
-          func = ->(v) { 
-            if v.kind_of?(Array)
+          c = fp_type?(tensor.data_type) ? 1.0 : 1
+          func = lambda { |v|
+            if v.is_a?(Array)
               v.empty? ? c : v.reduce(:*)
             else
               v
@@ -231,7 +229,7 @@ module TensorStream
 
           Array.new(rows) do |i|
             Array.new(columns) do |col|
-              if tensor.data_type == :float32
+              if fp_type?(tensor.data_type)
                 i == col ? 1.0 : 0.0
               else
                 i == col ? 1 : 0
@@ -241,7 +239,7 @@ module TensorStream
         when :cond
           pred = complete_eval(tensor.options[:pred], child_context)
 
-          if is_all_true(pred)
+          if all_true?(pred)
             complete_eval(a, child_context)
           else
             complete_eval(b, child_context)
@@ -288,15 +286,14 @@ module TensorStream
                  end
 
           if shape.is_a?(Array) && shape.size.zero?
-            func.call()
+            func.call
           else
             shape = [shape.to_i] unless shape.is_a?(Array)
             generate_vector(shape, generator: func)
           end
         when :shape
           input = complete_eval(a, child_context)
-
-          shape_eval(input)
+          shape_eval(input, tensor.options[:out_type])
         when :matmul
           matrix_a = complete_eval(a, child_context)
           matrix_b = complete_eval(b, child_context)
@@ -319,7 +316,7 @@ module TensorStream
 
           (Matrix[*matrix_a] * Matrix[*matrix_b]).to_a
         when :gradients
-          fail "not implemented in evaluator"
+          raise 'not implemented in evaluator' # see TensorStream.gradients instead.
         when :identity
           complete_eval(a, child_context)
         when :print
@@ -331,13 +328,13 @@ module TensorStream
           a = complete_eval(a, child_context)
           get_rank(a)
         when :div
-          process_vector_math_op(a, b, child_context, ->(a,b) { a/b })
+          process_vector_math_op(a, b, child_context, ->(t, u) { t / u })
         when :reshape
           arr = complete_eval(a, child_context)
           new_shape = complete_eval(b, child_context)
 
           flat_arr = arr.flatten
-          return flat_arr[0] if new_shape.size == 0 && flat_arr.size == 1
+          return flat_arr[0] if new_shape.size.zero? && flat_arr.size == 1
 
           new_shape = fix_inferred_elements(new_shape, flat_arr.size)
 
@@ -353,7 +350,7 @@ module TensorStream
 
           call_vector_op(:max, a, b, child_context, ->(t, u) { [t, u].max })
         else
-          fail "unknown op #{tensor.operation}"
+          raise "unknown op #{tensor.operation}"
         end.tap do |result|
           if tensor.breakpoint
             a = complete_eval(a, child_context)
@@ -412,9 +409,9 @@ module TensorStream
           else
             max = nil
             max_index = 0
-            a.each_with_index do |a, index|
-              if max.nil? || a > max
-                max = a
+            a.each_with_index do |x, index|
+              if max.nil? || x > max
+                max = x
                 max_index = index
               end
             end
@@ -445,17 +442,17 @@ module TensorStream
       end
 
       def arr_pad(arr, paddings, data_type = :float32, rank = 0)
-        fail "padding #{paddings[rank]} needs to have to elements [before, after]" if paddings[rank].size != 2
+        raise "padding #{paddings[rank]} needs to have to elements [before, after]" if paddings[rank].size != 2
 
         before = paddings[rank][0]
         after = paddings[rank][1]
-
+        pad_value = fp_type?(data_type) ? 0.0 : 0
         if arr[0].is_a?(Array)
           next_dim_elem = arr.collect { |a| arr_pad(a, paddings, data_type, rank + 1) }
-          padding = deep_dup_array(next_dim_elem[0], data_type == :float32 ? 0.0 : 0)
-          before.times.map { padding } + next_dim_elem + after.times.map { padding }
+          padding = deep_dup_array(next_dim_elem[0], pad_value)
+          Array.new(before) { padding } + next_dim_elem + Array.new(after) { padding }
         else
-          before.times.map {  data_type == :float32 ? 0.0 : 0 } + arr + after.times.map {  data_type == :float32 ? 0.0 : 0 }
+          Array.new(before) { pad_value } + arr + Array.new(after) { pad_value }
         end
       end
 
@@ -485,7 +482,7 @@ module TensorStream
       def matmul_const_transform(mat, mat_b, tensor)
         if !mat.is_a?(Array)
           compat_shape = shape_eval(mat_b).reverse
-          func = ->() { tensor.data_type == :int32 ? mat.to_i : mat.to_f }
+          func = -> { tensor.data_type == :int32 ? mat.to_i : mat.to_f }
 
           generate_vector(compat_shape, generator: func)
         else
@@ -496,7 +493,7 @@ module TensorStream
       def fix_inferred_elements(shape, total_size)
         return shape if shape.empty?
 
-        current_size = shape.inject(1) { |product, n|  n > 0 ? product * n : product }
+        current_size = shape.inject(1) { |product, n| n > 0 ? product * n : product }
         inferred_size = total_size / current_size
         shape.map { |s| s == -1 ? inferred_size : s }
       end
@@ -506,8 +503,8 @@ module TensorStream
 
         s = new_shape.shift
 
-        if new_shape.size == 0
-          fail "reshape dimen mismatch #{arr.size} != #{s}" if arr.size != s
+        if new_shape.size.zero?
+          raise "reshape dimen mismatch #{arr.size} != #{s}" if arr.size != s
           return arr
         end
 
@@ -525,7 +522,7 @@ module TensorStream
       end
 
       def call_vector_op(op, a, b, child_context, func)
-        process_vector_math_op(a, b,  child_context, func)
+        process_vector_math_op(a, b, child_context, func)
       rescue FullEvalNotPossible
         TensorStream.send(op.to_sym, a, b)
       end
@@ -534,12 +531,12 @@ module TensorStream
         eval_a = complete_eval(a, child_context) unless a.nil?
         eval_b = complete_eval(b, child_context) unless b.nil?
 
-        fail FullEvalNotPossible.new, "full eval not possible for #{a.name}" if eval_a.is_a?(Tensor) || eval_b.kind_of?(Tensor)
+        raise FullEvalNotPossible.new, "full eval not possible for #{a.name}" if eval_a.is_a?(Tensor) || eval_b.is_a?(Tensor)
 
         # ruby scalar
-        if get_rank(eval_a) == 0
-          if (get_rank(eval_b)) == 0
-            op.call(eval_a,eval_b)
+        if get_rank(eval_a).zero?
+          if get_rank(eval_b).zero?
+            op.call(eval_a, eval_b)
           else
             constant_op(eval_b, eval_a, child_context, op, true)
           end
@@ -547,14 +544,14 @@ module TensorStream
           if get_rank(eval_b) > 0
             vector_op(eval_a, eval_b, child_context, op)
           else
-          constant_op(eval_a, eval_b, child_context, op)
+            constant_op(eval_a, eval_b, child_context, op)
           end
         end
       end
 
       def get_rank(value, rank = 0)
         return rank unless value.is_a?(Array)
-        return rank + 1 if value.size == 0
+        return rank + 1 if value.empty?
 
         get_rank(value[0], rank + 1)
       end
@@ -570,7 +567,7 @@ module TensorStream
       end
 
       def concat(a, b, axis)
-        if axis == 0
+        if axis.zero?
           a + b
         else
           a.each_with_index.collect do |i, index|
@@ -581,80 +578,74 @@ module TensorStream
 
       def process_function_op(a, child_context, op)
         # ruby scalar
-        if (a.kind_of?(Tensor) && a.shape.rank > 0) || a.kind_of?(Array)
+        if (a.is_a?(Tensor) && a.shape.rank > 0) || a.is_a?(Array)
           constant_op(a, 0, child_context, op)
-        elsif !a.kind_of?(Tensor) || a.shape.rank == 0
+        elsif !a.is_a?(Tensor) || a.shape.rank.zero?
           v = run(a, child_context)
-          fail FullEvalNotPossible.new, "full eval not possible for #{v.name}" if v.is_a?(Tensor) && !v.is_const
+          raise FullEvalNotPossible.new, "full eval not possible for #{v.name}" if v.is_a?(Tensor) && !v.is_const
 
           op.call(v, 0)
         else
-          fail 'cannot be here'
+          raise 'cannot be here'
         end
       end
 
-      def resolve_placeholder(placeholder, execution_context = {})
+      def resolve_placeholder(placeholder, _execution_context = {})
         return nil if placeholder.nil?
         return placeholder if retain.include?(placeholder)
 
-        var = if placeholder.kind_of?(Placeholder)
+        var = if placeholder.is_a?(Placeholder)
                 @context[placeholder.name.to_sym].tap do |c|
-                  if c.nil?
-                    raise "missing placeholder #{placeholder.name}"
-                  end
+                  raise "missing placeholder #{placeholder.name}" if c.nil?
                 end
               else
                 placeholder
               end
 
-        return var unless placeholder.kind_of?(Tensor)
+        return var unless placeholder.is_a?(Tensor)
         Tensor.cast_dtype(var, placeholder.data_type)
       end
 
-      def reduce_axis(axis, val, keep_dims, child_context, op = ->(v) { v.kind_of?(Array) ? v.reduce(:+) : v })
+      def reduce_axis(axis, val, keep_dims, child_context, op = ->(v) { v.is_a?(Array) ? v.reduce(:+) : v })
         val = run(val, child_context)
         return val.is_a?(Array) ? op.call(val.flatten) : val if axis.nil?
-        return val.transpose.collect { |v| keep_dims ? [op.call(v)] : op.call(v) } if axis == 0
+        return val.transpose.collect { |v| keep_dims ? [op.call(v)] : op.call(v) } if axis.zero?
         return val.collect { |v| keep_dims ? [op.call(v)] : op.call(v) } if axis == 1
 
-        fail "can't handle with axis > 1 :("
+        raise "can't handle with axis > 1 :("
       end
 
       def constant_add(vector, constant)
         run(vector).collect do |item|
           if item.is_a?(Array)
             constant_add(item, constant)
+          elsif item.respond_to?(:value)
+            item.value + constant
           else
-            if item.respond_to?(:value)
-              item.value + constant
-            else
-              item + constant
-            end
+            item + constant
           end
         end
       end
 
-      def constant_op(vector, constant, child_context, op = ->(a,b) { a + b }, switch = false)
+      def constant_op(vector, constant, child_context, op = ->(a, b) { a + b }, switch = false)
         eval_vector = complete_eval(vector, child_context)
         constant = complete_eval(constant, child_context)
 
-        fail FullEvalNotPossible.new, "full eval not possible for #{eval_vector.name}" if eval_vector.kind_of?(Tensor) || constant.kind_of?(Tensor)
+        raise FullEvalNotPossible.new, "full eval not possible for #{eval_vector.name}" if eval_vector.is_a?(Tensor) || constant.is_a?(Tensor)
 
         eval_vector.each_with_index.collect do |item, index|
           c = constant.is_a?(Array) ? constant[index] : constant
           if item.is_a?(Array)
             constant_op(item, c, child_context, op, switch)
+          elsif item.respond_to?(:value)
+            switch ? op.call(c, item.value) : op.call(item.value, c)
           else
-            if item.respond_to?(:value)
-              switch ? op.(c, item.value) : op.(item.value, c)
-            else
-              switch ? op.(c, item) : op.(item, c)
-            end
+            switch ? op.call(c, item) : op.call(item, c)
           end
         end
       end
 
-      def call_3way_vector_op(v_a, v_b, v_c, child_context, op = ->(a,b,c) { a + b + c})
+      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)
 
         v_a.each_with_index.collect do |v1, index|
@@ -668,12 +659,12 @@ module TensorStream
         end
       end
 
-      def vector_op(vector, vector2, child_context, op = ->(a,b) { a + b })
+      def vector_op(vector, vector2, child_context, op = ->(a, b) { a + b })
         v_a = run(vector, child_context)
         v_b = run(vector2, child_context)
 
         if get_rank(v_a) < get_rank(v_b) # upgrade rank of A
-          duplicated = v_b.size.times.collect do
+          duplicated = Array.new(v_b.size) do
             v_a
           end
           return vector_op(duplicated, v_b, child_context, op)
@@ -692,10 +683,10 @@ module TensorStream
         end
       end
 
-      def is_all_true(arr)
+      def all_true?(arr)
         if arr.is_a?(Array)
-          arr.each do |a| 
-            return false if !is_all_true(a)
+          arr.each do |a|
+            return false unless all_true?(a)
           end
           return true
         end
@@ -710,33 +701,31 @@ module TensorStream
         v_a.each_with_index.collect do |item, index|
           if item.is_a?(Array)
             constant_add(item, constant)
+          elsif item.respond_to?(:value)
+            item.value + v_b[index].value
           else
-            if item.respond_to?(:value) 
-              item.value + v_b[index].value
-            else
-              item + v_b[index]
-            end
+            item + v_b[index]
           end
         end
       end
 
-      def generate_vector(shape, dtype: :float32, generator: )
+      def generate_vector(shape, dtype: :float32, generator:)
         if shape.is_a?(Integer)
-          shape.times.collect do
+          Array.new(shape) do
             generator.call
           end
         elsif shape.size > 1
-          shape[0].times.collect do
+          Array.new(shape[0]) do
             generate_vector(shape[1..shape.size], generator: generator, dtype: dtype)
           end
         elsif shape.size == 1
-          shape[0].times.collect do
+          Array.new(shape[0]) do
             generator.call
           end
-        elsif shape.size == 0
+        elsif shape.size.zero?
           generator.call
         end
       end
     end
   end
-end
+end