tensorflow-ruby 0.2.0

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

@@ -0,0 +1,25 @@
+module Tensorflow
+  module Keras
+    module Layers
+      class Flatten
+        def initialize(input_shape: nil)
+          @input_shape = input_shape
+        end
+
+        def output_shape
+          flattened_dim = @input_shape.inject(&:*)
+          [-1, flattened_dim]
+        end
+
+        def count_params
+          0
+        end
+
+        def call(inputs)
+          flattened_dim = inputs.shape[1..-1].inject(&:*)
+          Tensorflow.reshape(inputs, [-1, flattened_dim])
+        end
+      end
+    end
+  end
+end

data/lib/tensorflow/keras/losses/sparse_categorical_crossentropy.rb

@@ -0,0 +1,14 @@
+module Tensorflow
+  module Keras
+    module Losses
+      class SparseCategoricalCrossentropy
+        def call(target, output)
+          output = Math.log(output)
+          target = Tensorflow.cast(target, :int64)
+          cost, _ = RawOps.sparse_softmax_cross_entropy_with_logits(features: output, labels: target)
+          Math.reduce_sum(cost) / Tensorflow.cast(RawOps.size(input: cost), :float)
+        end
+      end
+    end
+  end
+end

data/lib/tensorflow/keras/metrics/mean.rb

@@ -0,0 +1,30 @@
+module Tensorflow
+  module Keras
+    module Metrics
+      class Mean
+        def initialize(name: nil, dtype: :float)
+          @dtype = dtype
+          @total = Utils.add_weight(name: "total", initializer: "zeros", dtype: @dtype)
+          @count = Utils.add_weight(name: "count", initializer: "zeros", dtype: @dtype)
+        end
+
+        def call(*args)
+          update_state(*args)
+        end
+
+        def update_state(values)
+          input = Tensorflow.cast(input, destination_dtype: @dtype)
+          @total.assign_add(Math.reduce_sum(input))
+          @count.assign_add(Tensorflow.cast(RawOps.size(input), @dtype))
+        end
+
+        def result
+          RawOps.div_no_nan(@total, Tensorflow.cast(@count, :float))
+        end
+
+        def reset_states
+        end
+      end
+    end
+  end
+end

data/lib/tensorflow/keras/metrics/sparse_categorical_accuracy.rb

@@ -0,0 +1,17 @@
+module Tensorflow
+  module Keras
+    module Metrics
+      class SparseCategoricalAccuracy < Mean
+        def update_state(y_true, y_pred)
+          y_pred = RawOps.arg_max(y_pred, -1)
+
+          # if y_pred.dtype != y_true.dtype
+          #   y_pred = Tensorflow.cast(y_pred, y_true.dtype)
+          # end
+
+          super(Math.equal(y_true, y_pred))
+        end
+      end
+    end
+  end
+end

data/lib/tensorflow/keras/model.rb

@@ -0,0 +1,6 @@
+module Tensorflow
+  module Keras
+    class Model
+    end
+  end
+end

data/lib/tensorflow/keras/models/sequential.rb

@@ -0,0 +1,56 @@
+module Tensorflow
+  module Keras
+    module Models
+      class Sequential
+        def initialize(layers = [])
+          @layers = []
+
+          layers.each do |layer|
+            add(layer)
+          end
+        end
+
+        def add(layer)
+          @layers << layer
+        end
+
+        def compile(optimizer: nil, loss: nil, metrics: nil)
+          raise "Not implemented"
+        end
+
+        def fit(x, y, epochs: nil)
+          raise "Not implemented"
+        end
+
+        def evaluate(x, y)
+          raise "Not implemented"
+        end
+
+        def summary
+          sep = "_________________________________________________________________\n"
+
+          output_shape = nil
+          @layers.each do |layer|
+            layer.build(output_shape) if layer.respond_to?(:build)
+            output_shape = layer.output_shape
+          end
+
+          total_params = @layers.map(&:count_params).sum
+
+          summary = String.new("")
+          summary << "Model: \"sequential\"\n"
+          summary << sep
+          summary << "Layer (type)                 Output Shape              Param #   \n"
+          summary << "=================================================================\n"
+          summary << @layers.map { |l| "%-28s %-25s %-10s\n" % [l.class.name.split("::").last, ([nil] + l.output_shape[1..-1]).inspect, l.count_params] }.join(sep)
+          summary << "=================================================================\n"
+          summary << "Total params: #{total_params}\n"
+          summary << "Trainable params: #{total_params}\n"
+          summary << "Non-trainable params: 0\n"
+          summary << sep
+          puts summary
+        end
+      end
+    end
+  end
+end

