tensorflow 0.1.0 → 0.1.1

data/lib/tensorflow/tensor.rb

@@ -1,6 +1,6 @@
 module TensorFlow
   class Tensor
-    def initialize(value = nil, pointer: nil, dtype: nil, shape: nil)
+    def initialize(value = nil, dtype: nil, shape: nil, pointer: nil)
       @status = FFI.TF_NewStatus
 
       if pointer
@@ -18,17 +18,27 @@ module TensorFlow
 
         data = data.flatten
 
-        dtype ||= Utils.infer_type(value)
+        dtype ||= Utils.infer_type(data)
         type = FFI::DataType[dtype]
         case dtype
+        when :float, :double, :int32, :uint8, :int16, :int8, :int64, :uint16, :uint32, :uint64
+          data_ptr = ::FFI::MemoryPointer.new(dtype, data.size)
+          data_ptr.send("write_array_of_#{dtype}", data)
+        when :bfloat16
+          # https://en.wikipedia.org/wiki/Bfloat16_floating-point_format
+          data_ptr = ::FFI::MemoryPointer.new(:int8, data.size * 2)
+          data_ptr.write_bytes(data.map { |v| [v].pack("g")[0..1] }.join)
+        when :complex64
+          data_ptr = ::FFI::MemoryPointer.new(:float, data.size * 2)
+          data_ptr.write_array_of_float(data.flat_map { |v| [v.real, v.imaginary] })
+        when :complex128
+          data_ptr = ::FFI::MemoryPointer.new(:double, data.size * 2)
+          data_ptr.write_array_of_double(data.flat_map { |v| [v.real, v.imaginary] })
         when :string
           data_ptr = string_ptr(data)
-        when :float
-          data_ptr = ::FFI::MemoryPointer.new(:float, data.size)
-          data_ptr.write_array_of_float(data)
-        when :int32
-          data_ptr = ::FFI::MemoryPointer.new(:int32, data.size)
-          data_ptr.write_array_of_int32(data)
+        when :bool
+          data_ptr = ::FFI::MemoryPointer.new(:int8, data.size)
+          data_ptr.write_array_of_int8(data.map { |v| v ? 1 : 0 })
         else
           raise "Unknown type: #{dtype}"
         end
@@ -42,74 +52,41 @@ module TensorFlow
         check_status @status
       end
 
-      # TODO fix segfault
-      # ObjectSpace.define_finalizer(self, self.class.finalize(@pointer))
+      ObjectSpace.define_finalizer(self, self.class.finalize(@pointer, @status, tensor))
     end
 
     def +(other)
-      TensorFlow.add(self, other)
+      Math.add(self, other)
     end
 
     def -(other)
-      TensorFlow.subtract(self, other)
+      Math.subtract(self, other)
     end
 
     def *(other)
-      TensorFlow.multiply(self, other)
+      Math.multiply(self, other)
     end
 
     def /(other)
-      TensorFlow.divide(self, other)
+      Math.divide(self, other)
     end
 
     def %(other)
-      TensorFlow.floormod(self, other)
-    end
-
-    def num_dims
-      ret = FFI.TFE_TensorHandleNumDims(@pointer, @status)
-      check_status @status
-      ret
-    end
-
-    def dtype
-      @dtype ||= FFI::DataType[FFI.TFE_TensorHandleDataType(@pointer)]
-    end
-
-    def element_count
-      ret = FFI.TFE_TensorHandleNumElements(@pointer, @status)
-      check_status @status
-      ret
-    end
-
-    def shape
-      @shape ||= begin
-        shape = []
-        num_dims.times do |i|
-          shape << FFI.TFE_TensorHandleDim(@pointer, i, @status)
-          check_status @status
-        end
-        shape
-      end
-    end
-
-    def data_pointer
-      tensor = FFI.TFE_TensorHandleResolve(@pointer, @status)
-      check_status @status
-      FFI.TF_TensorData(tensor)
-    end
-
-    def to_ptr
-      @pointer
+      Math.floormod(self, other)
     end
 
     def value
       value =
         case dtype
