tensorflow-ruby 0.2.0

data/lib/tensorflow/graph/session.rb

@@ -0,0 +1,156 @@
+module Tensorflow
+  module Graph
+    class SessionOptions
+      attr_accessor :target
+      def self.finalize(pointer)
+        proc do
+          FFI.TF_DeleteSessionOptions(pointer)
+        end
+      end
+
+      def initialize
+        @pointer = FFI.TF_NewSessionOptions
+        ObjectSpace.define_finalizer(self, self.class.finalize(@pointer))
+      end
+
+      def to_ptr
+        @pointer
+      end
+    end
+
+    class Session
+      attr_accessor :graph, :options
+
+      def self.run(graph)
+        session = self.new(graph, SessionOptions.new)
+        result = yield session
+        session.close
+        result
+      end
+
+      def self.finalize(pointer)
+        proc do
+          FFI.TF_DeleteSession(pointer)
+        end
+      end
+
+      def initialize(graph, options)
+        @graph = graph
+        Status.check do |status|
+          @pointer = FFI.TF_NewSession(graph, options, status)
+        end
+      end
+
+      def to_ptr
+        @pointer
+      end
+
+      def run(operations, feed_dict={})
+        operations = Array(operations).flatten.compact
+
+        key_outputs = feed_dict.keys.map(&:outputs).flatten
+        keys_ptr = FFI::Output.array_to_ptr(key_outputs.map(&:output))
+
+        values = self.values_to_tensors(feed_dict)
+        values_ptr = ::FFI::MemoryPointer.new(:pointer, values.length)
+        values_ptr.write_array_of_pointer(values)
+
+        # Gather up all the outputs for each operation
+        outputs = operations.map do |operation|
+          case operation
+            when Operation, Variable
+              operation.outputs
+            when OperationOutput
+              operation
+            else
+              raise(Error::UnimplementedError, "Unsupported operation type: #{operation}")
+          end
+        end.flatten
+
+        outputs_ptr = FFI::Output.array_to_ptr(outputs.map(&:output))
+        results_ptr = ::FFI::MemoryPointer.new(:pointer, outputs.length)
+
+        # Gather up all the targets
+        targets = operations.map do |operation|
+          case operation
+            when Operation, Variable
+              operation
+            when OperationOutput
+              operation.operation
+            else
+              raise("Unsupported target: #{operation}")
+          end
+        end
+        targets_ptr = ::FFI::MemoryPointer.new(:pointer, targets.length)
+        targets_ptr.write_array_of_pointer(targets)
+
+        run_options = nil
+        metadata = nil
+
+        Status.check do |status|
+          FFI.TF_SessionRun(self, run_options,
+                            # Inputs
+                            keys_ptr, values_ptr, feed_dict.keys.length,
+                            # Outputs
+                            outputs_ptr, results_ptr, outputs.length,
+                            # Targets
+                            targets_ptr, operations.length,
+                            metadata,
+                            status)
+        end
+
+        results = results_ptr.read_array_of_pointer(outputs.length).map.with_index do |pointer, i|
+          output = outputs[i]
+          Tensor.from_pointer(pointer).value
+        end
+
+        # For each operation we want to return a single result
+        start = 0
+        result = operations.reduce(Array.new) do |array, operation|
+          length = case operation
+                     when Operation, Variable
+                       operation.outputs.length
+                     when OperationOutput
+                       1
+                     else
+                       raise(Error::UnimplementedError, "Unsupported operation type: #{operation}")
+                   end
+
+          if length == 0
+            array << nil
+          else
+            array.concat(results[start, length])
+            start += length
+          end
+          array
+        end
+
+        if operations.length == 1 && results.length == 1
+          result.first
+        else
+          result
+        end
+      end
+
+      def close
+        Status.check do |status|
+          FFI.TF_CloseSession(self, status)
+        end
+      end
+
+      def values_to_tensors(values)
+        values.map do |key, value|
+          case value
+            when Tensor
+              value
+            else
+              # The value dtype needs to match the key dtype
+              raise(Error::UnknownError, "Cannot determine dtype: #{key}") if key.num_outputs != 1
+              dtype = key.output_types.first
+              Tensor.new(value, dtype: dtype)
+            end
+        end
+      end
+    end
+  end
+end

data/lib/tensorflow/keras/datasets/boston_housing.rb