data/lib/tensorflow/keras/optimizers/adam.rb

@@ -0,0 +1,8 @@
+module Tensorflow
+  module Keras
+    module Optimizers
+      class Adam
+      end
+    end
+  end
+end

data/lib/tensorflow/keras/preprocessing/image.rb

@@ -0,0 +1,22 @@
+module Tensorflow
+  module Keras
+    module Preprocessing
+      module Image
+        class << self
+          def load_img(path, target_size: nil)
+            img = MiniMagick::Image.open(path)
+            if target_size
+              # TODO make resize consistent with Python
+              img.resize "#{target_size.map(&:to_i).join("x")}!", "-filter", "point"
+            end
+            img
+          end
+
+          def img_to_array(img)
+            Numo::SFloat.cast(img.get_pixels)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tensorflow/keras/utils.rb

@@ -0,0 +1,83 @@
+module Tensorflow
+  module Keras
+    module Utils
+      class << self
+        def add_weight(name: nil, shape: [], initializer: nil, dtype: :float)
+          variable = Variable.new(shape: shape, name: name, dtype: dtype)
+          initial_value =
+            case initializer
+            when "zeros"
+              Tensorflow.fill(shape, 0.0)
+            when "glorot_uniform"
+              # TODO compute fans
+              fan_in = shape[0]
+              fan_out = shape[1]
+              scale = 1.0
+              scale /= [1.0, (fan_in + fan_out) / 2.0].max
+              limit = ::Math.sqrt(3.0 * scale)
+
+              minval = -limit
+              maxval = limit
+
+              rnd = RawOps.random_uniform(shape: shape, dtype: :float)
+              Math.add(rnd * (maxval - minval), minval)
+            else
+              raise Error, "Unknown initializer: #{initializer}"
+            end
+
+          variable.value = initial_value
+          variable
+        end
+
+        def get_file(fname, origin, file_hash: nil, cache_subdir: "datasets")
+          # destination
+          # TODO handle this better
+          raise "No HOME" unless ENV["HOME"]
+          dest = "#{ENV["HOME"]}/.keras/#{cache_subdir}/#{fname}"
+          FileUtils.mkdir_p(File.dirname(dest))
+
+          return dest if File.exist?(dest)
+
+          temp_dir ||= File.dirname(Tempfile.new("tensorflow"))
+          temp_path = "#{temp_dir}/#{Time.now.to_f}" # TODO better name
+
+          digest = file_hash&.size == 32 ? Digest::MD5.new : Digest::SHA2.new
+
+          uri = URI(origin)
+
+          # 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)
+
+            puts "Downloading data from #{origin}"
+            i = 0
+            File.open(temp_path, "wb") do |f|
+              http.request(request) do |response|
+                response.read_body do |chunk|
+                  f.write(chunk)
+                  digest.update(chunk)
+
+                  # print progress
+                  putc "." if i % 50 == 0
+                  i += 1
+                end
+              end
+              puts # newline
+            end
+          end
+
+          if file_hash && digest.hexdigest != file_hash
+            raise Error, "Bad hash"
+          end
+
+          FileUtils.mv(temp_path, dest)
+
+          dest
+        end
+      end
+    end
+  end
+end

data/lib/tensorflow/name_scope.rb

@@ -0,0 +1,57 @@
+require 'set'
+
+module Tensorflow
+  class NameScope
+    attr_reader :stack, :names
+
+    def initialize
+      @stack = Array.new
+      @names = Set.new
+    end
+
+    def name_scope(base_name)
+      name = self.unique_name(base_name)
+      stack.push(name)
+
+      begin
+        yield current_scope if block_given?
+      ensure
+        stack.pop
+      end
+    end
+
+    def current_scope
+      if self.stack.last.nil?
+        nil
+      else
+        self.stack.join("/")
+      end
+    end
+
+    def scoped_name(name)
+      base_name = case
+                    when self.stack.empty?
+                      name
+                    when self.stack.last.nil?
+                      name
+                    else
+                      "#{self.current_scope}/#{name}"
+                  end
+
+      self.unique_name(base_name)
+    end
+
+    def unique_name(name)
+      return nil unless name
+
+      i = 0
+      check_name = name
+      while self.names.include?(check_name.downcase)
+        i += 1
+        check_name = "#{name}_#{i}"
+      end
+      self.names << check_name.downcase unless check_name.nil?
+      check_name
+    end
+  end
+end