-        when :float
-          data_pointer.read_array_of_float(element_count)
-        when :int32
-          data_pointer.read_array_of_int32(element_count)
+        when :float, :double, :int32, :uint8, :int16, :int8, :int64, :uint16, :uint32, :uint64
+          data_pointer.send("read_array_of_#{dtype}", element_count)
+        when :bfloat16
+          byte_str = data_pointer.read_bytes(element_count * 2)
+          element_count.times.map { |i| "#{byte_str[(2 * i)..(2 * i + 1)]}\x00\x00".unpack1("g") }
+        when :complex64
+          data_pointer.read_array_of_float(element_count * 2).each_slice(2).map { |v| Complex(*v) }
+        when :complex128
+          data_pointer.read_array_of_double(element_count * 2).each_slice(2).map { |v| Complex(*v) }
         when :string
           # string tensor format
           # https://github.com/tensorflow/tensorflow/blob/5453aee48858fd375172d7ae22fad1557e8557d6/tensorflow/c/tf_tensor.h#L57
@@ -127,6 +104,21 @@ module TensorFlow
       reshape(value, shape)
     end
 
+    def dtype
+      @dtype ||= FFI::DataType[FFI.TFE_TensorHandleDataType(@pointer)]
+    end
+
+    def shape
+      @shape ||= begin
+        shape = []
+        num_dims.times do |i|
+          shape << FFI.TFE_TensorHandleDim(@pointer, i, @status)
+          check_status @status
+        end
+        shape
+      end
+    end
+
     def to_s
       inspect
     end
@@ -139,18 +131,44 @@ module TensorFlow
       value
     end
 
+    def to_ptr
+      @pointer
+    end
+
     def inspect
       inspection = %w(value shape dtype).map { |v| "#{v}: #{send(v).inspect}"}
       "#<#{self.class} #{inspection.join(", ")}>"
     end
 
-    def self.finalize(pointer)
+    def self.finalize(pointer, status, tensor)
       # must use proc instead of stabby lambda
-      proc { FFI.TFE_DeleteTensorHandle(pointer) }
+      proc do
+        FFI.TFE_DeleteTensorHandle(pointer)
+        FFI.TFE_DeleteStatus(status)
+        FFI.TFE_DeleteTensor(tensor) if tensor
+      end
     end
 
     private
 
+    def num_dims
+      ret = FFI.TFE_TensorHandleNumDims(@pointer, @status)
+      check_status @status
+      ret
+    end
+
+    def element_count
+      ret = FFI.TFE_TensorHandleNumElements(@pointer, @status)
+      check_status @status
+      ret
+    end
+
+    def data_pointer
+      tensor = FFI.TFE_TensorHandleResolve(@pointer, @status)
+      check_status @status
+      FFI.TF_TensorData(tensor)
+    end
+
     def reshape(arr, dims)
       return arr.first if dims.empty?
       arr = arr.flatten
@@ -176,12 +194,12 @@ module TensorFlow
       start_offset_size = data.size * 8
       offsets = [0]
       data.each do |str|
-        offsets << str.bytesize + 1
+        offsets << offsets.last + str.bytesize + 1
       end
       data_ptr = ::FFI::MemoryPointer.new(:char, start_offset_size + offsets.pop)
       data_ptr.write_array_of_uint64(offsets)
-      data.zip(offsets) do |str, off|
-        (data_ptr + start_offset_size + off).write_string(str)
+      data.zip(offsets) do |str, offset|
+        (data_ptr + start_offset_size + offset).write_string(str)
       end
       data_ptr
     end

data/lib/tensorflow/utils.rb

@@ -1,21 +1,140 @@
 module TensorFlow
   module Utils
-    def self.check_status(status)
-      if FFI.TF_GetCode(status) != 0
-        raise Error, FFI.TF_Message(status)
+    class << self
+      def check_status(status)
+        if FFI.TF_GetCode(status) != 0
+          raise Error, FFI.TF_Message(status)
+        end
       end
-    end
 