@@ -0,0 +1,32 @@
+module Tensorflow
+  module Keras
+    module Datasets
+      module BostonHousing
+        def self.load_data(path: "boston_housing.npz", test_split: 0.2, seed: 113)
+          file = Utils.get_file(
+            path,
+            "https://storage.googleapis.com/tensorflow/tf-keras-datasets/boston_housing.npz",
+            file_hash: "f553886a1f8d56431e820c5b82552d9d95cfcb96d1e678153f8839538947dff5"
+          )
+
+          data = Npy.load_npz(file)
+
+          x = data["x"]
+          y = data["y"]
+
+          len = x.shape[0]
+          indices = (0...len).to_a.shuffle(random: ::Random.new(seed))
+          x = x[indices, true]
+          y = y[indices]
+
+          x_train = x[0...(len * (1 - test_split)), true]
+          y_train = y[0...(len * (1 - test_split))]
+          x_test = x[(len * (1 - test_split))..-1, true]
+          y_test = y[(len * (1 - test_split))..-1]
+
+          [[x_train, y_train], [x_test, y_test]]
+        end
+      end
+    end
+  end
+end

data/lib/tensorflow/keras/datasets/cifar10.rb

@@ -0,0 +1,11 @@
+module Tensorflow
+  module Keras
+    module Datasets
+      module CIFAR10
+        # unfortunately, npy can't read pickle and numo can't store objects
+        # def self.load_data
+        # end
+      end
+    end
+  end
+end

data/lib/tensorflow/keras/datasets/cifar100.rb

@@ -0,0 +1,11 @@
+module Tensorflow
+  module Keras
+    module Datasets
+      module CIFAR100
+        # unfortunately, npy can't read pickle and numo can't store objects
+        # def self.load_data
+        # end
+      end
+    end
+  end
+end

data/lib/tensorflow/keras/datasets/fashion_mnist.rb

@@ -0,0 +1,44 @@
+module Tensorflow
+  module Keras
+    module Datasets
+      module FashionMNIST
+        def self.load_data
+          base_url = "https://storage.googleapis.com/tensorflow/tf-keras-datasets"
+          files = [
+            "train-labels-idx1-ubyte.gz", "train-images-idx3-ubyte.gz",
+            "t10k-labels-idx1-ubyte.gz", "t10k-images-idx3-ubyte.gz"
+          ]
+
+          paths = []
+          files.each do |file|
+            paths << Utils.get_file(file, "#{base_url}/#{file}", cache_subdir: "datasets/fashion-mnist")
+          end
+
+          x_train, y_train, x_test, y_test = nil
+
+          Zlib::GzipReader.open(paths[0]) do |gz|
+            gz.read(8) # move to offset
+            y_train = Numo::UInt8.from_string(gz.read)
+          end
+
+          Zlib::GzipReader.open(paths[1]) do |gz|
+            gz.read(16) # move to offset
+            x_train = Numo::UInt8.from_string(gz.read, [y_train.shape[0], 28, 28])
+          end
+
+          Zlib::GzipReader.open(paths[2]) do |gz|
+            gz.read(8) # move to offset
+            y_test = Numo::UInt8.from_string(gz.read)
+          end
+
+          Zlib::GzipReader.open(paths[3]) do |gz|
+            gz.read(16) # move to offset
+            x_test = Numo::UInt8.from_string(gz.read, [y_test.shape[0], 28, 28])
+          end
+
+          [[x_train, y_train], [x_test, y_test]]
+        end
+      end
+    end
+  end
+end

data/lib/tensorflow/keras/datasets/imdb.rb

@@ -0,0 +1,30 @@
+module Tensorflow
+  module Keras
+    module Datasets
+      module IMDB
+        # unfortunately, npy can't read pickle and numo can't store objects
+        # def self.load_data(path: "imdb.npz", seed: 113)
+        #   data = Utils.load_dataset(
+        #     path,
+        #     "https://storage.googleapis.com/tensorflow/tf-keras-datasets/imdb.npz",
+        #     "69664113be75683a8fe16e3ed0ab59fda8886cb3cd7ada244f7d9544e4676b9f"
+        #   )
+
+        #   x_train = data["x_train"]
+        #   labels_train = data["y_train"]
+        #   x_test = data["x_test"]
+        #   labels_test = data["y_test"]
+        # end
+
+        def self.get_word_index(path: "imdb_word_index.json")
+          file = Utils.get_file(
+            path,
+            "https://storage.googleapis.com/tensorflow/tf-keras-datasets/imdb_word_index.json",
+            file_hash: "bfafd718b763782e994055a2d397834f"
+          )
+          JSON.parse(File.read(file))
+        end
+      end
+    end
+  end
+end

data/lib/tensorflow/keras/datasets/mnist.rb

@@ -0,0 +1,18 @@
+module Tensorflow
+  module Keras
+    module Datasets
+      module MNIST
+        def self.load_data(path: "mnist.npz")
+          file = Utils.get_file(
+            path,
+            "https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz",
+            file_hash: "731c5ac602752760c8e48fbffcf8c3b850d9dc2a2aedcf2cc48468fc17b673d1"
+          )
+
+          data = Npy.load_npz(file)
+          [[data["x_train"], data["y_train"]], [data["x_test"], data["y_test"]]]
+        end
+      end
+    end
+  end
+end

data/lib/tensorflow/keras/datasets/reuters.rb

@@ -0,0 +1,28 @@
+module Tensorflow
+  module Keras
+    module Datasets
+      module Reuters
+        # unfortunately, npy can't read pickle and numo can't store objects
+        # def self.load_data(path: "reuters.npz", test_split: 0.2, seed: 113)
+        #   data = Utils.load_dataset(
+        #     path,
+        #     "https://storage.googleapis.com/tensorflow/tf-keras-datasets/reuters.npz",
+        #     "d6586e694ee56d7a4e65172e12b3e987c03096cb01eab99753921ef915959916"
+        #   )
+
+        #   xs = data["x"]
+        #   labels = data["y"]
+        # end
+
+        def self.get_word_index(path: "reuters_word_index.json")
+          file = Utils.get_file(
+            path,
+            "https://storage.googleapis.com/tensorflow/tf-keras-datasets/reuters_word_index.json",
+            file_hash: "4d44cc38712099c9e383dc6e5f11a921"
+          )
+          JSON.parse(File.read(file))
+        end
+      end
+    end
+  end
+end

data/lib/tensorflow/keras/layers/conv.rb

@@ -0,0 +1,14 @@
+module Tensorflow
+  module Keras
+    module Layers
+      class Conv
+        def initialize(rank, filters, kernel_size, activation: nil)
+          @rank = rank
+          @filter = filters
+          @kernel_size = kernel_size
+          @activation = activation
+        end
+      end
+    end
+  end
+end

data/lib/tensorflow/keras/layers/conv2d.rb

@@ -0,0 +1,11 @@
+module Tensorflow
+  module Keras
+    module Layers
+      class Conv2D < Conv
+        def initialize(filters, kernel_size, activation: nil)
+          super(2, filters, kernel_size, activation: activation)
+        end
+      end
+    end
+  end
+end

data/lib/tensorflow/keras/layers/dense.rb

@@ -0,0 +1,68 @@
+module Tensorflow
+  module Keras
+    module Layers
+      class Dense
+        def initialize(units, activation: nil, use_bias: true, kernel_initializer: "glorot_uniform", bias_initializer: "zeros", dtype: :float)
+          @units = units
+          @activation = activation
+          @use_bias = use_bias
+          @kernel_initializer = kernel_initializer
+          @bias_initializer = bias_initializer
+          @dtype = dtype
+          @built = false
+        end
+
+        def build(input_shape)
+          last_dim = input_shape.last
+          @kernel = Utils.add_weight(name: "kernel", shape: [last_dim, @units], initializer: @kernel_initializer, dtype: @dtype)
+
+          if @use_bias
+            @bias = Utils.add_weight(name: "bias", shape: [@units], initializer: @bias_initializer, dtype: @dtype)
+          else
+            @bias = nil
+          end
+
+          @output_shape = [last_dim, @units]
+
+          @built = true
+        end
+
+        def output_shape
+          @output_shape
+        end
+
+        def count_params
+          @units + @kernel.shape.inject(&:*)
+        end
+
+        def call(inputs)
+          build(inputs.shape) unless @built
+
+          rank = inputs.shape.size
+
+          if rank > 2
+            raise Error, "Rank > 2 not supported yet"
+          else
+            inputs = Tensorflow.cast(inputs, @dtype)
+            outputs = Tensorflow.matmul(inputs, @kernel)
+          end
+
+          if @use_bias
+            outputs = NN.bias_add(outputs, @bias)
+          end
+
+          case @activation
+          when "relu"
+            NN.relu(outputs)
+          when "softmax"
+            NN.softmax(outputs)
+          when nil
+            outputs
+          else
+            raise "Unknown activation: #{@activation}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tensorflow/keras/layers/dropout.rb

@@ -0,0 +1,27 @@
+module Tensorflow
+  module Keras
+    module Layers
+      class Dropout
+        def initialize(rate)
+        end
+
+        def build(input_shape)
+          @output_shape = input_shape
+        end
+
+        def call(inputs)
+          # TODO implement
+          Tensorflow.identity(inputs)
+        end
+
+        def output_shape
+          @output_shape
+        end
+
+        def count_params
+          0
+        end
+      end
+    end
+  end
+end