tensor_stream 1.0.0 → 1.0.1

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

@@ -1,6 +1,6 @@
 module TensorStream
   module CheckOps
-    def CheckOps.included(klass)
+    def self.included(klass)
       klass.class_eval do
         register_op :assert_equal do |context, tensor, inputs|
           result = call_vector_op(tensor, :equal, inputs[0], inputs[1], context) { |t, u| t == u }
@@ -14,4 +14,4 @@ module TensorStream
       end
     end
   end
-end
+end

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

@@ -1,8 +1,8 @@
-require 'chunky_png'
+require "chunky_png"
 
 module TensorStream
   module ImagesOps
-    def ImagesOps.included(klass)
+    def self.included(klass)
       klass.class_eval do
         register_op :decode_png do |_context, tensor, inputs|
           content = inputs[0]
@@ -26,26 +26,26 @@ module TensorStream
             end
           end
 
-          image_data = image.pixels.collect do |pixel|
+          image_data = image.pixels.collect { |pixel|
             color_values = if channels == 4
-                             [ChunkyPNG::Color.r(pixel),
-                              ChunkyPNG::Color.g(pixel),
-                              ChunkyPNG::Color.b(pixel),
-                              ChunkyPNG::Color.a(pixel)]
-                           elsif channels == 3
-                             [ChunkyPNG::Color.r(pixel),
-                              ChunkyPNG::Color.g(pixel),
-                              ChunkyPNG::Color.b(pixel)]
-                           elsif channels == 1
-                             [ChunkyPNG::Color.r(pixel)]
-                           else
-                             raise "Invalid channel value #{channels}"
-                           end
+              [ChunkyPNG::Color.r(pixel),
+               ChunkyPNG::Color.g(pixel),
+               ChunkyPNG::Color.b(pixel),
+               ChunkyPNG::Color.a(pixel),]
+            elsif channels == 3
+              [ChunkyPNG::Color.r(pixel),
+               ChunkyPNG::Color.g(pixel),
+               ChunkyPNG::Color.b(pixel),]
+            elsif channels == 1
+              [ChunkyPNG::Color.r(pixel)]
+            else
+              raise "Invalid channel value #{channels}"
+            end
 
             color_values.map!(&:to_f) if fp_type?(tensor.data_type)
 
             color_values
-          end
+          }
           TensorShape.reshape(image_data, [image.height, image.width, channels])
         end
 
@@ -85,4 +85,4 @@ module TensorStream
       end
     end
   end
-end
+end

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

@@ -1,13 +1,13 @@
 module TensorStream
   module MathOps
-    def MathOps.included(klass)
+    def self.included(klass)
       klass.class_eval do
         register_op :tanh, no_eval: true do |context, _tensor, inputs|
           call_op(inputs[0], context) { |t, _b| Math.tanh(t) }
         end
 
         register_op :tan, no_eval: true do |context, tensor, inputs|
-          call_op(inputs[0], context) { |t, _b| Math.tan(t) } 
+          call_op(inputs[0], context) { |t, _b| Math.tan(t) }
         end
 
         register_op :atan, no_eval: true do |context, _tensor, inputs|
@@ -20,7 +20,7 @@ module TensorStream
 
         register_op :add, no_eval: true do |context, tensor, inputs|
           a, b = inputs
-          call_vector_op(tensor, :add, a, b, context) { |t, u|  t + u }
+          call_vector_op(tensor, :add, a, b, context) { |t, u| t + u }
         end
 
         register_op :add_n, no_eval: true do |context, tensor, inputs|
@@ -58,7 +58,7 @@ module TensorStream
 
         register_op :mul, no_eval: true do |context, tensor, inputs|
           a, b = inputs
-          call_vector_op(tensor, :mul, a, b, context)  { |t, u| t * u }
+          call_vector_op(tensor, :mul, a, b, context) { |t, u| t * u }
         end
 
         register_op :pow, no_eval: true do |context, tensor, inputs|
@@ -141,13 +141,13 @@ module TensorStream
           raise TensorStream::InvalidArgumentError, "Expected dimension in the range [#{-rank},#{rank}) but got #{axis}" if axis < -rank || axis >= rank
 
           new_shape = shape_eval(inputs[0])
-          ns = new_shape.each_with_index.collect do |shape, index|
+          ns = new_shape.each_with_index.collect { |shape, index|
             next nil if index == axis
 
             shape
-          end.compact
+          }.compact
 