-    def self.infer_type(value)
-      case value
-      when String
-        :string
-      when Float
-        :float
-      when true, false
-        :bool
-      else
-        :int32
+      def default_context
+        @default_context ||= Context.new
+      end
+
+      def execute(op_name, inputs = [], **attrs)
+        context = default_context
+        status = FFI.TF_NewStatus # TODO reuse status between ops?
+        op = FFI.TFE_NewOp(context, op_name, status)
+        check_status status
+
+        attrs.each do |attr_name, attr_value|
+          next if attr_value.nil?
+
+          attr_name = attr_name.to_s
+
+          is_list = ::FFI::MemoryPointer.new(:int)
+          type = FFI.TFE_OpGetAttrType(op, attr_name, is_list, status)
+          check_status status
+
+          case FFI::AttrType[type]
+          when :string
+            FFI.TFE_OpSetAttrString(op, attr_name, attr_value, attr_value.bytesize)
+          # when :int
+          # when :float
+          # when :bool
+          when :type
+            FFI.TFE_OpSetAttrType(op, attr_name, attr_value)
+          when :shape
+            # TODO set value properly
+            FFI.TFE_OpSetAttrShape(op, attr_name, nil, 0, status)
+            check_status status
+          # when :tensor
+          # when :placeholder
+          # when :func
+          else
+            raise "Unknown type: #{FFI::AttrType[type]}"
+          end
+        end
+
+        inputs.each do |input|
+          input = TensorFlow.convert_to_tensor(input) unless input.respond_to?(:to_ptr)
+          FFI.TFE_OpAddInput(op, input, status)
+          check_status status
+        end
+
+        retvals = ::FFI::MemoryPointer.new(:pointer)
+        num_retvals = ::FFI::MemoryPointer.new(:int)
+        num_retvals.write_int(retvals.size)
+        FFI.TFE_Execute(op, retvals, num_retvals, status)
+        check_status status
+
+        if num_retvals.read_int > 0
+          handle = retvals.read_pointer
+          type = FFI.TFE_TensorHandleDataType(handle)
+
+          case FFI::DataType[type]
+          when :resource
+            handle
+          else
+            Tensor.new(pointer: handle)
+          end
+        end
+      ensure
+        FFI.TF_DeleteStatus(status) if status
+        FFI.TFE_DeleteOp(op) if op
+      end
+
+      def infer_type(value)
+        if value.all? { |v| v.is_a?(String) }
+          :string
+        elsif value.all? { |v| v == true || v == false }
+          :bool
+        elsif value.all? { |v| v.is_a?(Integer) }
+          if value.all? { |v| v >= -2147483648 && v <= 2147483647 }
+            :int32
+          else
+            :int64
+          end
+        elsif value.all? { |v| v.is_a?(Complex) }
+          :complex128
+        elsif value.all? { |v| v.is_a?(Numeric) }
+          :float
+        else
+          raise Error, "Unable to infer data type"
+        end
+      end
+
+      def load_dataset(path, url)
+        # TODO handle this better
+        raise "No HOME" unless ENV["HOME"]
+        datasets_dir = "#{ENV["HOME"]}/.keras/datasets"
+        FileUtils.mkdir_p(datasets_dir)
+
+        path = "#{datasets_dir}/#{path}"
+        Utils.download_file(url, path) unless File.exist?(path)
+        Npy.load_npz(path)
+      end
+
+      def download_file(url, dest)
+        uri = URI(url)
+
+        temp_dir ||= File.dirname(Tempfile.new("tensorflow"))
+        temp_path = "#{temp_dir}/#{Time.now.to_f}" # TODO better name
+
+        # Net::HTTP automatically adds Accept-Encoding for compression
+        # of response bodies and automatically decompresses gzip
+        # and deflateresponses unless a Range header was sent.
+        # https://ruby-doc.org/stdlib-2.6.4/libdoc/net/http/rdoc/Net/HTTP.html
+        Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+          request = Net::HTTP::Get.new(uri)
+
+          print("Downloading dataset")
+          i = 0
+          File.open(temp_path, "wb") do |f|
+            http.request(request) do |response|
+              response.read_body do |chunk|
+                f.write(chunk)
+
+                # print progress
+                putc "." if i % 50 == 0
+                i += 1
+              end
+            end
+            puts # newline
+          end
+        end
+
+        FileUtils.mv(temp_path, dest)
       end
     end
   end

data/lib/tensorflow/variable.rb

@@ -1,31 +1,31 @@
 module TensorFlow
   class Variable
     def initialize(initial_value, dtype: nil)