data/lib/tensorflow/op_def_builder.rb

@@ -0,0 +1,49 @@
+module Tensorflow
+  class OpDefBuilder
+    def self.unknown_shape_inference_func
+      @unknown_shape_func ||= FFI.ffi_libraries.first.find_function('TF_ShapeInferenceContextSetUnknownShape')
+    end
+
+    def self.finalize(pointer)
+      proc do
+        FFI::TF_DeleteOpDefinitionBuilder(pointer)
+      end
+    end
+
+    def initialize(name)
+      @pointer = FFI.TF_NewOpDefinitionBuilder(name)
+      ObjectSpace.define_finalizer(self, self.class.finalize(@pointer))
+    end
+
+    def to_ptr
+      @pointer
+    end
+
+    def attr(spec)
+      FFI.TF_OpDefinitionBuilderAddAttr(self, spec)
+      self
+    end
+
+    def input(spec)
+      FFI.TF_OpDefinitionBuilderAddInput(self, spec)
+      self
+    end
+
+    def output(spec)
+      FFI.TF_OpDefinitionBuilderAddOutput(self, spec)
+      self
+    end
+
+    def shape_inference(func)
+      FFI.TF_OpDefinitionBuilderSetShapeInferenceFunction(self, func)
+      self
+    end
+
+    def register
+      ObjectSpace.undefine_finalizer(self)
+      Status.check do |status|
+        FFI.TF_RegisterOpDefinition(self, status)
+      end
+    end
+  end
+end

data/lib/tensorflow/ops/audio.rb

@@ -0,0 +1,13 @@
+module Tensorflow
+  module Audio
+    class << self
+      def decode_wav(contents, desired_channels: -1, desired_samples: -1)
+        RawOps.decode_wav(contents: contents, desired_channels: desired_channels, desired_samples: desired_samples)
+      end
+
+      def encode_wav(audio, sample_rate)
+        RawOps.encode_wav(audio: audio, sample_rate: sample_rate)
+      end
+    end
+  end
+end

data/lib/tensorflow/ops/bitwise.rb

@@ -0,0 +1,29 @@
+module Tensorflow
+  module Bitwise
+    class << self
+      def bitwise_and(x, y)
+        RawOps.bitwise_and(x, y)
+      end
+
+      def bitwise_or(x, y)
+        RawOps.bitwise_or(x, y)
+      end
+
+      def bitwise_xor(x, y)
+        RawOps.bitwise_xor(x, y)
+      end
+
+      def invert(x)
+        RawOps.invert(x: x)
+      end
+
+      def left_shift(x, y)
+        RawOps.left_shift(x, y)
+      end
+
+      def right_shift(x, y)
+        RawOps.right_shift(x, y)
+      end
+    end
+  end
+end

data/lib/tensorflow/ops/control.rb

@@ -0,0 +1,13 @@
+module Tensorflow
+  module Control
+    def self.group(inputs, attrs={})
+      graph = ExecutionContext.current(inputs)
+      return if graph.is_a?(Eager::Context)
+
+      graph.control_dependencies(inputs) do
+        RawOps.no_op
+      end
+    end
+  end
+end
+

data/lib/tensorflow/ops/gradients.rb

@@ -0,0 +1,21 @@
+module Tensorflow
+  module Ops
+    def self.broadcast_mul(vector, matrix)
+      vector = Tensorflow.expand_dims(vector, -1)
+      vector * matrix
+    end
+
+    Graph::Gradients.register('SparseSoftmaxCrossEntropyWithLogits') do |gradient, outputs, inputs|
+      message = <<~EOS
+        Currently there is no way to take the second derivative of sparse_softmax_cross_entropy_with_logits due to the fused
+        implementation's interaction with tf.gradients()
+      EOS
+
+      graph = gradient.graph
+      operation = outputs[0].operation
+      sparse_softmax_grad_without_gradient = Tensorflow.prevent_gradient(operation[1], message: message)
+      op = Ops.broadcast_mul(gradient, sparse_softmax_grad_without_gradient)
+      op.outputs
+    end
+  end
+end