tensor_stream 0.8.1 → 0.8.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3c7d0a810a79ceedc0237379b105d7a9b598ba2513ef2d59ba3cec78d7b0da0
-  data.tar.gz: 7c0d90b27e548b72a86e88e7181f3d3b131a5fa3c6800000c743dd6e47d47b3b
+  metadata.gz: 1d6e9e482de719b709bfe554085718cb01a3bbfd089983eef51ace418b1b7d2d
+  data.tar.gz: 287e63d7a7269e7143ef1016677297c44235a4ac6afb03234f72bb2b6774d348
 SHA512:
-  metadata.gz: a7a8a5607883d868da3ceaa9f870ac5c6d6809d45992a9ae0e4f26d5648bda2c4a26ea3abec506abd92362dcf3b63935b3f6acbcc70b605600307313f8c69f49
-  data.tar.gz: db8917bee53f91e1017b5fdb8b9ece8b50a1096d249cee40eed8c335f597f32e5ce81056230b8ce1b9acff4df728497fa13e896212cbdaccc023dbdb7ed3591e
+  metadata.gz: 3ec2af3376d4cc671eb7bfc549290145d3e14167fe3b472f1c4dd1a05a6ab78ddeddc608d6c1c26a93ddc542ce605341172212e7d5d2f5beeb2542ef3790b03f
+  data.tar.gz: 961e74c0acac0179affca04974f7933fb1162a1a88b3bcdde6c57f679db6d5e23c2e92dd4fff8454bda7ba87dc2eaad7f9424458440348151ea4ac90258a8acc

data/.gitignore

@@ -11,3 +11,4 @@
 
 # rspec failure tracking
 .rspec_status
+.DS_Store

data/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.8.5] - 2018-09-06
+
+### Added
+- [TRAINING] Added AdadeltaOptimizer
+- [NEW OP] squeeze, encode_png, decode_png
+
+### Others
+- The OpenCL evaluator has now been decoupled and is not on its own gem (tensor_stream-opencl)
 
 ## [0.8.1] - 2018-08-30
 - [TRAINING] Added AdamOptimizer

data/README.md

@@ -22,10 +22,16 @@ The goal of this gem is to have a high performance machine learning and compute
 TensorStream comes with a pure ruby and OpenCL implementation out of the box. The pure ruby implementation
 is known to work with most ruby implementations including TruffleRuby, JRuby as well as jit enabled versions of mri (ruby-2.6.0).
 
-OpenCL is supported only on mri implementations of ruby. This can be enabled by including the OpenCL evaluator (Make sure you have OpenCL drivers installed correctly on your system):
+OpenCL is supported only on mri implementations of ruby. This can be enabled by adding OpenCL evaluator gem (Make sure you have OpenCL drivers installed correctly on your system):
+
+```Gemfile
+gem 'tensor_stream-opencl'
+```
+
+and then (without bundler)
 
 ```ruby
-require 'tensor_stream/evaluator/opencl/opencl_evaluator'
+require 'tensor_stream-opencl'
 ```
 
 OpenCL is basically a requirement for deep learning and image processing tasks as the ruby implementation is too slow even with jit speedups using latest ruby implementations.
@@ -199,14 +205,14 @@ Also OpenCL only supports ruby-mri at the moment.
 
 Also include the following gem in your project:
 
-```
-gem 'opencl_ruby_ffi'
+```Gemfile
+gem 'tensor_stream-opencl'
 ```
 
-To use the opencl evaluator instead of the ruby evaluator simply add require it.
+To use the opencl evaluator instead of the ruby evaluator simply require it (if using rails this should be loaded automatically).
 
 ```ruby