-      @dtype = dtype || Utils.infer_type(initial_value)
-      @pointer = TensorFlow.var_handle_op(type_enum, nil, shared_name: TensorFlow.send(:default_context).shared_name)
+      @dtype = dtype || Utils.infer_type(Array(initial_value).flatten)
+      @pointer = RawOps.var_handle_op(dtype: type_enum, shape: [], shared_name: Utils.default_context.shared_name)
       assign(initial_value)
     end
 
     def assign(value)
       value = TensorFlow.convert_to_tensor(value, dtype: @dtype)
-      TensorFlow.assign_variable_op(@pointer, value)
+      RawOps.assign_variable_op(resource: @pointer, value: value)
       self
     end
 
     def assign_add(value)
       value = TensorFlow.convert_to_tensor(value, dtype: @dtype)
-      TensorFlow.assign_add_variable_op(@pointer, value)
+      RawOps.assign_add_variable_op(resource: @pointer, value: value)
       self
     end
 
     def assign_sub(value)
       value = TensorFlow.convert_to_tensor(value, dtype: @dtype)
-      TensorFlow.assign_sub_variable_op(@pointer, value)
+      RawOps.assign_sub_variable_op(resource: @pointer, value: value)
       self
     end
 
     def read_value
-      TensorFlow.read_variable_op(@pointer, type_enum)
+      RawOps.read_variable_op(resource: @pointer, dtype: type_enum)
     end
 
     def +(other)

data/lib/tensorflow/version.rb

@@ -1,3 +1,3 @@
 module TensorFlow
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/tensorflow.rb

@@ -1,13 +1,30 @@
 # dependencies
 require "ffi"
+require "npy"
+
+# stdlib
+require "fileutils"
+require "forwardable"
+require "net/http"
+require "tempfile"
 
 # modules
 require "tensorflow/utils"
 require "tensorflow/context"
+require "tensorflow/math"
+require "tensorflow/ops"
+require "tensorflow/raw_ops"
 require "tensorflow/tensor"
 require "tensorflow/variable"
 require "tensorflow/version"
 
+# keras
+require "tensorflow/keras/datasets/mnist"
+require "tensorflow/keras/layers/dense"
+require "tensorflow/keras/layers/dropout"
+require "tensorflow/keras/layers/flatten"
+require "tensorflow/keras/models/sequential"
+
 module TensorFlow
   class Error < StandardError; end
 
@@ -20,8 +37,12 @@ module TensorFlow
   autoload :FFI, "tensorflow/ffi"
 
   class << self
+    include Ops
     include Utils
 
+    extend Forwardable
+    def_delegators Math, :abs, :acos, :acosh, :add, :add_n, :argmax, :argmin, :asin, :asinh, :atan, :atan2, :atanh, :cos, :cosh, :cumsum, :divide, :equal, :exp, :floor, :greater, :greater_equal, :less, :less_equal, :logical_and, :logical_not, :logical_or, :maximum, :minimum, :multiply, :negative, :not_equal, :pow, :reduce_all, :reduce_any, :reduce_logsumexp, :reduce_max, :reduce_mean, :reduce_min, :reduce_prod, :reduce_sum, :round, :scalar_mul, :sigmoid, :sign, :sin, :sinh, :sqrt, :square, :subtract, :tan, :tanh, :truediv
+
     def library_version
       FFI.TF_Version
     end
@@ -34,153 +55,6 @@ module TensorFlow
       value = Tensor.new(value, dtype: dtype) unless value.is_a?(Tensor)
       value
     end
