tensorflow-ruby 0.2.0

data/lib/tensorflow/tensor_mixin.rb

@@ -0,0 +1,32 @@
+module Tensorflow
+  module TensorMixin
+    def shape
+      @shape ||= begin
+        status = Status.new
+        shape = []
+        if self
+          num_dims.times do |i|
+            shape << dim(i)
+            status.check
+          end
+        end
+        shape
+      end
+    end
+
+    def numo
+      case dtype
+        when NilClass
+          nil
+        when :variant
+          :variant
+        when :string
+          :string
+        else
+          klass = TensorData::DTYPE_TO_NUMO_TYPE_MAP[dtype]
+          raise "Unknown type: #{dtype}" unless klass
+          klass.cast(value)
+      end
+    end
+  end
+end

data/lib/tensorflow/tensor_spec.rb

@@ -0,0 +1,10 @@
+module Tensorflow
+  class TensorSpec < BatchableTypeSpec
+    attr_reader :shape, :dtype
+
+    def initialize(shape, dtype)
+      @shape = shape
+      @dtype = dtype
+    end
+  end
+end

data/lib/tensorflow/tensorflow/core/util/event_pb.rb

@@ -0,0 +1,93 @@
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: tensorflow/core/util/event.proto
+
+require 'google/protobuf'
+
+require 'tensorflow/core/framework/summary_pb'
+Google::Protobuf::DescriptorPool.generated_pool.build do
+  add_file("tensorflow/core/util/event.proto", :syntax => :proto3) do
+    add_message "tensorflow.Event" do
+      optional :wall_time, :double, 1
+      optional :step, :int64, 2
+      oneof :what do
+        optional :file_version, :string, 3
+        optional :graph_def, :bytes, 4
+        optional :summary, :message, 5, "tensorflow.Summary"
+        optional :log_message, :message, 6, "tensorflow.LogMessage"
+        optional :session_log, :message, 7, "tensorflow.SessionLog"
+        optional :tagged_run_metadata, :message, 8, "tensorflow.TaggedRunMetadata"
+        optional :meta_graph_def, :bytes, 9
+      end
+    end
+    add_message "tensorflow.LogMessage" do
+      optional :level, :enum, 1, "tensorflow.LogMessage.Level"
+      optional :message, :string, 2
+    end
+    add_enum "tensorflow.LogMessage.Level" do
+      value :UNKNOWN, 0
+      value :DEBUGGING, 10
+      value :INFO, 20
+      value :WARN, 30
+      value :ERROR, 40
+      value :FATAL, 50
+    end
+    add_message "tensorflow.SessionLog" do
+      optional :status, :enum, 1, "tensorflow.SessionLog.SessionStatus"
+      optional :checkpoint_path, :string, 2
+      optional :msg, :string, 3
+    end
+    add_enum "tensorflow.SessionLog.SessionStatus" do
+      value :STATUS_UNSPECIFIED, 0
+      value :START, 1
+      value :STOP, 2
+      value :CHECKPOINT, 3
+    end
+    add_message "tensorflow.TaggedRunMetadata" do
+      optional :tag, :string, 1
+      optional :run_metadata, :bytes, 2
+    end
+    add_message "tensorflow.WatchdogConfig" do
+      optional :timeout_ms, :int64, 1
+    end
+    add_message "tensorflow.RequestedExitCode" do
+      optional :exit_code, :int32, 1
+    end
+    add_message "tensorflow.WorkerHeartbeatRequest" do
+      optional :shutdown_mode, :enum, 1, "tensorflow.WorkerShutdownMode"
+      optional :watchdog_config, :message, 2, "tensorflow.WatchdogConfig"
+      optional :exit_code, :message, 3, "tensorflow.RequestedExitCode"
+    end
+    add_message "tensorflow.WorkerHeartbeatResponse" do
+      optional :health_status, :enum, 1, "tensorflow.WorkerHealth"
+      repeated :worker_log, :message, 2, "tensorflow.Event"
+      optional :hostname, :string, 3
+    end
+    add_enum "tensorflow.WorkerHealth" do
+      value :OK, 0
+      value :RECEIVED_SHUTDOWN_SIGNAL, 1
+      value :INTERNAL_ERROR, 2
+      value :SHUTTING_DOWN, 3
+    end
+    add_enum "tensorflow.WorkerShutdownMode" do
+      value :DEFAULT, 0
+      value :NOT_CONFIGURED, 1
+      value :WAIT_FOR_COORDINATOR, 2
+      value :SHUTDOWN_AFTER_TIMEOUT, 3
+    end
+  end
+end
+
+module Tensorflow
+  Event = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("tensorflow.Event").msgclass
+  LogMessage = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("tensorflow.LogMessage").msgclass
+  LogMessage::Level = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("tensorflow.LogMessage.Level").enummodule
+  SessionLog = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("tensorflow.SessionLog").msgclass
+  SessionLog::SessionStatus = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("tensorflow.SessionLog.SessionStatus").enummodule
+  TaggedRunMetadata = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("tensorflow.TaggedRunMetadata").msgclass
+  WatchdogConfig = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("tensorflow.WatchdogConfig").msgclass
+  RequestedExitCode = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("tensorflow.RequestedExitCode").msgclass
+  WorkerHeartbeatRequest = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("tensorflow.WorkerHeartbeatRequest").msgclass
+  WorkerHeartbeatResponse = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("tensorflow.WorkerHeartbeatResponse").msgclass
+  WorkerHealth = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("tensorflow.WorkerHealth").enummodule
+  WorkerShutdownMode = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("tensorflow.WorkerShutdownMode").enummodule
+end