-require 'tensor_stream/evaluator/opencl/opencl_evaluator'
+require 'tensor_stream-opencl'
 ```
 
 Adding the OpenCL evaluator should expose additional devices available to tensor_stream

data/lib/tensor_stream.rb

@@ -30,6 +30,7 @@ require 'tensor_stream/math_gradients'
 require "tensor_stream/debugging/debugging"
 require 'tensor_stream/utils'
 require 'tensor_stream/train/utils'
+require 'tensor_stream/images'
 require 'tensor_stream/trainer'
 
 # require 'tensor_stream/libraries/layers'

data/lib/tensor_stream/evaluator/base_evaluator.rb

@@ -129,7 +129,7 @@ module TensorStream
       def global_eval(tensor, input, execution_context, op_options = {})
         return nil unless input
         return input unless input.is_a?(Tensor)
-
+        @context[:_cache][:placement][input.name] = @session.assign_evaluator(input) if @context[:_cache][:placement][input.name].nil?
         if object_id != @context[:_cache][:placement][input.name][1].object_id # tensor is on another device or evaluator
           cache_key = "#{tensor.graph.object_id}_#{input.name}:#{object_id}"
           return @context[:_cache][cache_key] if @context[:_cache].key?(cache_key)

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

@@ -0,0 +1,282 @@
+module TensorStream
+  module ArrayOps
+    def ArrayOps.included(klass)
+      klass.class_eval do
+        register_op :slice do |context, tensor, inputs|
+          input = inputs[0]
+          start = inputs[1]
+          size = complete_eval(tensor.options[:size], context)
+          raise "start index and size not of the same shape #{start.size} != #{size.size}" if start.size != size.size
+          slice_tensor(input, start, size)
+        end
+
+        register_op %i[flow_dynamic_stitch dynamic_stitch] do |_context, _tensor, inputs|
+          indexes, data = inputs
+          merged = []
+          merge_dynamic_stitch(merged, indexes, data)
+          merged
+        end
+
+        register_op :gather do |_context, _tensor, inputs|
+          params, indexes = inputs
+          gather(params, indexes)
+        end
+
+        register_op %i[concat concat_v2] do |_context, tensor, inputs|
+          concat_array(inputs, tensor.options[:axis])
+        end
+
+        register_op :stack do |_context, tensor, inputs|
+          axis = tensor.options[:axis] || 0
+          shape = shape_eval(inputs[0])
+          rank = shape.size + 1
+          elem_size = shape.empty? ? 1 : shape.reduce(:*)
+          output_buffer = Array.new(inputs.size * elem_size) { 0 }
+          new_shape = [inputs.size]
+          shape.inject(new_shape) { |ns, s| ns << s }
+
+          divisors = new_shape.dup.drop(1).reverse.inject([1]) do |a, s|
+            a << s * a.last
+          end.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|
+            a << s * a.last
+          end.reverse
+
+          inputs.each_with_index do |input, index|
+            raw_input = input.is_a?(Array) ? input.flatten : [input]
+            start = index * divisors.first
+
+            raw_input.each_with_index do |x, index2|
+              index_map = []
+              ptr = start + index2
+              divisors.each_with_object(index_map) do |div, a|
+                a << (ptr / div.to_f).floor
+                ptr = ptr % div
+              end
+
+              rotated_index = Array.new(axis + 1) { index_map.shift }
+              index_map = rotated_index.rotate! + index_map
+
+              ptr2 = 0
+              multipliers.each_with_index do |m, idx|
+                ptr2 += index_map[idx] * m
+              end
+
+              output_buffer[ptr2] = x
+            end
+          end
+
+          TensorShape.reshape(output_buffer, new_shape)
+        end
+
+        register_op :squeeze do |_context, tensor, inputs|
+          val = inputs[0]
+          shape = shape_eval(val)
+
+          axis = !tensor.options[:axis].is_a?(Array) ? [tensor.options[:axis]] : tensor.options[:axis]
+
+          if !axis.empty?
+            
+            axis.each do |axis|
+              if shape[axis] == 1
+                shape[axis] = nil 
+              else
+                raise TensorStream::ValueError, "unable to squeeze dimension that does not have a size of 1"
+              end
+            end
+          else
+            shape = shape.map { |s| s == 1 ? nil : s }
+          end
+
+          TensorShape.reshape(val.flatten, shape.compact)
+        end
+
+        register_op :expand_dims do |_context, _tensor, inputs|
+          val, axis = inputs
+          axis = axis.nil? ? 0 : axis
+
+          shape = shape_eval(val)
+          axis = -axis if axis == shape.size
+
+          new_shape = shape.dup.insert(axis, 1).compact
+
+          TensorShape.reshape([val].flatten, new_shape)
+        end
+
+        register_op :fill do |_context, _tensor, inputs|
+          shape = inputs[0]
+          value = inputs[1]
+
+          func = -> { value }
+
+          if shape.is_a?(Array) && shape.size.zero?
+            func.call
+          else
+            shape = [shape.to_i] unless shape.is_a?(Array)
+            generate_vector(shape, generator: func)
+          end
+        end
+
+        register_op :invert_permutation do |_context, _tensor, inputs|
+          input = inputs[0]
+          output = input.dup
+
+          unless input.nil?
+            input.size.times.each do |index|
+              output[input[index]] = index
+            end
+          end
+
+          output
+        end
+
+        register_op :index, no_eval: true do |_context, _tensor, inputs|
+          f = inputs[0]
+          index = inputs[1]
+          if f.is_a?(TensorStream::Evaluator::OutputGroup)
+            f.outputs[index]
+          else
+            f[index]
+          end
+        end
+
+        register_op :setdiff1d do |_context, tensor, inputs|
+          input, remove = inputs
+          idx = []
+          out = []
+          input.each_with_index do |x, index|
+            next if remove.include?(x)
+            out << x
+            idx << index
+          end
+          idx = idx.map { |i| Tensor.cast_dtype(i, tensor.options[:index_dtype]) } unless tensor.options[:index_dtype] == :int32
+          TensorStream::Evaluator::OutputGroup.new([out, idx], tensor.inputs.map(&:data_type))
+        end
+
+        register_op :size do |_context, tensor, inputs|
+          input = inputs[0]
+          Tensor.cast_dtype(input.flatten.size, tensor.options[:out_type])
+        end
+
+        register_op :range do |_context, _tensor, inputs|
+          start, limit, delta = inputs
+          raise " delta !=0 " if delta.zero?
+          raise " Requires start <= limit when delta > 0" if (start > limit) && delta > 0
+          raise " Requires start >= limit when delta < 0" if (start < limit) && delta < 0
+
+          cur_step = start
+          r = []
+          Kernel.loop do
+            break if start == limit
+            break if (start < limit) && (cur_step >= limit)
+            break if (start > limit) && (cur_step <= limit)
+            r << cur_step
+            cur_step += delta
+          end
+          r
+        end
+
+        register_op :eye do |_context, tensor, inputs|
+          rows, columns = inputs
+
+          Array.new(rows) do |i|
+            Array.new(columns) do |col|
+              if fp_type?(tensor.data_type)
+                i == col ? 1.0 : 0.0
+              else
+                i == col ? 1 : 0
+              end
+            end
+          end
+        end
+
+        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
+
+          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
+
+          if shape.is_a?(Array) && shape.size.zero?
+            func.call
+          else
+            shape = [shape.to_i] unless shape.is_a?(Array)
+
+            cache_key = "#{tensor.operation}_#{shape}"
+            if @context[:_cache].key?(cache_key)
+              @context[:_cache][cache_key]
+            else
+              generate_vector(shape, generator: func).tap do |v|
+                @context[:_cache][cache_key] = v
+              end
+            end
+          end
+        end
+
+        register_op :truncate do |_context, _tensor, inputs|
+          truncate(inputs[0], inputs[1])
+        end
+
+        register_op :rank do |_context, _tensor, inputs|
+          get_rank(inputs[0])
+        end
+
+        register_op :reshape do |_context, _tensor, inputs|
+          arr, new_shape = inputs
+
+          arr = [arr] unless arr.is_a?(Array)
+
+          flat_arr = arr.flatten
+          if new_shape.size.zero? && flat_arr.size == 1
+            flat_arr[0]
+          else
+            new_shape = TensorShape.fix_inferred_elements(new_shape, flat_arr.size)
+            TensorShape.reshape(flat_arr, new_shape)
+          end
+        end
+
+        register_op :pad do |context, tensor, inputs|
+          p = complete_eval(tensor.options[:paddings], context)
+
+          arr_pad(inputs[0], p, tensor.data_type)
+        end
+
+        register_op :tile do |_context, _tensor, inputs|
+          input, multiples = inputs
+          rank = get_rank(input)
+          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)
+          tile.nil? ? [] : tile
+        end
+
+        register_op :cond, noop: true do |context, tensor, inputs|
+          pred = global_eval(tensor, tensor.options[:pred], context)
+
+          if all_true?(pred)
+            global_eval(tensor, inputs[0], context)
+          else
+            global_eval(tensor, inputs[1], context)
+          end
+        end
+
+        register_op %i[select where] do |context, tensor, inputs|
+          pred = complete_eval(tensor.options[:pred], context)
+          call_3way_vector_op(pred, inputs[0], inputs[1], context, ->(t, u, v) { t ? u : v })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+require 'chunky_png'
+
+module TensorStream
+  module ImagesOps
+    def ImagesOps.included(klass)
+      klass.class_eval do
+        register_op :decode_png do |_context, tensor, inputs|
+          content = inputs[0]
+          channels = tensor.options[:channels]
+          channels = 4 if channels.zero?
+
+          image = ChunkyPNG::Image.from_blob(content)
+
+          image.grayscale! if channels == 1
+          image_data = image.pixels.collect do |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
+            
+            if fp_type?(tensor.data_type)
+              color_values.map! { |v| v.to_f }
+            end
+
+            color_values
+          end
+          TensorShape.reshape(image_data.flatten, [image.height, image.width, channels])
+        end
+
+        register_op :encode_png do |_context, tensor, inputs|
+          image_data = inputs[0]
+          height, width, channels = shape_eval(image_data)
+
+          png = ChunkyPNG::Image.new(width, height)
+          image_data.each_with_index do |rows, h_index|
+            rows.each_with_index do |p_data, w_index|
+              if channels == 4
+                png[w_index, h_index] = ChunkyPNG::Color.rgba(p_data[0], p_data[1], p_data[2], p_data[3])
+              elsif channels == 3
+                png[w_index, h_index] = ChunkyPNG::Color.rgb(p_data[0], p_data[1], p_data[2])
+              elsif channels == 1
+                png[w_index, h_index] = ChunkyPNG::Color.rgb(p_data[0], p_data[0], p_data[0])
+              end
+            end
+          end
+          png.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -138,6 +138,117 @@ module TensorStream
         register_op :tanh_grad, no_eval: true do |context, _tensor, inputs|
           call_op(:tanh_grad, inputs[0], context, ->(t, _b) { 1 - Math.tanh(t) * Math.tanh(t) })
         end
+
+        register_op(%i[argmax arg_max]) do |_context, tensor, inputs|
+          axis = tensor.options[:axis] || 0
+          rank = get_rank(inputs[0])
+          raise TensorStream::InvalidArgumentError, "Expected dimension in the range [#{-rank},#{rank}) but got #{axis}" if axis < -rank || axis >= rank
+          get_op_with_axis(inputs[0], axis, 0, tensor.data_type)
+        end
+
+        register_op(%i[argmin arg_min]) do |_context, tensor, inputs|
+          axis = tensor.options[:axis] || 0
+          rank = get_rank(inputs[0])
+          raise TensorStream::InvalidArgumentError, "Expected dimension in the range [#{-rank},#{rank}) but got #{axis}" if axis < -rank || axis >= rank
+          get_op_with_axis(inputs[0], axis, 0, tensor.data_type, ->(a, b) { a < b })
+        end
+
+        register_op :cumprod do |context, tensor, inputs|
+          x = inputs[0]
+          c = fp_type?(tensor.data_type) ? 1.0 : 1
+          reverse_option = tensor.options[:reverse]
+          exclusive = tensor.options[:exclusive]
+
+          func = lambda do |arr|
+            return c if arr.nil?
+            count = arr.size
+
+
+            arr = arr.reverse if reverse_option
+            arr = [1] + arr if exclusive
+
+            start_prod = arr[0]
+            mapped = arr[1...count].map do |v|
+              start_prod = vector_op(start_prod, v, ->(a, b) { a * b })
+            end
+
+            arr = [arr[0]] + mapped
+            reverse_option ? arr.reverse : arr
+          end
+          reduction(context, tensor, func)
+        end
+
+        register_op :sum, noop: true do |context, tensor, _inputs|
+          func = lambda do |arr|
+            reduced_val = arr[0]
+            arr[1..arr.size].each do |v|
+              reduced_val = vector_op(reduced_val, v, ->(t, u) { t + u })
+            end
+            reduced_val
+          end
+
+          reduction(context, tensor, func)
+        end
+
+        register_op :prod, noop: true do |context, tensor, _inputs|
+          c = fp_type?(tensor.data_type) ? 1.0 : 1
+          func = lambda do |arr|
+            return c if arr.nil?
+
+            reduced_val = arr[0]
+            arr[1..arr.size].each do |v|
+              reduced_val = vector_op(reduced_val, v, ->(a, b) { a * b })
+            end
+            reduced_val
+          end
+
+          reduction(context, tensor, func)
+        end
+
+        register_op :sigmoid_grad, no_eval: true do |context, tensor, inputs|
+          a, b = inputs
+          call_vector_op(tensor, :sigmoid_grad, a, b, context, ->(t, u) { u * sigmoid(t) * (1 - sigmoid(t)) })
+        end
+
+        register_op :mean, noop: true do |context, tensor, _inputs|
+          c = fp_type?(tensor.data_type) ? 0.0 : 0
+          func = lambda do |arr|
+            return c if arr.nil?
+
+            reduced_val = arr[0]
+            arr[1..arr.size].each do |v|
+              reduced_val = vector_op(reduced_val, v, ->(a, b) { a + b })
+            end
+
+            vector_op(reduced_val, nil, ->(a, _b) { a / arr.size })
+          end
+
+          reduction(context, tensor, func)
+        end
+
+        register_op :mat_mul do |_context, tensor, inputs|
+          matrix_a, matrix_b = inputs
+          rank_a = get_rank(matrix_a)
+          rank_b = get_rank(matrix_b)
+          raise "#{tensor.inputs[0].name} rank must be greater than 1" if rank_a < 2
+          raise "#{tensor.inputs[1].name} rank must be greater than 1" if rank_b < 2
+
+          matrix_a = matrix_a.transpose if tensor.options[:transpose_a]
+          matrix_b = matrix_b.transpose if tensor.options[:transpose_b]
+
+          # check matrix dimensions
+          raise "incompatible shape sizes for matrix multiplication (#{matrix_a[0].size} != #{matrix_b.size}) #{shape_eval(matrix_a)} vs #{shape_eval(matrix_b)}" if matrix_a[0].size != matrix_b.size
+
+          (Matrix[*matrix_a] * Matrix[*matrix_b]).to_a
+        end
+
+        register_op %i[max maximum], noop: true do |context, tensor, inputs|
+          call_vector_op(tensor, :max, inputs[0], inputs[1], context, ->(t, u) { [t, u].max })
+        end
+
+        register_op %i[min minimum], noop: true do |context, tensor, inputs|
+          call_vector_op(tensor, :min, inputs[0], inputs[1], context, ->(t, u) { [t, u].min })
+        end
       end
     end
   end