-          Tensor.cast_dtype(TensorShape.reshape(get_op_with_axis(inputs[0], axis, 0, :max), ns), tensor.data_type)
+          Tensor.cast_dtype(TensorShape.reshape(get_op_with_axis(inputs[0], axis, 0, :max), ns), tensor.options[:output_type])
         end
 
         register_op(%i[argmin arg_min]) do |_context, tensor, inputs|
@@ -156,13 +156,13 @@ module TensorStream
           raise TensorStream::InvalidArgumentError, "Expected dimension in the range [#{-rank},#{rank}) but got #{axis}" if axis < -rank || axis >= rank
 
           new_shape = shape_eval(inputs[0])
-          ns = new_shape.each_with_index.collect do |shape, index|
+          ns = new_shape.each_with_index.collect { |shape, index|
             next nil if index == axis
 
             shape
-          end.compact
+          }.compact
 
-          Tensor.cast_dtype(TensorShape.reshape(get_op_with_axis(inputs[0], axis, 0, :min), ns), tensor.data_type)
+          Tensor.cast_dtype(TensorShape.reshape(get_op_with_axis(inputs[0], axis, 0, :min), ns), tensor.options[:output_type])
         end
 
         register_op :cumprod do |context, tensor, inputs|
@@ -179,9 +179,9 @@ module TensorStream
               arr = [1] + arr if exclusive
 
               start_prod = arr[0]
-              mapped = arr[1...count].map do |v|
+              mapped = arr[1...count].map { |v|
                 start_prod = vector_op(start_prod, v) { |a, b| a * b }
-              end
+              }
 
               arr = [arr[0]] + mapped
               reverse_option ? arr.reverse : arr
@@ -190,7 +190,6 @@ module TensorStream
         end
 
         register_op :sum, noop: true do |context, tensor, _inputs|
-
           reduction(context, tensor) do |arr|
             reduced_val = arr[0]
             arr[1..arr.size].each do |v|
@@ -269,4 +268,4 @@ module TensorStream
       end
     end
   end
-end
+end

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

@@ -1,7 +1,7 @@
 module TensorStream
   ## Collection of machine learning related ops
   module NNOps
-    def NNOps.included(klass)
+    def self.included(klass)
       klass.class_eval do
         register_op :apply_gradient_descent do |context, tensor, inputs|
           target_var, learning_rate, delta = inputs
@@ -17,10 +17,10 @@ module TensorStream
           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
+            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
         end
@@ -52,9 +52,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_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
         end
 
@@ -123,11 +123,11 @@ module TensorStream
           labels = last_axis(inputs[1])
           num_classes = input_shape.last
 
