tensor_stream 0.1.0

data/lib/tensor_stream/ops.rb

@@ -0,0 +1,225 @@
+module TensorStream
+  module Ops
+    FLOATING_POINT_TYPES = %w[float32 float64].map(&:to_sym)
+    NUMERIC_TYPES = %w[int32 int64 float32 float64].map(&:to_sym)
+
+    def argmax(input, axis = nil, name: nil, dimension: nil, output_type: :int32)
+      op(:argmax, input, nil, axis: axis, name: name, dimension: dimension, data_type: output_type)
+    end
+
+    def gradients(ys, xs, grad_ys: nil,
+      name: 'gradients',
+      colocate_gradients_with_ops: false,
+      gate_gradients: false,
+      aggregation_method: nil,
+      stop_gradients: nil
+      )
+      options = { stop_gradients: stop_gradients}
+      op(:gradients, ys, xs, options)
+    end
+
+    def random_uniform(shape, dtype: :float32, minval: 0, maxval: 1, seed: nil, name: nil)
+      options = {shape: shape, dtype: dtype, minval: minval, maxval: maxval, seed: seed, name: name}
+      op(:random_uniform, nil, nil, options)
+    end
+
+    def random_normal(shape, dtype: :float32, mean: 0.0, stddev: 1.0, seed: nil, name: nil)
+      options = {shape: shape, dtype: dtype, mean: mean, stddev: stddev, seed: seed, name: name}
+      op(:random_normal, nil, nil, options)
+    end
+
+    def stop_gradient(tensor, options = {})
+      op(:stop_gradient, tensor, nil, options)
+    end
+
+    def eye(num_rows, num_columns: nil, dtype: :float32, name: nil)
+      op(:eye, num_rows, num_columns || num_rows, data_type: dtype, name: name, preserve_params_type: true)
+    end
+
+    def shape(input, name: nil, out_type: :int32)
+      op(:shape, input, nil, name: name)
+    end
+
+    def rank(input, name: nil)
+      op(:rank, input, name: name)
+    end
+
+    def zeros_initializer(options = {})
+      op(:zeros, nil, nil, options)
+    end
+  
+    def slice(input, start, size, name: nil)
+      op(:slice, input, start, size: size, name: name)
+    end
+  
+    def zeros(shape, dtype: :float32, name: nil)
+      op(:zeros, shape, nil, data_type: dtype, name: name)
+    end
+  
+    def ones(shape, dtype: :float32, name: nil)
+      op(:ones, shape, nil, data_type: dtype, name: name)
+    end
+  
+    def less(a, b, name: nil)
+      op(:less, a, b, name: name)
+    end
+  
+    def greater(a, b, name: nil)
+      op(:greater, a, b, name: name)
+    end
+  
+    def reduce_mean(input_tensor, axis = nil, keepdims: false, name: nil)
+      op(:reduce_mean, input_tensor, nil, axis: axis, keepdims: keepdims, name: name)
+    end
+
+    def reduce_sum(input_tensor, axis = nil, keepdims: false, name: nil)
+      op(:reduce_sum, input_tensor, nil, axis: axis, keepdims: keepdims, name: name)
+    end
+  
+    def reduce_prod(input, axis = nil, keepdims: false, name: nil)
+      op(:reduce_prod, input, nil, axis: axis, keepdims: keepdims, name: name)
+    end
+  
+    def concat(values, axis, name: 'concat')
+      op(:concat, values, nil, axis: axis, name: name)
+    end
+  
+    def reshape(tensor, shape, name: nil)
+      op(:reshape, tensor, shape, name: name)
+    end
+  
+    def square(tensor, name: nil)
+      op(:square, tensor, nil, name: name)
+    end
+  
+    def cond(pred, true_fn, false_fn, name: nil)
+      op(:cond, true_fn, false_fn, pred: pred, name: name)
+    end
+
+    def where(condition, x = nil, y = nil, name: nil)
+      op(:where, x, y, pred: condition)
+    end
+  
+    def add(a, b, name: nil)
+      op(:add, a, b, name: name)
+    end
+  
+    def sub(a, b, name: nil)
+      op(:sub, a, b, name: name)
+    end
+
+    def max(a, b, name: nil)
+      check_allowed_types(a, NUMERIC_TYPES)
+      check_allowed_types(b, NUMERIC_TYPES)
+
+      op(:max, a, b, name: name)
+    end
+
+    def cast(input, dtype, name: nil)
+      op(:cast, input, nil, data_type: dtype, name: name)
+    end
+  
+    def print(input, data, message: nil, name: nil)
+      op(:print, input, data, message: message, name: name)
+    end
+  
+    def negate(a, options = {})
+      op(:negate, a, nil, options)
+    end
+  
+    def equal(a, b, name: nil)
+      op(:equal, a, b, name: name)
+    end
+
+    def not_equal(a, b, name: nil)
+      op(:not_equal, a, b, name: name)
+    end
+  
+    def zeros_like(tensor, dtype: nil, name: nil)
+      op(:zeros_like, tensor, nil, data_type: dtype, name: name)
+    end
+
+    def ones_like(tensor, dtype: nil, name: nil)
+      op(:ones_like, tensor, nil, data_type: dtype, name: name)
+    end
+  
+    def identity(input, name: nil)
+      op(:identity, input, nil, name: name)
+    end
+  
+    def multiply(a, b, name: nil)
+      op(:mul, a, b, name: name)
+    end
+  
+    def pow(a, e, name: nil)
+      op(:pow, a, e, name: name)
+    end
+  
+    def abs(x, name: nil)
+      op(:abs, x, nil, name: name)
+    end
+  
+    def sign(x, name: nil)
+      op(:sign, x, nil, name: name)
+    end
+  
+    def sin(a, options = {})
+      options[:data_type] ||= :float32
+      check_allowed_types(a, FLOATING_POINT_TYPES)
+      op(:sin, a, nil, options)
+    end
+  
+    def cos(a, options = {})
+      options[:data_type] ||= :float32
+      check_allowed_types(a, FLOATING_POINT_TYPES)
+      op(:cos, a, nil, options)
+    end
+  
+    def tan(a, options = {})
+      options[:data_type] ||= :float32
+      check_allowed_types(a, FLOATING_POINT_TYPES)
+      op(:tan, a, nil, options)
+    end
+  
+    def tanh(a, options = {})
+      options[:data_type] ||= :float32
+      check_allowed_types(a, FLOATING_POINT_TYPES)
+      op(:tanh, a, nil, options)
+    end
+  
+    def sqrt(a, name: nil)
+      options = {
+        data_type: a.data_type,
+        name: name
+      }
+      check_allowed_types(a, FLOATING_POINT_TYPES)
+      op(:sqrt, a, nil, options)
+    end
+  
+    def log(input, options= {})
+      options[:data_type] ||= :float32
+      check_allowed_types(input, FLOATING_POINT_TYPES)
+      op(:log, input, nil, options)
+    end
+  
+    def exp(a, options = {})
+      options[:data_type] ||= :float32
+      check_allowed_types(a, FLOATING_POINT_TYPES)
+      op(:exp, a, nil, options)
+    end
+
+    def matmul(input_a, input_b, transpose_a: false,
+                                 transpose_b: false,
+                                 name: nil)
+      op(:matmul, input_a, input_b, transpose_a: transpose_a, transpose_b: transpose_b, name: name)
+    end
+
+    def transpose(tensor, perm: nil, name: 'transpose')
+      op(:transpose, tensor, nil, perm: perm, name: name)
+    end
+
+    def pad(tensor, paddings, mode: 'CONSTANT', name: nil)
+      op(:pad, tensor, nil, paddings: paddings, mode: mode, name: name)
+    end
+  end
+end

