tensorflow-ruby 0.2.0

data/lib/tensorflow/stream_executor/dnn_pb.rb

@@ -0,0 +1,90 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: stream_executor/dnn.proto
+
+require 'google/protobuf'
+
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_file("stream_executor/dnn.proto", :syntax => :proto3) do
+    add_message "stream_executor.dnn.TensorDescriptorProto" do
+      repeated :dimensions, :int64, 1
+      optional :data_type, :enum, 2, "stream_executor.dnn.DataType"
+      oneof :layout_oneof do
+        optional :data_layout, :enum, 3, "stream_executor.dnn.DataLayout"
+        optional :filter_layout, :enum, 4, "stream_executor.dnn.FilterLayout"
+      end
+    end
+    add_message "stream_executor.dnn.AlgorithmProto" do
+      optional :algo_id, :int64, 1
+      optional :math_type, :enum, 2, "stream_executor.dnn.AlgorithmProto.MathType"
+    end
+    add_enum "stream_executor.dnn.AlgorithmProto.MathType" do
+      value :DEFAULT_MATH, 0
+      value :TENSOR_OP_MATH, 1
+    end
+    add_message "stream_executor.dnn.ConvolutionDescriptorProto" do
+      repeated :paddings, :int64, 1
+      repeated :strides, :int64, 2
+      repeated :dilations, :int64, 3
+      optional :compute_mode, :enum, 4, "stream_executor.dnn.DataType"
+      optional :group_count, :int32, 5
+      optional :convolution_mode, :enum, 6, "stream_executor.dnn.ConvolutionMode"
+      optional :name, :string, 7
+    end
+    add_enum "stream_executor.dnn.DataType" do
+      value :kFloat, 0
+      value :kDouble, 1
+      value :kHalf, 2
+      value :kInt8, 3
+      value :kInt32, 4
+    end
+    add_enum "stream_executor.dnn.DataLayout" do
+      value :kYXDepthBatch, 0
+      value :kYXBatchDepth, 1
+      value :kBatchYXDepth, 2
+      value :kBatchDepthYX, 3
+      value :kBatchDepthYX4, 4
+    end
+    add_enum "stream_executor.dnn.FilterLayout" do
+      value :kOutputInputYX, 0
+      value :kOutputYXInput, 1
+      value :kOutputInputYX4, 2
+      value :kInputYXOutput, 3
+      value :kYXInputOutput, 4
+    end
+    add_enum "stream_executor.dnn.ActivationMode" do
+      value :kNone, 0
+      value :kSigmoid, 1
+      value :kRelu, 2
+      value :kRelu6, 3
+      value :kReluX, 4
+      value :kTanh, 5
+      value :kBandPass, 6
+    end
+    add_enum "stream_executor.dnn.ConvolutionMode" do
+      value :CROSS_CORRELATION, 0
+      value :CONVOLUTION, 1
+    end
+    add_enum "stream_executor.dnn.ConvolutionKind" do
+      value :INVALID, 0
+      value :FORWARD, 1
+      value :BACKWARD_FILTER, 2
+      value :BACKWARD_DATA, 3
+      value :FORWARD_BIAS_ACTIVATION, 4
+    end
+  end
+end
+
+module StreamExecutor
+  module Dnn
+    TensorDescriptorProto = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("stream_executor.dnn.TensorDescriptorProto").msgclass
+    AlgorithmProto = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("stream_executor.dnn.AlgorithmProto").msgclass
+    AlgorithmProto::MathType = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("stream_executor.dnn.AlgorithmProto.MathType").enummodule
+    ConvolutionDescriptorProto = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("stream_executor.dnn.ConvolutionDescriptorProto").msgclass
+    DataType = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("stream_executor.dnn.DataType").enummodule
+    DataLayout = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("stream_executor.dnn.DataLayout").enummodule
+    FilterLayout = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("stream_executor.dnn.FilterLayout").enummodule
+    ActivationMode = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("stream_executor.dnn.ActivationMode").enummodule
+    ConvolutionMode = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("stream_executor.dnn.ConvolutionMode").enummodule
+    ConvolutionKind = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("stream_executor.dnn.ConvolutionKind").enummodule
+  end
+end