-          labels = labels.map do |l|
+          labels = labels.map { |l|
             one_hot = Array.new(num_classes) { 0 }
             one_hot[l] = 1
             one_hot
-          end
+          }
 
           func = lambda { |logits, label|
             c = logits.max
@@ -173,9 +173,9 @@ module TensorStream
           if input_shape.size == 1
             func.call(last_dimen_list)
           else
-            arr = last_dimen_list.collect do |list|
+            arr = last_dimen_list.collect { |list|
               func.call(list)
-            end
+            }
             TensorShape.reshape(arr, input_shape)
           end
         end
@@ -202,9 +202,9 @@ module TensorStream
           if input_shape.size == 1
             func.call(last_dimen_list, last_grad_list)
           else
-            arr = last_dimen_list.zip(last_grad_list).collect do |list, last_grad|
+            arr = last_dimen_list.zip(last_grad_list).collect { |list, last_grad|
               func.call(list, last_grad)
-            end
+            }
             TensorShape.reshape(arr, input_shape)
           end
         end
@@ -226,32 +226,31 @@ module TensorStream
 
           _batch, height, width, _channels = shape_eval(inputs[0])
           padding = conv2d_padding_options(padding_option, filter_shape, height, width, height_stride, width_stride)
-          inputs[0].collect do |image|
+          inputs[0].collect { |image|
             f_height, f_width, _input_channels, _output_channels = filter_shape
-            (-padding[0]...height).step(height_stride).map do |y|
+            (-padding[0]...height).step(height_stride).map { |y|
               next if (y + f_height) > (height + padding[2])
 
-              (-padding[1]...width).step(width_stride).map do |x|
+              (-padding[1]...width).step(width_stride).map { |x|
                 next if (x + f_width) > (width + padding[3])
 
-                filter_result = (0...f_height).map do |f_y|
-                  (0...f_width).map do |f_x|
+                filter_result = (0...f_height).map { |f_y|
+                  (0...f_width).map { |f_x|
                     f_element = filter[f_y][f_x]
 
                     next if (x + f_x >= width) || (x + f_x < 0)
                     next if (y + f_y >= height) || (y + f_y < 0)
 
-
                     image[y + f_y][x + f_x].zip(f_element).map do |image_channel, filter_channels|
                       filter_channels.map { |c| image_channel * c }
                     end
-                  end.compact
-                end.flatten(2)
+                  }.compact
+                }.flatten(2)
 
                 filter_result.transpose.map { |e| e.reduce(:+) }
-              end.compact
-            end.compact
-          end.compact
+              }.compact
+            }.compact
+          }.compact
         end
 
         register_op :conv2d_backprop_input do |_context, tensor, inputs|
@@ -285,15 +284,14 @@ module TensorStream
                     img_grad = grad[b][(y + padding[0]) / height_stride][(x + padding[1]) / width_stride]
 
                     channels.times.each do |c|
-                      g = Array.new(output_channels) do |o_c|
+                      g = Array.new(output_channels) { |o_c|
                         filter[f_y][f_x][c][o_c] * img_grad[o_c]
-                      end.reduce(:+)
+                      }.reduce(:+)
 
                       image_gradient[y + f_y][x + f_x][c] += g
                     end
                   end
                 end
-
               end
             end
 
@@ -319,19 +317,19 @@ module TensorStream
 
             ((0 - padding[0])...height).step(height_stride).each do |y|
               ((0 - padding[1])...width).step(width_stride).each do |x|
-                filter_result = (0...f_height).map do |f_y|
+                filter_result = (0...f_height).map { |f_y|
                   (0...f_width).map do |f_x|
                     next Array.new(input_channels * output_channels) { 0.0 } if x + f_x >= width || (x + f_x < 0) || ((x + f_width) > (width + padding[3]))
                     next Array.new(input_channels * output_channels) { 0.0 } if y + f_y >= height || (y + f_y < 0) || ((y + f_height) > (height + padding[2]))
 
-                    image_grad = grad[index][(y + padding[0]) / height_stride][(x + padding[1])/ width_stride]
+                    image_grad = grad[index][(y + padding[0]) / height_stride][(x + padding[1]) / width_stride]
                     image[y + f_y][x + f_x].map do |image_channel|
                       Array.new(output_channels) do |o_c|
                         image_channel * image_grad[o_c]
                       end
                     end
                   end
-                end.flatten
+                }.flatten
 
                 filter_gradient_sum = multi_array_op(->(a, b) { a + b }, filter_gradient_sum, filter_result)
               end
@@ -341,17 +339,16 @@ module TensorStream
           TensorShape.reshape(filter_gradient_sum, filter_shape)
         end
 
-
         def conv2d_padding_options(padding_option, filter_shape, height, width, h_stride, w_stride)
           case padding_option
-          when 'SAME'
+          when "SAME"
             [
               calc_pad(height, h_stride, filter_shape[0]),
               calc_pad(width, w_stride, filter_shape[1]),
               calc_pad(height, h_stride, filter_shape[0], true),
-              calc_pad(width, w_stride, filter_shape[1], true)
+              calc_pad(width, w_stride, filter_shape[1], true),
             ]
-          when 'VALID'
+          when "VALID"
             [0, 0, 0, 0]
           else
             raise TensorStream::ValueError, "Unsupported padding value #{padding_option}, valid values 'SAME', 'VALID'"
@@ -369,4 +366,4 @@ module TensorStream
       end
     end
   end
-end
+end

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

@@ -1,7 +1,7 @@
 module TensorStream
   ## Collection of machine learning related ops
   module RandomOps
-    def RandomOps.included(klass)
+    def self.included(klass)
       klass.class_eval do
         register_op :glorot_uniform, no_eval: true do |_context, tensor, _inputs|
           seed = tensor.options[:seed]
@@ -9,12 +9,12 @@ module TensorStream
 
           shape = tensor.options[:shape] || tensor.shape.shape
           fan_in, fan_out = if shape.size.zero?
-                              [1, 1]
-                            elsif shape.size == 1
-                              [1, shape[0]]
-                            else
-                              [shape[0], shape.last]
-                            end
+            [1, 1]
+          elsif shape.size == 1
+            [1, shape[0]]
+          else
+            [shape[0], shape.last]
+          end
 
           limit = Math.sqrt(6.0 / (fan_in + fan_out))
 
@@ -46,7 +46,6 @@ module TensorStream
           generate_vector(shape, generator: generator)
         end
 
-        
         register_op :truncated_normal, no_eval: true do |_context, tensor, inputs|
           seed = tensor.options[:seed]
           random = _get_randomizer(tensor, seed)
@@ -54,14 +53,14 @@ module TensorStream
           random = _get_randomizer(tensor, seed)
           generator = -> { r.rand }
           shape = inputs[0] || tensor.shape.shape
-          random_values = Array.new(shape.reduce(:*) || 1) do
+          random_values = Array.new(shape.reduce(:*) || 1) {
             generator.call
-          end
+          }
           mean = random_values.reduce(:+) / random_values.size
 
           # standard deviation
 
-          stddev = Math.sqrt( random_values.map { |v| ( v - mean )**2 }.reduce(:+) / (random_values.size - 1) )
+          stddev = Math.sqrt(random_values.map { |v| (v - mean)**2 }.reduce(:+) / (random_values.size - 1))
           minval = random_values.min
           maxval = random_values.max
           max_iterations = 100
@@ -73,14 +72,14 @@ module TensorStream
             maxval = a
             stddev = -stddev
           end
-          
-          norm_min = (minval - mean) / stddev;
-          norm_max = (maxval - mean) / stddev;
-          sqrt_factor = Math.sqrt((norm_min * norm_min) + 4.0);
-          cutoff = 2.0 * Math.exp( 0.5 + (norm_min * (norm_min - sqrt_factor)) / 4.0 ) / (norm_min + sqrt_factor)
-          diff = norm_max - norm_min;
 
-          val = random_values.map do |v|
+          norm_min = (minval - mean) / stddev
+          norm_max = (maxval - mean) / stddev
+          sqrt_factor = Math.sqrt((norm_min * norm_min) + 4.0)
+          cutoff = 2.0 * Math.exp(0.5 + (norm_min * (norm_min - sqrt_factor)) / 4.0) / (norm_min + sqrt_factor)
+          diff = norm_max - norm_min
+
+          val = random_values.map { |v|
             iterations = 0
             pick = v
             while (pick > norm_max) || (pick < norm_min)
@@ -92,12 +91,12 @@ module TensorStream
               end
             end
 
-            pick 
-          end
+            pick
+          }
 
           TensorShape.reshape(val, shape)
         end
       end
     end
   end
-end
+end

data/lib/tensor_stream/evaluator/ruby_evaluator.rb

@@ -1,13 +1,13 @@
-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/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/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/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"
 
 module TensorStream
   module Evaluator
@@ -49,12 +49,12 @@ module TensorStream
 
         child_context = execution_context.dup
         res = if tensor.is_a?(Operation)
-                eval_operation(tensor, child_context)
-              elsif !tensor.is_a?(Tensor)
-                tensor
-              else
-                tensor.op
-              end
+          eval_operation(tensor, child_context)
+        elsif !tensor.is_a?(Tensor)
+          tensor
+        else
+          tensor.op
+        end
         execution_context.deep_merge!(returns: child_context[:returns])
         res
       end
@@ -84,6 +84,7 @@ module TensorStream
 
       def prepare_input(tensor, context, options = {})
         return nil unless tensor
+
         if options[:noop]
           tensor
         elsif options[:no_eval]
@@ -102,10 +103,10 @@ module TensorStream
       end
 
       register_op(:cast) do |context, tensor, inputs|
-        call_op(inputs[0], context)  { |t, _b| Tensor.cast_dtype(t, tensor.data_type) }
+        call_op(inputs[0], context) { |t, _b| Tensor.cast_dtype(t, tensor.data_type) }
       end
 
-      register_op(:sign) do |context, tensor, inputs|
+      register_op(:sign) do |context, _tensor, inputs|
         call_op(inputs[0], context) do |x, _b|
           if x.zero? || (x.is_a?(Float) && x.nan?)
             0
@@ -114,7 +115,7 @@ module TensorStream
           elsif x > 0
             1
           else
-            raise 'assert: cannot be here'
+            raise "assert: cannot be here"
           end
         end
       end
@@ -213,7 +214,7 @@ module TensorStream
       end
 
       register_op :print do |_context, tensor, inputs|
-        puts "#{tensor.options.fetch(:message, '')} #{inputs[1]}"
+        puts "#{tensor.options.fetch(:message, "")} #{inputs[1]}"
         inputs[0]
       end
 
@@ -245,12 +246,12 @@ module TensorStream
           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)
