tensorflow 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 32ac7a47334631b2c5393721e5a7f848a26d9535b473557e146e8e6b4b6337be
+  data.tar.gz: 21ca600101471ee43edd9a404f3072d67cbbdfa44f412ba8ec76a2546973087d
+SHA512:
+  metadata.gz: 601c99ff6035138797f0e14a0f5f2c52ae68b4ee4c5223ef5676e45aaf2f61a7994f0a2ce2ad353b03fa503d7ad8fd6e9c49ba7567fbdcee2156bffe6d36a4c4
+  data.tar.gz: 825d6b40f58f3cbe4d1c6f5b9cff5c7a739b730a89e025bf305bcdf3789269ce34f851709a0294d2c830ca1621a08ff3a67b352422bafd92eb8dec30f65e42e3

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1.0
+
+- First release

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2019 Andrew Kane
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,113 @@
+# TensorFlow
+
+[TensorFlow](https://github.com/tensorflow/tensorflow) - the end-to-end machine learning platform - for Ruby
+
+:fire: Uses the C API for blazing performance
+
+## Installation
+
+[Install TensorFlow](#tensorflow-installation). For Homebrew, use:
+
+```sh
+brew install tensorflow
+```
+
+Add this line to your application’s Gemfile:
+
+```ruby
+gem 'tensorflow'
+```
+
+## Getting Started
+
+This library follows the TensorFlow 2.0 [Python API](https://www.tensorflow.org/versions/r2.0/api_docs/python/tf). Many methods and options are missing at the moment. PRs welcome!
+
+## Constants
+
+```ruby
+a = Tf.constant(2)
+b = Tf.constant(3)
+a + b
+```
+
+## Variables
+
+```ruby
+v = Tf::Variable.new(0.0)
+w = v + 1
+```
+
+## FizzBuzz
+
+```ruby
+def fizzbuzz(max_num)
+  counter = Tf.constant(0)
+  max_num.times do |i|
+    num = Tf.constant(i + 1)
+    if (num % 3).to_i == 0 && (num % 5).to_i == 0
+      puts "FizzBuzz"
+    elsif (num % 3).to_i == 0
+      puts "Fizz"
+    elsif (num % 5).to_i == 0
+      puts "Buzz"
+    else
+      puts num.to_i
+    end
+  end
+end
+
+fizzbuzz(15)
+```
+
+## Keras
+
+Coming soon
+
+```ruby
+mnist = Tf::Keras::Datasets::MNIST
+(x_train, y_train), (x_test, y_test) = mnist.load_data
+x_train = x_train / 255.0
+x_test = x_test / 255.0
+
+model = Tf::Keras::Models::Sequential.new([
+  Tf::Keras::Layers::Flatten.new(input_shape: [28, 28]),
+  Tf::Keras::Layers::Dense.new(128, activation: "relu"),
+  Tf::Keras::Layers::Dropout.new(0.2),
+  Tf::Keras::Layers::Dense.new(10, activation: "softmax")
+])
+
+model.compile(optimizer: "adam", loss: "sparse_categorical_crossentropy", metrics: ["accuracy"])
+model.fit(x_train, y_train, epochs: 5)
+model.evaluate(x_test, y_test)
+```
+
+## TensorFlow Installation
+
+### Mac
+
+Run:
+
+```sh
+brew install tensorflow
+```
+
+### Linux
+
+Download the [shared library](https://www.tensorflow.org/install/lang_c#download) and move `libtensorflow.so` to `/usr/local/lib`.
+
+### Windows
+
+Download the [shared library](https://www.tensorflow.org/install/lang_c#download) and move `tensorflow.dll` to `C:\Windows\System32`.
+
+## History
+
+View the [changelog](https://github.com/ankane/tensorflow/blob/master/CHANGELOG.md)
+
+## Contributing
+
+Everyone is encouraged to help improve this project. Here are a few ways you can help:
+
+- [Report bugs](https://github.com/ankane/tensorflow/issues)
+- Fix bugs and [submit pull requests](https://github.com/ankane/tensorflow/pulls)
+- Write, clarify, or fix documentation
+- Suggest or add new features

data/lib/tensorflow/context.rb

@@ -0,0 +1,26 @@
+module TensorFlow
+  class Context
+    def initialize
+      options = FFI.TFE_NewContextOptions
+      @status = TensorFlow::FFI.TF_NewStatus
+      @pointer = FFI.TFE_NewContext(options, @status)
+      Utils.check_status @status
+      ObjectSpace.define_finalizer(self, self.class.finalize(@pointer))
+      FFI.TFE_DeleteContextOptions(options)
+    end
+
+    def self.finalize(pointer)
+      # must use proc instead of stabby lambda
+      proc { FFI.TFE_DeleteContext(pointer) }
+    end
+
+    def to_ptr
+      @pointer
+    end
+
+    def shared_name
+      # hard-coded in Python library
+      "cd2c89b7-88b7-44c8-ad83-06c2a9158347"
+    end
+  end
+end

data/lib/tensorflow/ffi.rb

@@ -0,0 +1,60 @@
+module TensorFlow
+  module FFI
+    extend ::FFI::Library
+
+    begin
+      ffi_lib TensorFlow.ffi_lib
+    rescue LoadError => e
+      raise e if ENV["TENSORFLOW_DEBUG"]
+      raise LoadError, "Could not find TensorFlow"
+    end
+
+    # https://github.com/tensorflow/tensorflow/blob/master/tensorflow/c/c_api.h
+    attach_function :TF_Version, %i[], :string
+
+    # https://github.com/tensorflow/tensorflow/blob/master/tensorflow/c/tf_attrtype.h
+    AttrType = enum(:string, :int, :float, :bool, :type, :shape, :tensor, :placeholder, :func)
+
+    # https://github.com/tensorflow/tensorflow/blob/master/tensorflow/c/tf_datatype.h
+    DataType = enum(:float, 1, :double, :int32, :uint8, :int16, :int8, :string, :complex64, :int64, :bool, :qint8, :quint8, :qint32, :bfloat16, :qint16, :quint16, :uint16, :complex128, :half, :resource, :variant, :uint32, :uint64)
+
+    # https://github.com/tensorflow/tensorflow/blob/master/tensorflow/c/tf_status.h
+    attach_function :TF_NewStatus, %i[], :pointer
+    attach_function :TF_DeleteStatus, %i[pointer], :pointer
+    attach_function :TF_GetCode, %i[pointer], :int
+    attach_function :TF_Message, %i[pointer], :string
+
+    # https://github.com/tensorflow/tensorflow/blob/master/tensorflow/c/tf_tensor.h
+    attach_function :TF_NewTensor, %i[int pointer int pointer size_t pointer pointer], :pointer
+    attach_function :TF_DeleteTensor, %i[pointer], :void
+    attach_function :TF_TensorData, %i[pointer], :pointer
+
+    # https://github.com/tensorflow/tensorflow/blob/master/tensorflow/c/eager/c_api.h
+    attach_function :TFE_NewContextOptions, %i[], :pointer
+    attach_function :TFE_ContextOptionsSetAsync, %i[pointer char], :void
+    attach_function :TFE_DeleteContextOptions, %i[pointer], :void
+    attach_function :TFE_NewContext, %i[pointer pointer], :pointer
+    attach_function :TFE_DeleteContext, %i[pointer], :void
+    attach_function :TFE_ContextListDevices, %i[pointer pointer], :pointer
+    attach_function :TFE_ContextGetDevicePlacementPolicy, %i[pointer], :int
+    attach_function :TFE_NewTensorHandle, %i[pointer pointer], :pointer
+    attach_function :TFE_DeleteTensorHandle, %i[pointer], :void
+    attach_function :TFE_TensorHandleDataType, %i[pointer], :int
+    attach_function :TFE_TensorHandleNumDims, %i[pointer pointer], :int
+    attach_function :TFE_TensorHandleNumElements, %i[pointer pointer], :int64
+    attach_function :TFE_TensorHandleDim, %i[pointer int pointer], :int64
+    attach_function :TFE_TensorHandleDeviceName, %i[pointer pointer], :string
+    attach_function :TFE_TensorHandleBackingDeviceName, %i[pointer pointer], :string
+    attach_function :TFE_TensorHandleResolve, %i[pointer pointer], :pointer
+    attach_function :TFE_NewOp, %i[pointer string pointer], :pointer
+    attach_function :TFE_DeleteOp, %i[pointer], :void
+    attach_function :TFE_OpSetDevice, %i[pointer string pointer], :pointer
+    attach_function :TFE_OpGetDevice, %i[pointer pointer], :string
+    attach_function :TFE_OpAddInput, %i[pointer pointer pointer], :void
+    attach_function :TFE_OpGetAttrType, %i[pointer string pointer pointer], :int
+    attach_function :TFE_OpSetAttrString, %i[pointer string pointer size_t], :void
+    attach_function :TFE_OpSetAttrType, %i[pointer string int], :void
+    attach_function :TFE_OpSetAttrShape, %i[pointer string pointer int pointer], :void
+    attach_function :TFE_Execute, %i[pointer pointer pointer pointer], :pointer
+  end
+end

data/lib/tensorflow/tensor.rb

@@ -0,0 +1,193 @@
+module TensorFlow
+  class Tensor
+    def initialize(value = nil, pointer: nil, dtype: nil, shape: nil)
+      @status = FFI.TF_NewStatus
+
+      if pointer
+        @pointer = pointer
+      else
+        data = Array(value)
+        shape ||= calculate_shape(value)
+
+        if shape.size > 0
+          dims_ptr = ::FFI::MemoryPointer.new(:int64, shape.size)
+          dims_ptr.write_array_of_int64(shape)
+        else
+          dims_ptr = nil
+        end
+
+        data = data.flatten
+
+        dtype ||= Utils.infer_type(value)
+        type = FFI::DataType[dtype]
+        case dtype
+        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)
+        else
+          raise "Unknown type: #{dtype}"
+        end
+
+        callback = ::FFI::Function.new(:void, [:pointer, :size_t, :pointer]) do |data, len, arg|
+          # FFI handles deallocation
+        end
+
+        tensor = FFI.TF_NewTensor(type, dims_ptr, shape.size, data_ptr, data_ptr.size, callback, nil)
+        @pointer = FFI.TFE_NewTensorHandle(tensor, @status)
+        check_status @status
+      end
+
+      # TODO fix segfault
+      # ObjectSpace.define_finalizer(self, self.class.finalize(@pointer))
+    end
+
+    def +(other)
+      TensorFlow.add(self, other)
+    end
+
+    def -(other)
+      TensorFlow.subtract(self, other)
+    end
+
+    def *(other)
+      TensorFlow.multiply(self, other)
+    end
+
+    def /(other)
+      TensorFlow.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
+    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 :string
+          # string tensor format
+          # https://github.com/tensorflow/tensorflow/blob/5453aee48858fd375172d7ae22fad1557e8557d6/tensorflow/c/tf_tensor.h#L57
+          start_offset_size = element_count * 8
+          offsets = data_pointer.read_array_of_uint64(element_count)
+          element_count.times.map { |i| (data_pointer + start_offset_size + offsets[i]).read_string }
+        when :bool
+          data_pointer.read_array_of_int8(element_count).map { |v| v == 1 }
+        when :resource
+          return data_pointer
+        else
+          raise "Unknown type: #{dtype}"
+        end
+
+      reshape(value, shape)
+    end
+
+    def to_s
+      inspect
+    end
+
+    def to_i
+      value.to_i
+    end
+
+    def to_a
+      value
+    end
+
+    def inspect
+      inspection = %w(value shape dtype).map { |v| "#{v}: #{send(v).inspect}"}
+      "#<#{self.class} #{inspection.join(", ")}>"
+    end
+
+    def self.finalize(pointer)
+      # must use proc instead of stabby lambda
+      proc { FFI.TFE_DeleteTensorHandle(pointer) }
+    end
+
+    private
+
+    def reshape(arr, dims)
+      return arr.first if dims.empty?
+      arr = arr.flatten
+      dims[1..-1].reverse.each do |dim|
+        arr = arr.each_slice(dim)
+      end
+      arr.to_a
+    end
+
+    def calculate_shape(value)
+      shape = []
+      d = value
+      while d.is_a?(Array)
+        shape << d.size
+        d = d.first
+      end
+      shape
+    end
+
+    # string tensor format
+    # https://github.com/tensorflow/tensorflow/blob/5453aee48858fd375172d7ae22fad1557e8557d6/tensorflow/c/tf_tensor.h#L57
+    def string_ptr(data)
+      start_offset_size = data.size * 8
+      offsets = [0]
+      data.each do |str|
+        offsets << 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)
+      end
+      data_ptr
+    end
+
+    def check_status(status)
+      Utils.check_status(status)
+    end
+  end
+end

data/lib/tensorflow/utils.rb

@@ -0,0 +1,22 @@
+module TensorFlow
+  module Utils
+    def self.check_status(status)
+      if FFI.TF_GetCode(status) != 0
+        raise Error, FFI.TF_Message(status)
+      end
+    end
+
+    def self.infer_type(value)
+      case value
+      when String
+        :string
+      when Float
+        :float
+      when true, false
+        :bool
+      else
+        :int32
+      end
+    end
+  end
+end

data/lib/tensorflow/variable.rb

@@ -0,0 +1,57 @@
+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)
+      assign(initial_value)
+    end
+
+    def assign(value)
+      value = TensorFlow.convert_to_tensor(value, dtype: @dtype)
+      TensorFlow.assign_variable_op(@pointer, value)
+      self
+    end
+
+    def assign_add(value)
+      value = TensorFlow.convert_to_tensor(value, dtype: @dtype)
+      TensorFlow.assign_add_variable_op(@pointer, value)
+      self
+    end
+
+    def assign_sub(value)
+      value = TensorFlow.convert_to_tensor(value, dtype: @dtype)
+      TensorFlow.assign_sub_variable_op(@pointer, value)
+      self
+    end
+
+    def read_value
+      TensorFlow.read_variable_op(@pointer, type_enum)
+    end
+
+    def +(other)
+      v = Variable.new(read_value.value, dtype: @dtype)
+      v.assign_add(other).read_value
+    end
+
+    def -(other)
+      v = Variable.new(read_value.value, dtype: @dtype)
+      v.assign_sub(other).read_value
+    end
+
+    def to_s
+      inspect
+    end
+
+    def inspect
+      value = read_value
+      inspection = %w(value shape dtype).map { |v| "#{v}: #{value.send(v).inspect}"}
+      "#<#{self.class} #{inspection.join(", ")}>"
+    end
+
+    private
+
+    def type_enum
+      FFI::DataType[@dtype.to_sym] if @dtype
+    end
+  end
+end

data/lib/tensorflow/version.rb

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

data/lib/tensorflow.rb

@@ -0,0 +1,188 @@
+# dependencies
+require "ffi"
+
+# modules
+require "tensorflow/utils"
+require "tensorflow/context"
+require "tensorflow/tensor"
+require "tensorflow/variable"
+require "tensorflow/version"
+
+module TensorFlow
+  class Error < StandardError; end
+
+  class << self
+    attr_accessor :ffi_lib
+  end
+  self.ffi_lib = ["tensorflow", "libtensorflow.so"]
+
+  # friendlier error message
+  autoload :FFI, "tensorflow/ffi"
+
+  class << self
+    include Utils
+
+    def library_version
+      FFI.TF_Version
+    end
+
+    def constant(value, dtype: nil, shape: nil)
+      Tensor.new(value, dtype: dtype, shape: shape)
+    end
+
+    def convert_to_tensor(value, dtype: nil)
+      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
+
+# shortcut
+Tf = TensorFlow

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: tensorflow
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andrew Kane
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-09-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  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
+    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: rake
+  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: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5'
+description: 
+email: andrew@chartkick.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/tensorflow.rb
+- lib/tensorflow/context.rb
+- lib/tensorflow/ffi.rb
+- lib/tensorflow/tensor.rb
+- lib/tensorflow/utils.rb
+- lib/tensorflow/variable.rb
+- lib/tensorflow/version.rb
+homepage: https://github.com/ankane/tensorflow
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: TensorFlow - the end-to-end machine learning platform - for Ruby
+test_files: []