tensor_stream-opencl 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80aa4c8e84193ba879b9c7863b8103cd345b6591ec0a534162c53965609f1bd1
-  data.tar.gz: 88840b00a6c4a71540d837a4e20378cf2aafe4efda1990d2f978f401cae35c83
+  metadata.gz: 03fcb3bb50485dd601bf17b58f216209c86fb20aeb6c0b61b23144b5d644efaa
+  data.tar.gz: 7b96f90b902ff747b74575be13015e52cfda0f4104273e14eca5bee90fc1a405
 SHA512:
-  metadata.gz: c8c74bbc136ea42c8a01506a0b606bbde8a83a922026caef917d3eb8dbad1c41298fea37040e846ea1eee0683af35f0dd24df7d5449dac75c3e175ed07d94d49
-  data.tar.gz: 2235974d1d8dc5cfe9117991cb5ea4dff2b75409e26e20b197414613484a68b482c41796ff74699b041dbcf5f963721ffffa2f5f1a9f28e1f05b5bb96a081039
+  metadata.gz: 2916b8a053754bfd58594cef0680d79d12d38332d99d28a3cded71028c58b7a35ec3a6480b6b80f486aa2a59b617f89ee1b534bf00f51343e4827df250ff92f4
+  data.tar.gz: 308153886efa111da2251b31f4a6b5d4ad610336681e3d94b1bb9b055cf8a7e97ad9460271a5ae14e738410a77fc75d8669636732909af2ff574f0e907cad44b

data/README.md