data/lib/tensorflow/train/gradient_descent_optimizer.rb

@@ -0,0 +1,33 @@
+# Based on code from https://github.com/jedld/tensor_stream
+
+module Tensorflow
+  module Train
+    class GradientDescentOptimizer < Optimizer
+      attr_accessor :learning_rate
+
+      def initialize(learning_rate, use_locking: false, name: "GradientDescent")
+        @learning_rate = learning_rate
+        @learning_rate_tensor = nil
+        super(name: name, use_locking: use_locking)
+      end
+
+      protected
+
+      def prepare
+        learning_rate = call_if_callable(@learning_rate)
+        @learning_rate_tensor = Tensorflow.constant(learning_rate, name: "learning_rate")
+      end
+
+      def apply_dense(grad, var)
+        dtype = grad.output_types.first
+        learning_rate = if @learning_rate_tensor.output_types.first == dtype
+                          @learning_rate_tensor
+                        else
+                          Tensorflow.cast(@learning_rate_tensor, dtype)
+                        end
+
+        RawOps.resource_apply_gradient_descent(var, learning_rate, grad)
+      end
+    end
+  end
+end

data/lib/tensorflow/train/optimizer.rb

@@ -0,0 +1,158 @@
+# Based on code from https://github.com/jedld/tensor_stream
+module Tensorflow
+  module Train
+    class Optimizer
+      attr_reader :name
+
+      def initialize(name: nil, use_locking: false)
+        @name = name
+        @use_locking = use_locking
+        raise(Error::InvalidArgumentError, "Must specify the optimizer name") unless name
+
+        @slots = {}
+        @non_slots = {}
+      end
+
+      def graph
+        ExecutionContext.current
+      end
+
+      def minimize(loss, var_list: nil, grad_loss: nil, global_step: nil, name: nil)
+        grads_and_vars = compute_gradients(loss, var_list: var_list, grad_loss: grad_loss)
+        if grads_and_vars.empty?
+          raise(Error::InvalidArgumentError, "No gradients provided for any variable, check your graph for ops that do not support gradients")
+        end
+        apply_gradients(grads_and_vars, global_step: global_step, name: name)
+      end
+
+      def apply_gradients(grads_and_vars, global_step: nil, name: nil)
+        varlist = grads_and_vars.map { |_grad, var| var }
+        #create_slots(varlist)
+        #TensorStream.name_scope(name, default: @name) do
+          prepare
+          apply_ops = grads_and_vars.map do |grad, var|
+            #TensorStream.name_scope("update_" + var.op.name) do
+              apply_dense(grad, var)
+            #end
+          end
+
+          if global_step.nil?
+            finish(apply_ops, name)
+          else
+            global_step.handle.graph.control_dependencies([finish(apply_ops, "update")]) do
+              global_step.assign_add(Tensorflow.constant(1, dtype:global_step.dtype))
+            end
+          end
+        #end
+      end
+
+      def compute_gradients(loss, var_list: nil, grad_loss: nil)
+        trainable_vars = var_list || self.graph.get_collection_ref(Tensorflow::Graph::GraphKeys::TRAINABLE_VARIABLES)
+
+        if trainable_vars.nil? || trainable_vars.empty?
+          raise(Error::InvalidArgumentError, 'There are no variables to train for the loss function')
+        end
+        gradients = Graph::Gradients.new(graph)
+        grads = gradients.gradients(loss, trainable_vars, grad_ys: grad_loss)
+
+        grads.zip(trainable_vars)
+      end
+
+      def get_slot(var, name)
+        named_slots = @slots.fetch(name, nil)
+        return nil if named_slots.nil?
+
+        named_slots.fetch(var_key(var), nil)
+      end
+
+      def get_slot_names
+        @slots.keys.sort
+      end
+
+      protected
+
+      def finish(update_ops, name_scope)
+        Control.group(update_ops, name: name_scope)
+      end
+
+      def create_slots(var_list)
+        # no implementation
+      end
+
+      def prepare
+        # no implementation
+      end
+
+      def apply_dense(_grad, _var)
+        raise(Error::UnimplementedError, "Not implemented")
+      end
+
+      ##
+      # Find or create a slot initialized with 0.0.
+      #
+      # Args:
+      #   var: Variable - A Variable object
+      #   slot_name: string - Name for the slot
+      #   op_name: string - Name to use when scoping the Variable that needs to be created
+      def zeros_slot(var, slot_name, op_name)
+        named_slots = slot_dict(slot_name)
+        unless named_slots.key?(var_key(var))
+          named_slots[var_key(var)] = create_zeros_slot(var, op_name)
+        end
+        named_slots[var_key(var)]
+      end
+
+      ##
+      # Returns a dict for caching slots created under the given name.
+      #
+      # Args:
+      # slot_name string Name for the slot
+      #
+      # Returns: A dict that maps primary 'Variable' objects to the slot created
+      def slot_dict(slot_name)
+        named_slots = @slots.fetch(slot_name, nil)
+        if named_slots.nil?
+          named_slots = {}
+          @slots[slot_name] = named_slots
+        end
+        named_slots
+      end
+
+      def var_key(var)
+        [var.op.graph, var.op.name]
+      end
+
+      def get_non_slot_variable(name, graph: nil)
+        non_slot = @non_slots.fetch([name, graph], nil)
+        non_slot
+      end
+
+      def call_if_callable(param)
+        param.is_a?(Proc) ? param.call : param
+      end
+
+      def create_non_slot_variable(initial_value, name, colocate_with)
+        graph = colocate_with.graph
+
+        key = [name, graph]
+        v = @non_slots.fetch(key, nil)
+        if v.nil?
+          v = TensorStream.variable(initial_value, name: name, trainable: false)
+          @non_slots[key] = v
+        end
+        v
+      end
+
+      ##
+      # Find or create a slot for a variable, using an Initializer.
+      def get_or_make_slot_with_initializer(var, initializer, shape, dtype, slot_name, op_name)
+        named_slots = slot_dict(slot_name)
+        unless named_slots.key?(var_key(var))
+          new_slot_variable = create_slot_with_initializer(var, initializer, shape, dtype, op_name)
+          named_slots[var_key(var)] = new_slot_variable
+        end
+        named_slots[var_key(var)]
+      end
+    end
+  end
+end

data/lib/tensorflow/type_spec.rb

@@ -0,0 +1,4 @@
+module Tensorflow
+  class TypeSpec
+  end
+end

data/lib/tensorflow/variable.rb

@@ -0,0 +1,127 @@
+module Tensorflow
+  class Variable
+    include Operators
+
+    attr_reader :handle, :dtype, :name
+
+    def initialize(initial_value = nil, dtype: nil, shape: nil, shared_name: nil, name: 'Variable', trainable: true)
+      initial_value = case initial_value
+                      when NilClass
+                        @dtype = dtype
+                        shape = []
+                        initial_value
+                      when Graph::Operation
+                        @dtype = dtype || initial_value.dtype
+                        shape = shape || initial_value.output_shapes.first
+                        initial_value
+                      when Tensor
+                        @dtype = initial_value.dtype
+                        shape = shape || initial_value.shape
+                        initial_value
+                      else
+                        tensor = Tensor.from_value(initial_value, dtype: dtype)
+                        @dtype = tensor.dtype
+                        shape = tensor.shape
+                        tensor
+                      end
+
+      name = name&.to_s
+      shared_name = shared_name&.to_s
+      unique_name = ExecutionContext.current.unique_name(name || shared_name)
+      shared_name ||= unique_name
+      @name = unique_name
+
+      collections = [Graph::GraphKeys::GLOBAL_VARIABLES]
+      if trainable
+        collections << Graph::GraphKeys::TRAINABLE_VARIABLES
+      end
+
+      ExecutionContext.current.add_to_collections(collections, self)
+
+      @handle = RawOps.var_handle_op(dtype: @dtype, shape: shape, shared_name: shared_name, name: unique_name)
+      self.value = initial_value if initial_value
+    end
+
+    def value_handle
+      @value_handle ||= RawOps.read_variable_op(self.handle, dtype: @dtype)
+    end
+
+    def value
+      case value_handle
+        when Eager::TensorHandle
+          value_handle.value
+        when Graph::Operation
+          value_handle
+      end
+    end
+
+    def value=(value)
+      @initializer = RawOps.assign_variable_op(self.handle, value, dtype: @dtype)
+    end
+
+    def initializer
+      @initializer
+    end
+
+    def initialized?
+      RawOps.var_is_initialized_op(self.handle)
+    end
+
+    # These methods match the operation api to enable gradients and sessions
+    def consumers
+      self.handle.consumers
+    end
+
+    # This enables executing variables to get the values in a session
+    def outputs
+      [Graph::OperationOutput.from_index(self.value_handle, 0)]
+    end
+
+    def to_ptr
+      self.handle.to_ptr
+    end
+
+    def shape
+      self.value_handle.shape
+    end
+
+    def tensor
+      raise(Error::UnavailableError, "Only supported in eager execution mode") if Tensorflow.execution_mode == Tensorflow::GRAPH_MODE
+      self.value_handle.tensor
+    end
+
+    def rank
+      self.shape.size
+    end
+
+    def reshape(shape)
+      RawOps.reshape(self, shape)
+    end
+
+    def assign_add(value, dtype: nil)
+      @value_handle = nil
+      tensor = Tensor.from_value(value, dtype: dtype)
+      tensor = Tensorflow.cast(tensor, self.dtype)
+      RawOps.assign_add_variable_op(self.handle, value, dtype: tensor.dtype)
+    end
+
+    def assign_sub(value)
+      @value_handle = nil
+      tensor = Tensor.from_value(value, dtype: dtype)
+      tensor = Tensorflow.cast(tensor, self.dtype)
+      RawOps.assign_sub_variable_op(self.handle, value, dtype: tensor.dtype)
+    end
+
+    def to_s
+      inspect
+    end
+
+    def inspect
+      inspection = []
+      inspection << ["name: #{self.handle.name}"] if self.handle.respond_to?(:name)
+      inspection << ["shape: #{self.value_handle.shape}"]
+      inspection << ["dtype: #{self.value_handle.dtype}"]
+      "#<#{self.class} #{inspection.join(", ")}>"
+    end
+  end
+end