+            "shape" => shape_eval(val),
+            "data" => Base64.strict_encode64(packed_data),
           }
         end
 
-        File.write(outputfile, { 'variables' => variables }.to_yaml)
+        File.write(outputfile, {"variables" => variables}.to_yaml)
         nil
       end
 
@@ -262,10 +263,10 @@ module TensorStream
         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.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']
+          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
@@ -277,6 +278,7 @@ module TensorStream
         message = tensor.options[:message]
         call_op(inputs[0], context) do |t, _b|
           raise TensorStream::InvalidArgumentError, "#{message} Invalid argument" if t.nan? || t.infinite?
+
           t
         end
       end
@@ -289,9 +291,7 @@ module TensorStream
           # puts "result done ruby #{object_id}: #{tensor.name}"
           # assertions to make sure inferred shapes == actual evaluated shapes
           if tensor.shape.known? && (result.is_a?(Array) || result.is_a?(Float) || result.is_a?(Integer))
-            if shape_eval(result) != tensor.shape.shape
-              raise "assert error #{tensor.name} #{shape_eval(result)} != #{tensor.shape.shape}"
-            end
+            raise "assert error #{tensor.name} #{shape_eval(result)} != #{tensor.shape.shape}" if shape_eval(result) != tensor.shape.shape
           end
 
           if tensor.breakpoint
@@ -308,7 +308,7 @@ module TensorStream
               shape: shape_eval(result),
               source: tensor.source,
               description: tensor.to_math(true, 1),
-              value: result
+              value: result,
             }
           end
           @context[tensor.name] = result
@@ -317,22 +317,9 @@ module TensorStream
         raise e, "error #{e.message} while evaluating #{tensor.name}  defined at #{tensor.source}"
       rescue TensorStreamError => e
         raise e, "error #{e.message} while evaluating #{tensor.name}  defined at #{tensor.source}"
-      rescue StandardError => e
-         puts e.message
+      rescue => e
+        puts e.message
         puts e.backtrace.join("\n")
-        # shape_a = a.shape.shape if a
-        # shape_b = b.shape.shape if b
-        # dtype_a = a.data_type if a
-        # dtype_b = b.data_type if b
-        # a = complete_eval(a, child_context)
-        # b = complete_eval(b, child_context)
-        # puts "name: #{tensor.given_name}"
-        # # puts "op: #{tensor.to_math(true, 1)}"
-        # puts "A #{shape_a} #{dtype_a}: #{a}" if a
-        # puts "B #{shape_b} #{dtype_b}: #{b}" if b
-        # dump_intermediates if @log_intermediates
-        # File.write('/home/jedld/workspace/tensor_stream/samples/error.graphml', TensorStream::Graphml.new.get_string(tensor, @session))
-        # File.write('/Users/josephemmanueldayo/workspace/gradients.graphml', TensorStream::Graphml.new.get_string(tensor, @session))
         raise EvaluatorExcecutionException.new(e, tensor), "error #{e.message} while evaluating #{tensor.name} : #{tensor.to_math(true, 1)} defined at #{tensor.source}"
       end
 
@@ -367,7 +354,7 @@ module TensorStream
         TensorStream.send(op.to_sym, a, b)
       end
 
-      def process_vector_math_op(tensor, a, b,  child_context, &block)
+      def process_vector_math_op(tensor, a, b, child_context, &block)
         eval_a = global_eval(tensor, a, child_context) unless a.nil?
         eval_b = global_eval(tensor, b, child_context) unless b.nil?
 
@@ -390,7 +377,7 @@ module TensorStream
       # multi array ops on ruby arrays with same sizes
       def multi_array_op(func, *args)
         elem = args[0]
-        if (elem.is_a?(Array))
+        if elem.is_a?(Array)
           elem.each_with_index.collect do |_item, index|
             indexed_args = args.collect { |a| a[index] }
             multi_array_op(func, *indexed_args)
@@ -497,10 +484,10 @@ module TensorStream
         end
         arr << "============== end ====================="
         str = arr.join("\n")
-        File.write('/tmp/intermediates.txt', str)
+        File.write("/tmp/intermediates.txt", str)
       end
     end
   end
 end
 
-TensorStream::Evaluator.register_evaluator(TensorStream::Evaluator::RubyEvaluator, 'ruby')
+TensorStream::Evaluator.register_evaluator(TensorStream::Evaluator::RubyEvaluator, "ruby")