tensorflow-ruby 0.2.0

data/lib/tensorflow/ops/raw_ops.rb.erb

@@ -0,0 +1,38 @@
+# Do NOT edit this file. It is generated by `rake generate_ops`
+
+module Tensorflow
+  module RawOps
+    def self.execute(op_type, inputs=[], attrs={})
+      context = ExecutionContext.current(inputs)
+      attrs = attrs.compact
+      operation = context.create_operation(op_type, inputs, attrs)
+      if context.is_a?(Graph::Graph)
+        operation
+      else
+        context.execute(operation)
+      end
+    end
+
+  <% Tensorflow.op_defs.values.sort_by(&:name).each do |op_def|
+     name = RawOpHelper.underscore(op_def.name).downcase
+
+     input_names = op_def.input_arg.map do |input|
+       RawOpHelper.check_name(input.name)
+     end
+
+     attributes_in = op_def.attr.map do |attr_def|
+       RawOpHelper.process_attribute(attr_def)
+     end
+     attributes_in << "name: \"#{op_def.name}\""
+
+     attributes_out = op_def.attr.map do |attr_def|
+       attribute_name = RawOpHelper.check_attribute_name(attr_def)
+       "#{attr_def.name}: #{attribute_name}"
+     end
+     attributes_out << "name: name" %>
+
+    def self.<%= name %>(<%= (input_names + attributes_in).join(', ') %>)
+      self.execute("<%= op_def.name %>", [<%= input_names.join(', ') %>], <%= attributes_out.join(', ') %>)
+    end<% end %>
+  end
+end

data/lib/tensorflow/printers/graph.erb

@@ -0,0 +1,80 @@
+<% graph.operations.each do |operation|
+   op_def = self.graph.op_def(operation.op_type) %>
+node {
+  name: "<%= operation.name %>"
+  op: "<%= operation.op_type %>"
+  <% operation.inputs.each do |input| %>
+  input: "<%= input.operation.name %><%= input.index > 0 ? ":#{input.index}" : "" %>"
+  <% end %>
+  <% operation.control_inputs.each do |control_input| %>
+  input: "^<%= control_input.name %>"
+  <% end %>
+  <% op_def.attr.sort_by(&:name).each do |attr_def|
+     attr = operation.attr(attr_def.name) %>
+  attr {
+    key: "<%= attr_def.name %>"
+    value {
+  <% case attr.metadata[:type]
+     when :tensor %>
+      tensor {
+        dtype: DT_<%= attr.tensor.dtype.upcase %>
+        tensor_shape {
+          <% attr.tensor.shape.each do |dim| %>
+          dim {
+            size: <%= dim %>
+          }
+          <% end %>
+        }
+        <%= attr.tensor.dtype %>_val: <%= attr.tensor.value.is_a?(Numo::NArray) ? attr.tensor.value.to_a : attr.tensor.value %>
+        tensor_content: <%= attr.proto.tensor.tensor_content.dump %>
+      }
+    <% when :type %>
+      <% if attr.list? %>
+      list {
+        <% attr.value.each do |list_value| %>
+        type: DT_<%= list_value.to_s.upcase %>
+        <% end %>
+      }
+      <% else %>
+      type: DT_<%= attr.value.to_s.upcase %>
+      <% end %>
+    <% when :bool %>
+      b: <%= attr.value ? 'true' : 'false' %>
+    <% when :int %>
+      i: <%= attr.value %>
+    <% when :shape %>
+      <% if attr.list? %>
+      list {
+        <% attr.value.each do |list_value| %>
+        shape {
+          <% list_value.each do |sub_list_value| %>
+          dim {
+            size: <%= sub_list_value %>
+          }
+          <% end %>
+        }
+        <% end %>
+      }
+      <% elsif attr.value.empty? %>
+      shape {
+      }
+      <% else %>
+      shape {
+        <%= attr.value.join(', ') %>
+      }
+      <% end %>
+    <% when :string %>
+      s: "<%= attr.value %>"
+    <% when :func %>
+      func {
+        name: "<%= attr.value %>"
+      }
+    <% end %>
+    }
+  }
+  <% end %>
+}
+<% end %>
+versions {
+  producer: 119
+}

data/lib/tensorflow/printers/graph.rb

@@ -0,0 +1,26 @@
+require 'erubi'
+
+module Tensorflow
+  module Printers
+    class Graph
+      attr_reader :graph
+
+      def initialize(graph)
+        @graph = graph
+      end
+
+      def template
+        @template ||= begin
+          path = File.join(__dir__, 'graph.erb')
+          File.read(path, :mode => 'rb')
+        end
+      end
+
+      def print(io_stream=STDOUT)
+        #io_stream << ERB.new(self.template, nil, trim_mode: "<>").result_with_hash(:graph => self.graph)
+        raw = Erubi::Engine.new(self.template, filename: 'graph.erb')
+        io_stream << eval(raw.src)
+      end
+    end
+  end
+end

data/lib/tensorflow/printers/graph_def.erb

@@ -0,0 +1,109 @@
+<% graph_def.node.each do |node_def| %>
+node {
+  name: "<%= node_def.name %>"
+  op: "<%= node_def.op %>"
+  device: "<%= node_def.device %>"
+  <% node_def.input.each do |input| %>
+  input: "<%= input %>"
+  <% end %>
+  <% node_def.attr.sort_by {|key, value| key}.each do |key, attr_def| %>
+  attr {
+    key: "<%= key %>"
+    value {
+  <% case attr_def.value
+     when :tensor %>
+      tensor {
+        dtype: <%= attr_def.tensor.dtype %>
+        tensor_shape {
+          <% attr_def.tensor.tensor_shape.dim.each do |dim| %>
+          dim {
+            size: <%= dim %>
+          }
+          <% end %>
+        }
+        <% value_method = "#{attr_def.tensor.dtype[3..-1].downcase}_val" %>
+        <%= value_method %>: <%= attr_def.tensor.send(value_method.to_sym) %>
+      }
+    <% when :type %>
+      type: <%= attr_def.type %>
+    <% when :list %>
+      list {
+      <% case  %>
+        <% when !attr_def.list.type.empty? %>
+          <% attr_def.list.type.each do |type| %>
+        type: <%= type %>
+          <% end %>
+        <% when !attr_def.list.shape.empty? %>
+          <% attr_def.list.shape.each do |shape| %>
+        shape {
+            <% shape.dim.each do |dim| %>
+          dim {
+            size: <%= dim.size %>
+          }
+            <% end %>
+        }
+          <% end %>
+      <% end %>
+      }
+    <% when :b %>
+      b: <%= attr_def.b %>
+    <% when :int %>
+      i: <%= attr_def.i %>
+    <%# when :shape %>
+      <%# if attr.list? %>
+<!--      list {-->
+        <%# attr.value.each do |list_value| %>
+<!--        shape {-->
+          <%# list_value.each do |sub_list_value| %>
+<!--          dim {-->
+<!--            size: <%#= sub_list_value %>-->
+<!--          }-->
+          <%# end %>
+<!--        }-->
+        <%# end %>
+<!--      }-->
+      <%# elsif attr.value.empty? %>
+<!--      shape {-->
+<!--      }-->
+      <%# else %>
+<!--      shape {-->
+        <%#= attr.value.join(', ') %>
+<!--      }-->
+      <%# end %>
+    <% when :s %>
+      s: "<%= attr_def.s %>"
+    <% when :func %>
+      func {
+        name: "<%= attr_def.func.name %>"
+      }
+    <% end %>
+    }
+  }
+  <% end %>
+}
+<% end %>
+library {
+<% graph_def.library.function.each do |function_def| %>
+  function {
+    signature {
+      name: "<%= function_def.signature.name %>"
+      <% function_def.signature.input_arg.each do |arg_def| %>
+      input_arg {
+        name: "<%= arg_def.name %>"
+        type: <%= arg_def.type %>
+      }
+      <% end %>
+      <% function_def.signature.output_arg.each do |arg_def| %>
+      output_arg {
+        name: "<%= arg_def.name %>"
+        type: <%= arg_def.type %>
+      }
+  <% end %>
+    }
+  }
+<% end %>
+}
+versions {
+  producer: <%= graph_def.versions.producer %>
+  min_consumer: <%= graph_def.versions.min_consumer %>
+}

data/lib/tensorflow/printers/graph_def.rb

@@ -0,0 +1,26 @@
+require 'erubi'
+
+module Tensorflow
+  module Printers
+    class GraphDef
+      attr_reader :graph_def
+
+      def initialize(graph_def)
+        @graph_def = graph_def
+      end
+
+      def template
+        @template ||= begin
+          path = File.join(__dir__, 'graph_def.erb')
+          File.read(path, :mode => 'rb')
+        end
+      end
+
+      def print(io_stream=STDOUT)
+        #io_stream << ERB.new(self.template, nil, trim_mode: "<>").result_with_hash(:graph_def => self.graph_def)
+        raw = Erubi::Engine.new(self.template, filename: 'graph_def.erb')
+        io_stream << eval(raw.src)
+      end
+    end
+  end
+end

data/lib/tensorflow/python_compatiblity.rb

@@ -0,0 +1,55 @@
+module Tensorflow
+  FFI::DataType.symbols.each do |dtype|
+    define_singleton_method(dtype) do
+      dtype
+    end
+  end
+
+  def self.float32
+    :float
+  end
+
+  def self.float64
+    :double
+  end
+
+  module PythonCompatability
+    def disable_eager_execution
+      self.execution_mode = Tensorflow::GRAPH_MODE
+    end
+
+    def enable_eager_execution
+      self.execution_mode = Tensorflow::EAGER_MODE
+    end
+
+    def global_variables
+      if ExecutionContext.eager?
+        []
+      else
+        ExecutionContext.current.get_collection_ref(Graph::GraphKeys::GLOBAL_VARIABLES)
+      end
+    end
+
+    def global_variables_initializer
+      if ExecutionContext.eager?
+        RawOps.no_op
+      else
+        global_variables = ExecutionContext.current.get_collection_ref(Graph::GraphKeys::GLOBAL_VARIABLES)
+        global_variables = Array(global_variables)
+        if global_variables.length > 0
+          self.variables_initializer(global_variables)
+        end
+      end
+    end
+
+    def variables_initializer(variables, name: 'init')
+      if ExecutionContext.eager?
+        RawOps.no_op
+      else
+        Control.group(variables.map(&:initializer))
+      end
+    end
+  end
+end
+
+Tf = Tensorflow

data/lib/tensorflow/resource_summary_writer.rb

@@ -0,0 +1,78 @@
+module Tensorflow
+  class ResourceSummaryWriter
+    attr_accessor :step
+    attr_reader :initializer
+
+    def initialize(shared_name: "", container: "")
+      self.step = 1
+      @resource = RawOps.summary_writer(shared_name: shared_name, container: container)
+      @initializer = yield @resource
+    end
+
+    def create_summary_metadata(display_name, description)
+      metadata = SummaryMetadata.new
+      metadata.display_name = display_name
+      metadata.summary_description = description
+      metadata.plugin_data = SummaryMetadata.PluginData.new
+      metadata.plugin_data.plugin_name = 'scalars'
+    end
+
+    def step=(value)
+      @step = value.is_a?(Variable) ? value : Tensor.new(value, dtype: :int64)
+    end
+
+    def audio(tag, tensor, sample_rate, max_outputs: 3)
+      tensor = Tensor.from_value(tensor, dtype: :float)
+      result = RawOps.write_audio_summary(@resource, self.step, tag, tensor, sample_rate, max_outputs: max_outputs)
+      ExecutionContext.current.add_to_collection(Graph::GraphKeys::SUMMARY_COLLECTION, result)
+      result
+    end
+
+    def graph(graph)
+      RawOps.write_graph_summary(@resource, self.step, graph.as_graph_def)
+    end
+
+    def histogram(tag, values)
+      result = RawOps.write_histogram_summary(@resource, self.step, tag, values)
+      ExecutionContext.current.add_to_collection(Graph::GraphKeys::SUMMARY_COLLECTION, result)
+      result
+    end
+
+    def image(tag, tensor, bad_color=nil)
+      bad_color ||= Tensor.new([255, 0, 0, 255], dtype: :uint8)
+      result = RawOps.write_image_summary(@resource, self.step, tag, tensor, bad_color)
+      ExecutionContext.current.add_to_collection(Graph::GraphKeys::SUMMARY_COLLECTION, result)
+      result
+    end
+
+    def proto(tag, tensor)
+      result = RawOps.write_raw_proto_summary(@resource, self.step, tensor)
+      ExecutionContext.current.add_to_collection(Graph::GraphKeys::SUMMARY_COLLECTION, result)
+      result
+    end
+
+    def scalar(tag, value, dtype: nil)
+      result = RawOps.write_scalar_summary(@resource, self.step, tag, value, typeT: dtype)
+      ExecutionContext.current.add_to_collection(Graph::GraphKeys::SUMMARY_COLLECTION, result)
+      result
+    end
+
+    def write(tag, value, metadata: "".b)
+      value = Tensor.new(value)
+      dtype ||= value.dtype
+
+      result = RawOps.write_summary(@resource, step, value, tag, metadata, typeT: dtype)
+      ExecutionContext.current.add_to_collection(Graph::GraphKeys::SUMMARY_COLLECTION, result)
+      result
+    end
+    alias :generic :write
+
+    def flush
+      RawOps.flush_summary_writer(@resource)
+    end
+
+    def close
+      RawOps.close_summary_writer(@resource)
+    end
+  end
+end

data/lib/tensorflow/status.rb

@@ -0,0 +1,49 @@
+# Status holds error information returned by TensorFlow. We
+# can use status to get error and even display the error messages from tensorflow.
+module Tensorflow
+  class Status
+    def self.finalize(pointer)
+      proc do
+        FFI::TF_DeleteStatus(pointer)
+      end
+    end
+
+    def self.check
+      status = Status.new
+      result = yield status
+      status.check
+      status = nil
+      result
+    end
+
+    def initialize
+      @pointer = FFI.TF_NewStatus
+      ObjectSpace.define_finalizer(self, self.class.finalize(@pointer))
+    end
+
+    def to_ptr
+      @pointer
+    end
+
+    def code
+      FFI.TF_GetCode(self)
+    end
+
+    def message
+      FFI.TF_Message(self)
+    end
+
+    def set(code, message)
+      FFI.TF_SetStatus(self, code, message)
+    end
+
+    def check
+      if self.code != :tf_ok
+        camel_case = self.code[3..-1].capitalize
+        camel_case.gsub!(/(?:_|(\/))([a-z\d]*)/i) {"#{$1}#{$2.capitalize}"}
+        error_klass = Tensorflow::Error.const_get("#{camel_case}Error")
+        raise(error_klass, self.message)
+      end
+    end
+  end
+end