data/lib/tensor_stream/placeholder.rb

@@ -0,0 +1,21 @@
+module TensorStream
+  class Placeholder < Tensor
+    def initialize(data_type, rank, shape, options = {})
+      @data_type = data_type
+      @rank = rank
+      @shape = TensorShape.new(shape, rank)
+      @value = nil
+      @is_const = false
+      @source = set_source(caller_locations)
+      @graph = options[:graph] || TensorStream.get_default_graph
+      @name = options[:name] || build_name
+      @graph.add_node(self)
+    end
+
+    private
+
+    def build_name
+      "Placeholder#{Tensor.placeholder_name}:#{@rank}"
+    end
+  end
+end

data/lib/tensor_stream/session.rb

@@ -0,0 +1,66 @@
+module TensorStream
+  class Session
+    def initialize(evaluator = :ruby_evaluator, thread_pool_class: Concurrent::ImmediateExecutor)
+      @evaluator_class = Object.const_get("TensorStream::Evaluator::#{camelize(evaluator.to_s)}")
+      @thread_pool = thread_pool_class.new
+    end
+
+    def self.default_session
+      @session ||= Session.new
+    end
+
+    def last_session_context
+      @last_session_context
+    end
+
+    def run(*args)
+      options = if args.last.is_a?(Hash)
+        args.pop
+      else
+        {}
+      end
+      context = {}
+
+      # scan for placeholders and assign value
+      options[:feed_dict].keys.each do |k|
+        if k.is_a?(Placeholder)
+          context[k.name.to_sym] = options[:feed_dict][k]
+        end
+      end if options[:feed_dict]
+      
+      evaluator = @evaluator_class.new(self, context.merge!(retain: options[:retain]), thread_pool: @thread_pool)
+
+      execution_context = {}
+      result = args.collect { |e| evaluator.run(e, execution_context) }
+      @last_session_context = context
+      result.size == 1 ? result.first : result
+    end
+
+    def dump_internal_ops(tensor)
+      dump_ops(tensor, ->(k, n) { n.is_a?(Tensor) && n.internal? } )
+    end
+
+    def dump_user_ops(tensor)
+      dump_ops(tensor, ->(k, n) { n.is_a?(Tensor) && !n.internal? } )
+    end
+
+    def dump_ops(tensor, selector)
+      graph = tensor.graph
+      graph.nodes.select { |k,v| selector.call(k, v) }.collect do |k, node|
+        next unless @last_session_context[node.name]
+        "#{k} #{node.to_math(true, 1)} = #{@last_session_context[node.name]}"
+      end.compact
+    end
+
+    private
+
+    def camelize(string, uppercase_first_letter = true)
+      if uppercase_first_letter
+        string = string.sub(/^[a-z\d]*/) { $&.capitalize }
+      else
+        string = string.sub(/^(?:(?=\b|[A-Z_])|\w)/) { $&.downcase }
+      end
+      string.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }.gsub('/', '::')
+    end
+  end
+end

data/lib/tensor_stream/tensor.rb

@@ -0,0 +1,317 @@
+require 'ostruct'
+
+module TensorStream
+  class Tensor
+    include OpHelper
+
+    attr_accessor :name, :data_type, :shape, :rank, :native_buffer, :is_const, :value, :breakpoint, :internal, :source, :given_name, :graph
+
+    def self.const_name
+      @const_counter ||= 0
+
+      name = if @const_counter == 0
+        ""
+      else
+        "_#{@const_counter}"
+      end
+
+      @const_counter += 1
+      
+      name
+    end
+
+    def self.var_name
+      @var_counter ||= 0
+      @var_counter += 1
+
+      return "" if @var_counter == 1
+      return "_#{@var_counter}"
+    end
+
+    def self.placeholder_name
+      @placeholder_counter ||= 0
+      @placeholder_counter += 1
+
+      return "" if @placeholder_counter == 1
+      return "_#{@placeholder_counter}"
+    end
+
+    def initialize(data_type, rank, shape, options = {})
+      @data_type = data_type
+      @rank = rank
+      @breakpoint = false
+      @shape = TensorShape.new(shape, rank)
+      @value = nil
+      @source = set_source(caller_locations)
+      @is_const = options[:const] || false
+      @internal = options[:internal]
+      @graph = options[:graph] || TensorStream.get_default_graph
+      @name = options[:name] || build_name
+      @given_name = @name
+
+      if options[:value]
+        if options[:value].kind_of?(Array)
+          # check if single dimenstion array is passed
+          if shape.size >= 2 && options[:value].size > 0 && !options[:value][0].kind_of?(Array)
+            options[:value] = reshape(options[:value], shape.reverse.dup)
+          end
+
+          @value = options[:value].collect do |v|
+            v.kind_of?(Tensor) ? Tensor.cast_dtype(v, data_type) : v
+          end
+        elsif shape.size > 0
+          @value = reshape(Tensor.cast_dtype(options[:value], @data_type), shape.dup)
+        else
+          @value = Tensor.cast_dtype(options[:value], @data_type)
+        end
+      end
+
+      @graph.add_node(self)
+    end
+
+    def internal?
+      !!@internal
+    end
+
+    def dtype
+      @data_type
+    end
+
+    def self.reset_counters
+      @const_counter = 0
+      @var_counter = 0
+      @placeholder_counter = 0
+    end
+
+    def build_buffer
+      @native_buffer = if @data_type == :float32 && @rank == 2
+        NArray.sfloat(@shape.cols * @shape.rows)
+      elsif @data_type == :float32 && @rank == 0
+        NArray.sfloat(1)
+      else
+        raise "Invalid data type #{@data_type}"
+      end
+    end
+
+    def +(operand)
+      TensorStream::Operation.new(:add, self, auto_wrap(operand))
+    end
+
+    def [](index)
+      TensorStream::Operation.new(:index, self, index)
+    end
+
+    def *(operand)
+      TensorStream::Operation.new(:mul, self, auto_wrap(operand))
+    end
+
+    def **(operand)
+      TensorStream::Operation.new(:pow, self, auto_wrap(operand))
+    end
+
+    def /(operand)
+      TensorStream::Operation.new(:div, self, auto_wrap(operand))
+    end
+
+    def -(operand)
+      TensorStream::Operation.new(:sub, self, auto_wrap(operand))
+    end
+
+    def -@
+      TensorStream::Operation.new(:negate, self, nil)
+    end
+
+    def ==(operand)
+      op(:equal, self, operand)
+    end
+
+    def <(operand)
+      op(:less, self, operand)
+    end
+
+    def !=(operand)
+      op(:not_equal, self, operand)
+    end
+
+    def <=(operand)
+      op(:less_equal, self, operand)
+    end
+
+    def >(operand)
+      op(:greater, self, operand)
+    end
+
+    def >=(operand)
+      op(:greater_equal, self, operand)
+    end
+
+    def collect(&block)
+      @value.collect(&block)
+    end
+
+    def to_s
+      @name
+    end
+
+    # def to_ary
+    #   if rank == 2
+    #     @native_buffer.to_a.each_slice(shape.cols).collect { |slice| slice }
+    #   else
+    #     raise "Invalid rank"
+    #   end
+    # end
+
+    # open cl methods
+    def open_cl_buffer(context)
+      @cl_buffer ||= context.create_buffer(@native_buffer.size * @native_buffer.element_size, :flags => OpenCL::Mem::COPY_HOST_PTR, :host_ptr => @native_buffer)
+    end
+
+    def sync_cl_buffer(queue, events = [])
+      queue.enqueue_read_buffer(@cl_buffer, @native_buffer, :event_wait_list => events)
+    end
+
+    def eval(options = {})
+      Session.default_session.run(self, options)
+    end
+
+    def to_h
+      {
+        name: @name,
+        value: hashify_tensor(@value),
+        dtype: @data_type,
+        shape: @shape,
+        const: !!is_const,
+      }
+    end
+
+    def to_i
+      @value
+    end
+
+    def to_a
+      @value
+    end
+
+    def to_f
+      @value
+    end
+
+    def first
+      op(:index, self, 0)
+    end
+
+    def to_math(name_only = false, max_depth = 99)
+      return @name if max_depth==0 || name_only || @value.nil?
+      
+      if @value.kind_of?(Array)
+        @value.collect { |v| v.kind_of?(Tensor) ? v.to_math(name_only, max_depth - 1) : v }
+      else
+        is_const ? @value : @name
+      end
+    end
+
+    def auto_math(tensor, name_only = false, max_depth = 99)
+      tensor.kind_of?(Tensor) ? tensor.to_math(name_only, max_depth) : tensor
+    end
+
+    def self.detect_type(value)
+      dtype = if value.is_a?(String)
+        :string
+      elsif value.is_a?(Float)
+        :float32
+      elsif value.is_a?(Integer)
+        :int32
+      elsif value.is_a?(Array)
+        :array
+      else
+        :float32
+      end
+    end
+
+    def self.cast_dtype(val, dtype)
+      return val if val.is_a?(Tensor)
+
+      if val.is_a?(Array)
+        return val.collect do |v|
+          cast_dtype(v, dtype)
+        end
+      end
+
+      case dtype.to_sym
+      when :float32, :float
+        if !!val == val
+          val ? 1.0 : 0.0
+        else
+          val.to_f
+        end
+      when :string
+        val.to_s
+      when :int32, :int16
+        if !!val == val
+          val ? 1 : 0
+        else
+          val.to_i
+        end
+      when :boolean
+        !!val
+      when :unknown
+        val
+      else
+        fail "unknown data_type #{dtype} passed"
+      end
+    end
+
+    def breakpoint!(&block)
+      @breakpoint = block
+      self
+    end
+
+    protected
+
+    def set_source(trace)
+      trace.reject { |c| c.to_s.include?(File.join("lib","tensor_stream")) }.first
+    end
+
+    def hashify_tensor(tensor)
+      if tensor.kind_of?(Tensor) 
+        tensor.to_h
+      elsif tensor.kind_of?(Array)
+        tensor.collect do |t| hashify_tensor(t) end
+      else
+        tensor
+      end
+    end
+
+    def reshape(arr, shape)
+      if arr.is_a?(Array)
+        return arr if shape.size < 2
+        slice = shape.shift
+        arr.each_slice(slice).collect do |s|
+          reshape(s, shape)
+        end
+      else
+        return arr if shape.size < 1
+        slice = shape.shift
+        return arr if slice.nil?
+
+        slice.times.collect do |s|
+          reshape(arr, shape.dup)
+        end
+      end
+    end
+
+    def auto_wrap(operand)
+      return auto_wrap(operand.call) if operand.is_a?(Proc)
+
+      if !operand.is_a?(Tensor)
+        i_cons(operand, dtype: @data_type || Tensor.detect_type(operand))
+      else
+        operand
+      end
+    end
+
+    def build_name
+      "#{@is_const ? "Const#{Tensor.const_name}:#{@rank}" : "Variable#{Tensor.var_name}:#{@rank}"}"
+    end
+  end
+end