data/lib/tensorflow/strings.rb

@@ -0,0 +1,100 @@
+module Tensorflow
+  module Strings
+    class << self
+      def as_string(input, precision: nil, scientific: nil, shortest: nil, width: nil, fill: nil)
+        RawOps.as_string(input, precision: precision, scientific: scientific, shortest: shortest, width: width, fill: fill)
+      end
+
+      # def bytes_split
+      # end
+
+      # def format
+      # end
+
+      def join(inputs, separator: "")
+        RawOps.string_join(inputs, separator: separator, n: inputs.size)
+      end
+
+      def length(input, unit: "BYTE")
+        RawOps.string_length(input, unit: unit)
+      end
+
+      def lower(input)
+        RawOps.string_lower(input.encode('UTF-8'), encoding: 'utf-8')
+      end
+
+      # def ngrams
+      # end
+
+      def reduce_join(inputs, reduction_indices, keep_dims: nil, separator: nil)
+        RawOps.reduce_join(inputs, reduction_indices: reduction_indices, keep_dims: keep_dims, separator: separator)
+      end
+
+      def regex_full_match(input, pattern)
+        RawOps.regex_full_match(input, pattern: pattern)
+      end
+
+      def regex_replace(input, pattern, rewrite, replace_global: nil)
+        RawOps.regex_replace(input, pattern: pattern, rewrite: rewrite, replace_global: replace_global)
+      end
+
+      def split(split_dim, value, num_split: nil)
+        RawOps.split(split_dim: split_dim, value: value, num_split: num_split)
+      end
+
+      def strip(input)
+        RawOps.string_strip(input)
+      end
+
+      def substr(input, pos, len, unit: nil)
+        RawOps.substr(input, pos, len, unit: unit)
+      end
+
+      # def to_hash_bucket
+      # end
+
+      # def to_hash_bucket_fast
+      # end
+
+      # def to_hash_bucket_strong
+      # end
+
+      def to_number(input, out_type: :float)
+        RawOps.string_to_number(input, out_type: out_type)
+      end
+
+      def unicode_decode(input, input_encoding: nil, errors: nil, replacement_char: nil, replace_control_characters: nil)
+        RawOps.unicode_decode(input, input_encoding: input_encoding, errors: errors, replacement_char: replacement_char, replace_control_characters: replace_control_characters)
+      end
+
+      def unicode_decode_with_offsets(input, input_encoding: nil, errors: nil, replacement_char: nil, replace_control_characters: nil)
+        RawOps.unicode_decode_with_offsets(input, input_encoding: input_encoding, errors: errors, replacement_char: replacement_char, replace_control_characters: replace_control_characters)
+      end
+
+      def unicode_encode(input_values, input_splits, errors: nil, output_encoding: nil, replacement_char: nil)
+        RawOps.unicode_encode(input_values: input_values, input_splits: input_splits, errors: errors, output_encoding: output_encoding, replacement_char: replacement_char)
+      end
+
+      def unicode_script(input)
+        RawOps.unicode_script(input)
+      end
+
+      # def unicode_split
+      # end
+
+      # def unicode_split_with_offsets
+      # end
+
+      def unicode_transcode(input, input_encoding: nil, output_encoding: nil, errors: nil, replacement_char: nil, replace_control_characters: nil)
+        RawOps.unicode_transcode(input, input_encoding: input_encoding, output_encoding: output_encoding, errors: errors, replacement_char: replacement_char, replace_control_characters: replace_control_characters)
+      end
+
+      # def unsorted_segment_join
+      # end
+
+      def upper(input, encoding: "")
+        RawOps.string_upper(input, encoding: encoding)
+      end
+    end
+  end
+end

data/lib/tensorflow/summary.rb

@@ -0,0 +1,13 @@
+module Tensorflow
+  class Summary
+    def self.create_file_writer(logdir, max_queue: 10, flush_millis: 120_000, filename_suffix: '.v2', name: nil)
+      ResourceSummaryWriter.new(shared_name: name) do |writer|
+        RawOps.create_summary_file_writer(writer, logdir, max_queue, flush_millis, filename_suffix)
+      end
+    end
+
+    def self.all_v2_summary_ops
+      ExecutionContext.current.get_collection_ref(Graph::GraphKeys::SUMMARY_COLLECTION)
+    end
+  end
+end

data/lib/tensorflow/tensor.rb

@@ -0,0 +1,133 @@
+module Tensorflow
+  class Tensor
+    include Operators
+    include TensorMixin
+
+    def self.finalize(pointer)
+      proc do
+        FFI.TF_DeleteTensor(pointer)
+      end
+    end
+
+    def self.from_value(value, dtype: nil)
+      case value
+        when Tensor
+          value
+        when Graph::Operation
+          value
+        when Eager::TensorHandle
+          value.tensor
+        when Data::Dataset
+          value.variant_tensor
+        else
+          Tensor.new(value, dtype: dtype)
+      end
+    end
+
+    def self.from_proto(proto)
+      proto = proto.is_a?(TensorProto) ? proto : TensorProto.decode(proto)
+      shape = proto.tensor_shape.dim.map(&:size)
+      dtype = FFI::DataType[DataType.resolve(proto.dtype)]
+      numo_klass = TensorData::DTYPE_TO_NUMO_TYPE_MAP[dtype]
+      value = if shape.empty?
+                array = numo_klass.from_binary(proto.tensor_content)
+                array[0]
+               else
+                 numo_klass.from_binary(proto.tensor_content, shape)
+               end
+      self.new(value, dtype:dtype, shape:shape)
+    end
+
+    def self.from_pointer(pointer)
+      result = self.allocate
+      result.instance_variable_set(:@pointer, pointer)
+      ObjectSpace.define_finalizer(result, self.finalize(pointer))
+      result
+    end
+
+    def initialize(value, dtype: nil, shape: [])
+      value = case value
+                when Numo::NArray
+                  value
+                when Array
+                  # We convert all arrays to narrays. This makes it a lot easier to support multidimensional arrays
+                  result = Numo::NArray.cast(value)
+                else
+                  TensorData.value_with_shape(value, dtype, shape)
+              end
+
+      tensor_data = TensorData.new(value, dtype: dtype, shape: shape)
+      dtype = tensor_data.dtype
+      shape = tensor_data.shape
+
+      if shape && shape.size > 0
+        dims_ptr = ::FFI::MemoryPointer.new(:int64, shape.size)
+        dims_ptr.write_array_of_int64(shape)
+      else
+        dims_ptr = nil
+      end
+
+      @pointer = FFI.TF_NewTensor(dtype,
+                                  dims_ptr, shape ? shape.size : 0,
+                                  tensor_data, tensor_data.byte_size,
+                                  TensorData::Deallocator, nil)
+
+      ObjectSpace.define_finalizer(self, self.class.finalize(@pointer))
+    end
+
+    def value
+      self.data.value
+    end
+
+    def dtype
+      FFI.TF_TensorType(self)
+    end
+
+    def to_s
+      inspect
+    end
+
+    def to_ptr
+      @pointer
+    end
+
+    def byte_size
+      FFI.TF_TensorByteSize(self)
+    end
+
+    def inspect
+      inspection = %w(numo shape dtype).map { |v| "#{v}: #{send(v).inspect}"}
+      "#<#{self.class} #{inspection.join(", ")}>"
+    end
+
+    def data
+      TensorData.from_pointer(FFI.TF_TensorData(self), self.byte_size, self.dtype, self.shape)
+    end
+
+    private
+
+    def num_dims
+      FFI.TF_NumDims(self)
+    end
+
+    def dim(index)
+      FFI.TF_Dim(self, index)
+    end
+
+    def element_count
+      FFI.TF_TensorElementCount(self)
+    end
+
+    def calculate_shape(value)
+      return value.shape if value.respond_to?(:shape)
+
+      shape = []
+      d = value
+      while d.is_a?(Array)
+        shape << d.size
+        d = d.first
+      end
+      shape
+    end
+  end
+end

data/lib/tensorflow/tensor_data.rb

@@ -0,0 +1,310 @@
+require 'rbconfig'
+module Tensorflow
+  # Tensorflow expects client libraries to allocate memory for the data that a tensor wraps. When a tensor is released,
+  # it notifies the client via a callback that gives the client a chance to release the memory.
+  #
+  # We don't want to use a FFI::MemoryPointer because they are garbage collected. If the underlying data is freed before
+  # the tensor is released you get a GC (this can happen even if a Ruby tensor object keeps a reference to the pointer at
+  # GC time).
+  #
+  # Thus this class creates its own memory and frees the memory only after being called bcak by tensorflow.
+
+  class TensorData
+    extend ::FFI::Library
+    ffi_lib "#{RbConfig::CONFIG['RUBY_SO_NAME']}.#{RbConfig::CONFIG['SOEXT']}"
+    attach_function :ruby_xmalloc, [:size_t], :pointer
+    attach_function :ruby_xfree, [:pointer], :void
+
+    attr_reader :pointer, :byte_size, :dtype, :shape
+
+    extend Forwardable
+    def_delegators :to_ptr, :+, *::FFI::Pointer.instance_methods.grep(/^write_/)
+
+    # Store a callback as a class consstant (so it won't be garbage collected ) that tensorflow will trigger
+    # when memory should be freed.
+    Deallocator = ::FFI::Function.new(:void, [:pointer, :size_t, :pointer]) do |data, len, arg|
+                    ruby_xfree(data)
+                  end
+
+    DTYPE_TO_NUMO_TYPE_MAP = {bool:       Numo::Bit,
+                              complex64:  Numo::SComplex,
+                              complex128: Numo::DComplex,
+                              double:     Numo::DFloat,
+                              float:      Numo::SFloat,
+                              int8:       Numo::Int8,
+                              int16:      Numo::Int16,
+                              int32:      Numo::Int32,
+                              int64:      Numo::Int64,
+                              uint8:      Numo::UInt8,
+                              uint16:     Numo::UInt16,
+                              uint32:     Numo::UInt32,
+                              uint64:     Numo::UInt64}
+
+    NUMO_TYPE_TO_DTYPE_MAP = DTYPE_TO_NUMO_TYPE_MAP.each_with_object(Hash.new) do |pair, hash|
+      hash[pair.last] = pair.first
+    end
+
+    def self.figure_dtype(value)
+      case value
+        when Numo::RObject
+          # Need to look at the first element to see what it is
+          self.figure_dtype(value[0])
+        when Numo::NArray
+          NUMO_TYPE_TO_DTYPE_MAP[value.class]
+        when Array
+          self.figure_dtype(value.first)
+        when Integer
+          (value >= -2147483648 && value <= 2147483647) ? :int32 : :int64
+        when Complex
+          (value.real > -1.175494351e38 && value.real <	3.402823466e38) ? :complex64 : :complex128
+        when Numeric
+          (value > -1.175494351e38 && value <	3.402823466e38) ? :float : :double
+        when String
+          :string
+        when TrueClass, FalseClass
+          :bool
+        when ::FFI::Pointer
+          :pointer
+        when Tensor
+          value.dtype
+        when Variable
+          value.dtype
+        when Graph::Operation
+          nil
+        when Eager::TensorHandle
+          value.dtype
+        when Google::Protobuf::MessageExts
+          :string
+        else
+          raise(Error::InvalidArgumentError, "Unsupported type: #{value.class}")
+      end
+    end
+
+    def self.type_size(dtype)
+      case dtype
+        when :complex64
+          ::FFI.type_size(:float) * 2
+        when :complex128
+          ::FFI.type_size(:double) * 2
+        else
+          ::FFI.type_size(dtype)
+      end
+    end
+
+    def self.value_with_shape(value, dtype, shape)
+      if shape && shape.size > 0
+        dtype ||= self.figure_dtype(value)
+        numo_klass = DTYPE_TO_NUMO_TYPE_MAP[dtype]
+        numo_klass.new(shape).fill(value)
+      else
+        value
+      end
+    end
+
+    def self.from_pointer(pointer, byte_size, dtype, shape)
+      result = self.allocate
+      result.instance_variable_set(:@pointer, pointer)
+      result.instance_variable_set(:@byte_size, byte_size)
+      result.instance_variable_set(:@dtype, dtype)
+      result.instance_variable_set(:@shape, shape)
+      result
+    end
+
+    def initialize(value, dtype: nil, shape: [])
+      @dtype = dtype || self.class.figure_dtype(value)
+      @shape = shape
+      case value
+        when Numo::NArray
+          self.write_narray(value)
+        when Array
+          raise(Error::InvalidArgumentError, "TensorData does not support Arrays. Please use a Numo::NArray")
+        when Google::Protobuf::MessageExts
+          encoded = value.class.encode(value)
+          self.write_array_of_string([encoded])
+        else
+          self.write_scalar(value)
+      end
+    end
+
+    def to_ptr
+      @pointer
+    end
+
+    def read_array_of_complex64(count)
+      values = self.read_array_of_float(2 * count)
+      values.each_slice(2).map do |real, imaginary|
+        Complex(real, imaginary)
+      end
+    end
+
+    def read_array_of_complex128(count)
+      values = self.read_array_of_double(2 * count)
+      values.each_slice(2).map do |real, imaginary|
+        Complex(real, imaginary)
+      end
+    end
+
+    def read_array_of_string(count)
+      # The start of the data section comes after the offset table
+      start_offset_size = count * ::FFI.type_size(:int64)
+
+      # Read in the string offsets
+      offsets = self.pointer.read_array_of_uint64(count)
+
+      offsets.map.with_index do |offset, index|
+        src_bytes = (offsets[index + 1] || self.byte_size) - offset
+        dst_ptr = ::FFI::MemoryPointer.new(:pointer)
+        dst_len_ptr = ::FFI::MemoryPointer.new(:size_t)
+        Status.check do |status|
+          FFI.TF_StringDecode(self.pointer + start_offset_size + offset, src_bytes, dst_ptr, dst_len_ptr, status)
+        end
+        string_pointer = dst_ptr.read_pointer
+        string_length = dst_len_ptr.read(:size_t)
+        string_pointer.read_string(string_length)
+      end
+    end
+
+    # def value
+    #   result = case self.dtype
+    #             when :float, :double, :int32, :uint8, :int16, :int8, :int64, :uint16, :uint32, :uint64
+    #               self.pointer.send("read_array_of_#{self.dtype}", self.count)
+    #             when :bfloat16
+    #               byte_str = self.pointer.read_bytes(self.count * 2)
+    #               self.count.times.map { |i| "#{byte_str[(2 * i)..(2 * i + 1)]}\x00\x00".unpack1("g") }
+    #             when :complex64
+    #               self.read_array_of_complex64(self.count)
+    #             when :complex128
+    #               self.read_array_of_complex128(self.count)
+    #             when :string
+    #               self.read_array_of_string(self.count)
+    #             when :bool
+    #               self.pointer.read_array_of_int8(self.count)
+    #             when :resource, :variant
+    #               return self.data
+    #             else
+    #               raise "Unsupported tensor data type: #{self.dtype}"
+    #           end
+    #
+    #   if self.count == 1
+    #     result.first
+    #   else
+    #     result
+    #   end
+    # end
+
+    def value
+      result = case self.dtype
+                 when :bfloat16
+                   byte_str = self.pointer.read_bytes(self.count * 2)
+                   self.count.times.map { |i| "#{byte_str[(2 * i)..(2 * i + 1)]}\x00\x00".unpack1("g") }
+                 when :string
+                   count = self.shape.reduce(1) {|dim, result| result *= dim}
+                   self.read_array_of_string(count)
+                 when :bool
+                   bytes = self.pointer.read_bytes(self.byte_size)
+                   int8 = if self.shape.empty?
+                             Numo::Int8.from_binary(bytes)
+                           else
+                             Numo::Int8.from_binary(bytes, self.shape)
+                           end
+                   int8.cast_to(Numo::Bit)
+                 else
+                   bytes = self.pointer.read_bytes(self.byte_size)
+                   numo_klass = DTYPE_TO_NUMO_TYPE_MAP[self.dtype]
+                   if self.shape.empty?
+                     numo_klass.from_binary(bytes)
+                   else
+                     numo_klass.from_binary(bytes, self.shape)
+                   end
+               end
+
+      if self.shape.empty?
+        result[0]
+      else
+        result
+      end
+    end
+
+    def write_array_of_string(strings)
+      # The start of the data section comes after the offset table
+      start_offset_size = strings.size * ::FFI.type_size(:int64)
+
+      # Get the encoded sizes for each string
+      encoded_sizes = strings.map do |string|
+        FFI.TF_StringEncodedSize(string.bytesize)
+      end
+
+      # Now figure the offsets. Offsets are relative to the beginning of data section, not the beginning of the pointer.
+      # Notice we skip the last string [0..-2] since its offset would be the end of the pointer
+      offsets = [0]
+      encoded_sizes[0..-2].each do |encoded_size|
+        offsets << offsets.last + encoded_size
+      end
+
+      # Allocate the needed memory
+      @byte_size = start_offset_size + encoded_sizes.sum
+      @pointer = self.class.ruby_xmalloc(@byte_size)
+
+      # Write the offsets
+      self.pointer.write_array_of_uint64(offsets)
+
+      # Write the strings
+      strings.each_with_index do |string, index|
+        offset = offsets[index]
+        size = encoded_sizes[index]
+        Status.check do |status|
+          FFI.TF_StringEncode(string, string.bytesize, self.pointer + start_offset_size + offset, size, status)
+        end
+      end
+    end
+
+    def write_narray(new_value)
+      @shape = new_value.shape
+
+      case self.dtype
+        when :string
+          self.write_array_of_string(new_value.flatten.to_a)
+        when :bool
+          new_value = new_value.cast_to(Numo::Int8)
+          @byte_size = new_value.byte_size
+          @pointer = self.class.ruby_xmalloc(self.byte_size)
+          self.pointer.write_bytes(new_value.to_binary)
+        else
+          if NUMO_TYPE_TO_DTYPE_MAP[new_value.class] != dtype
+            # Cast the narray if necessary (say the user passed in float but we have a double array)
+            new_value = new_value.cast_to(DTYPE_TO_NUMO_TYPE_MAP[dtype])
+          end
+          @byte_size = new_value.byte_size
+          @pointer = self.class.ruby_xmalloc(@byte_size)
+          self.pointer.write_bytes(new_value.to_binary)
+      end
+    end
+
+    def write_scalar(new_value)
+      case self.dtype
+        when :string
+          self.write_array_of_string([new_value])
+        when :resource, :variant
+          return self
+        else
+          @byte_size = self.class.type_size(self.dtype)
+          @pointer = self.class.ruby_xmalloc(@byte_size)
+          case self.dtype
+            when :float, :double, :int32, :uint8, :int16, :int8, :int64, :uint16, :uint32, :uint64
+              self.pointer.send("write_#{self.dtype}", new_value)
+            when :bfloat16
+              byte_str = self.pointer.read_bytes(self.count * 2)
+              self.count.times.map { |i| "#{byte_str[(2 * i)..(2 * i + 1)]}\x00\x00".unpack1("g") }
+            when :complex64
+              self.pointer.write_array_of_float([new_value.real, new_value.imaginary])
+            when :complex128
+              self.pointer.write_array_of_double([new_value.real, new_value.imaginary])
+            when :bool
+              self.pointer.write_int8(new_value ? 1 : 0)
+            else
+              raise "Unsupported tensor data type: #{self.dtype}"
+          end
+      end
+    end
+  end
+end