-
-    def add(x, y)
-      execute("Add", [x, y])
-    end
-
-    def subtract(x, y)
-      execute("Sub", [x, y])
-    end
-
-    def multiply(x, y)
-      execute("Mul", [x, y])
-    end
-
-    def divide(x, y)
-      execute("Div", [x, y])
-    end
-
-    def abs(x)
-      execute("Abs", [x])
-    end
-
-    def sqrt(x)
-      execute("Sqrt", [x])
-    end
-
-    def matmul(x, y)
-      execute("MatMul", [x, y])
-    end
-
-    def floormod(x, y)
-      execute("Mod", [x, y])
-    end
-
-    def range(start, limit, delta)
-      execute("Range", [start, limit, delta])
-    end
-
-    def transpose(x, perm: [1, 0])
-      execute("Transpose", [x, perm])
-    end
-
-    def equal(x, y)
-      execute("Equal", [x, y])
-    end
-
-    def zeros_like(x)
-      execute("ZerosLike", [x])
-    end
-
-    def fill(dims, value)
-      execute("Fill", [dims, value])
-    end
-
-    def zeros(dims)
-      fill(dims, 0)
-    end
-
-    def ones(dims)
-      fill(dims, 1)
-    end
-
-    def assign_add_variable_op(resource, value)
-      execute("AssignAddVariableOp", [resource, value])
-    end
-
-    def assign_sub_variable_op(resource, value)
-      execute("AssignSubVariableOp", [resource, value])
-    end
-
-    def assign_variable_op(resource, value)
-      execute("AssignVariableOp", [resource, value])
-    end
-
-    def read_variable_op(resource, dtype)
-      execute("ReadVariableOp", [resource], dtype: dtype)
-    end
-
-    def var_handle_op(dtype, shape, container: "", shared_name: "")
-      execute("VarHandleOp", [], container: container, shared_name: shared_name, dtype: dtype, shape: shape)
-    end
-
-    def var_is_initialized_op(resource)
-      execute("VarIsInitializedOp", [resource])
-    end
-
-    private
-
-    def default_context
-      @default_context ||= Context.new
-    end
-
-    def execute(op_name, inputs = [], **attrs)
-      context = default_context
-      status = FFI.TF_NewStatus
-      op = FFI.TFE_NewOp(context, op_name, status)
-      check_status status
-      # TODO clean up status and op
-
-      attrs.each do |attr_name, attr_value|
-        attr_name = attr_name.to_s
-
-        is_list = ::FFI::MemoryPointer.new(:int)
-        type = FFI.TFE_OpGetAttrType(op, attr_name, is_list, status)
-        check_status status
-
-        case FFI::AttrType[type]
-        when :type
-          FFI.TFE_OpSetAttrType(op, attr_name, attr_value)
-        when :shape
-          # TODO set value properly
-          FFI.TFE_OpSetAttrShape(op, attr_name, attr_value, 0, status)
-          check_status status
-        when :string
-          FFI.TFE_OpSetAttrString(op, attr_name, attr_value, attr_value.bytesize)
-        else
-          raise "Unknown type: #{FFI::AttrType[type]}"
-        end
-      end
-
-      inputs.each do |input|
-        input = convert_to_tensor(input) unless input.respond_to?(:to_ptr)
-        FFI.TFE_OpAddInput(op, input, status)
-        check_status status
-      end
-
-      retvals = ::FFI::MemoryPointer.new(:pointer)
-      num_retvals = ::FFI::MemoryPointer.new(:int)
-      num_retvals.write_int(retvals.size)
-      FFI.TFE_Execute(op, retvals, num_retvals, status)
-      check_status status
-
-      if num_retvals.read_int > 0
-        handle = retvals.read_pointer
-        type = FFI.TFE_TensorHandleDataType(handle)
-
-        case FFI::DataType[type]
-        when :resource
-          handle
-        else
-          Tensor.new(pointer: handle)
-        end
-      end
-    end
-
-    def check_status(status)
-      Utils.check_status(status)
-    end
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tensorflow
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-18 00:00:00.000000000 Z
+date: 2019-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: npy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +80,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5'
+- !ruby/object:Gem::Dependency
+  name: google-protobuf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email: andrew@chartkick.com
 executables: []
@@ -78,6 +120,14 @@ files:
 - lib/tensorflow.rb
 - lib/tensorflow/context.rb
 - lib/tensorflow/ffi.rb
+- lib/tensorflow/keras/datasets/mnist.rb
+- lib/tensorflow/keras/layers/dense.rb
+- lib/tensorflow/keras/layers/dropout.rb
+- lib/tensorflow/keras/layers/flatten.rb
+- lib/tensorflow/keras/models/sequential.rb
+- lib/tensorflow/math.rb
+- lib/tensorflow/ops.rb
+- lib/tensorflow/raw_ops.rb
 - lib/tensorflow/tensor.rb
 - lib/tensorflow/utils.rb
 - lib/tensorflow/variable.rb