@@ -1,7 +1,9 @@
+[![Gem Version](https://badge.fury.io/rb/tensor_stream-opencl.svg)](https://badge.fury.io/rb/tensor_stream-opencl)
+
 # TensorStream::Opencl
 
 This gem provides an OpenCL backend for TensorStream (https://github.com/jedld/tensor_stream). OpenCL is an open standard
-that allows running compute applications on heterogenous platforms like CPUs and GPUs.
+that allows running compute applications on heterogenous platforms like CPUs and GPUs. For certain neural network implementations, like deep neural networks GPU acceleration can dramatically speedup computation.
 
 ## Installation
 
@@ -37,7 +39,47 @@ Or install it yourself as:
 
 ## Usage
 
-Simply including this gem will allow tensor_stream to automatically select opencl devices for use in your computation
+If using a Gemfile or a framework like rails, simply including this gem will allow tensor_stream to automatically select opencl devices for use in your computation. Otherwise you can do:
+
+```ruby
+require 'tensor_stream/opencl'
+```
+
+You can check for available OpenCL devices via'
+
+```ruby
+TensorStream::Evaluator::OpenclEvaluator.query_supported_devices
+
+TensorStream::Evaluator::OpenclEvaluator.query_supported_devices.map(&:native_device)
+# => [#<OpenCL::Device: Intel(R) Core(TM) i5-5575R CPU @ 2.80GHz (4294967295)>, #<OpenCL::Device: Intel(R) Iris(TM) Pro Graphics 6200 (16925952)>]
+```
+
+## Device placement control
+
+You can place operations on certain devices using ts.device:
+
+```ruby
+require 'tensor_stream/opencl'
+
+ts = TensorStream
+# For the first GPU
+ts.device('/device:GPU:0') do
+  a = ts.placeholder(:float32, shape: [DIMEN, DIMEN])
+  b = ts.placeholder(:float32, shape: [DIMEN, DIMEN])
+  # Compute A^n and B^n and store results in c1
+  c1 << matpow(a, n)
+  c1 << matpow(b, n)
+end
+
+# For the second GPU
+ts.device('/device:GPU:1') do
+  a = ts.placeholder(:float32, shape: [DIMEN, DIMEN])
+  b = ts.placeholder(:float32, shape: [DIMEN, DIMEN])
+  # Compute A^n and B^n and store results in c1
+  c1 << matpow(a, n)
+  c1 << matpow(b, n)
+end
+```
 
 ## Development
 

data/lib/tensor_stream/opencl/array_ops.rb

@@ -202,12 +202,33 @@ module TensorStream
             output_buffer
           end
 
+          register_op :squeeze do |context, tensor, inputs|
+            arr = inputs[0]
+            shape = inputs[0].shape.dup
+            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
+
+            OpenCLBuffer.new(name: tensor.name, data_type: tensor.data_type,
+              shape: shape.compact, buffer: arr.buffer,
+              cl_buffer: arr.cl_buffer,
+              op: arr.op)
+          end
+
           register_op :stack do |_context, tensor, inputs|
             axis = tensor.options[:axis] || 0
             shape = inputs[0].shape
             rank = shape.size + 1
             elem_size = shape.empty? ? 1 : shape.reduce(:*)
-
             new_shape = [inputs.size]
             shape.inject(new_shape) { |ns, s| ns << s }
 
@@ -313,8 +334,8 @@ module TensorStream
           end
 
           register_op :shape_n do |_context, tensor, inputs|
-            shapes = inputs.collect do |input|
-              wrap_opencl(input.shape, name: tensor.name, data_type: tensor.data_type)
+            shapes = inputs.collect.with_index do |input, index|
+              wrap_opencl(input.shape, name: "#{tensor.name}_#{index}", data_type: tensor.data_type)
             end
             TensorStream::Evaluator::OutputGroup.new(shapes, shapes.map { tensor.data_type })
           end

data/lib/tensor_stream/opencl/nn_ops.rb

@@ -285,6 +285,39 @@ module TensorStream
             output_buffer
           end
 
+          register_op :sparse_softmax_cross_entropy_with_logits do |context, tensor, inputs|
+            a = inputs[0] # logits
+            labels = read_final_result(complete_eval(inputs[1], context)) # labels
+            labels = last_axis(labels)
+            num_classes = a.shape.last
+
+            labels = labels.map do |l|
+              one_hot = Array.new(num_classes) { 0 }
+              one_hot[l] = 1
+              one_hot
+            end
+
+            b = wrap_opencl(labels, data_type: inputs[0].data_type, name: "#{tensor.name}_label")
+ 
+            event_wait_list = build_event_wait_list(inputs)
+            dtype = tensor.data_type
+            output_buffer = _create_result_buffer(tensor.data_type, a.shape, tensor.name)
+            output_buffer_backprop = _create_result_buffer(tensor.data_type, a.shape, "#{tensor.name}_2")
+            rank = a.shape.size - 1
+            m, n = a.shape
+            work_group = [m]
+            n = m if n.nil?
+            cl_n = OpenCL::Int1.new(n || 1)
+
+            event = _cl_program("softmax_cross", dtype: dtype).send(:"softmax_cross_#{dtype}", _opencl_queue, work_group, cl_n, a.cl_buffer, b.cl_buffer,
+                                 output_buffer.cl_buffer, output_buffer_backprop.cl_buffer, event_wait_list: event_wait_list)
+            output_buffer.op = event
+            output_buffer_backprop.op = event
+
+            loss = reduction(context, tensor, output_buffer, rank, :sum)
+            TensorStream::Evaluator::OutputGroup.new([loss, output_buffer_backprop],  [tensor.inputs[0].data_type, tensor.inputs[0].data_type])
+          end
+
           register_op :softmax_grad do |_context, tensor, inputs|
             a, grad = inputs
 

data/lib/tensor_stream/opencl/opencl_evaluator.rb

@@ -413,9 +413,11 @@ module TensorStream
         end
       rescue EvaluatorExcecutionException => e
         _opencl_queue.finish # dump queue
+        puts e.message
         raise e, "error #{e.message} while evaluating #{tensor.name} : #{tensor.to_math(true, 1)} defined at #{tensor.source}"
       rescue TensorStreamError => e
         _opencl_queue.finish # dump queue
+        puts e.message
         raise e, "error #{e.message} while evaluating #{tensor.name} : #{tensor.to_math(true, 1)} defined at #{tensor.source}"
       rescue StandardError => e
         _opencl_queue.finish # dump queue

data/lib/tensor_stream/opencl/version.rb

@@ -1,5 +1,5 @@
 module TensorStream
   module Opencl
-    VERSION = "0.2.0"
+    VERSION = "0.2.1"
   end
 end

data/samples/rnn.rb

@@ -8,7 +8,7 @@
 require "bundler/setup"
 require 'tensor_stream'
 require 'tensor_stream/opencl'
-require 'pry-byebug'
+# require 'pry-byebug'
 
 
 tf = TensorStream
@@ -75,7 +75,7 @@ losses = logits_series.zip(labels_series).collect do |logits, labels|
 end
 total_loss = tf.reduce_mean(losses)
 
-train_step = TensorStream::Train::AdagradOptimizer.new(0.3).minimize(total_loss)
+train_step = TensorStream::Train::AdagradOptimizer.new(0.1).minimize(total_loss)
 
 puts "#{tf.get_default_graph.nodes.keys.size} nodes created"
 zeros_state = tf.zeros([batch_size, state_size]).eval

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tensor_stream-opencl
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Joseph Dayo
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-05 00:00:00.000000000 Z
+date: 2018-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler