tensorflow 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32ac7a47334631b2c5393721e5a7f848a26d9535b473557e146e8e6b4b6337be
-  data.tar.gz: 21ca600101471ee43edd9a404f3072d67cbbdfa44f412ba8ec76a2546973087d
+  metadata.gz: 509b05a4a14e0bbb314c682f4172959b264e6709f92afc0fa0a749afccfe233b
+  data.tar.gz: daa060a1cb5c2602a652d87b75986a78a0d440c631b5fd7363e822363339f0ca
 SHA512:
-  metadata.gz: 601c99ff6035138797f0e14a0f5f2c52ae68b4ee4c5223ef5676e45aaf2f61a7994f0a2ce2ad353b03fa503d7ad8fd6e9c49ba7567fbdcee2156bffe6d36a4c4
-  data.tar.gz: 825d6b40f58f3cbe4d1c6f5b9cff5c7a739b730a89e025bf305bcdf3789269ce34f851709a0294d2c830ca1621a08ff3a67b352422bafd92eb8dec30f65e42e3
+  metadata.gz: '0755950b3b9865fe17a60efa970c23afcbbba33250b78e78bed7ddb907d90ecdfe64ffdd3fc48533ab6a30fbee6a64dbe6fd4d30e8554ca5c3f9535ea46e1daa'
+  data.tar.gz: 7307f84476cf789486a4f21328056a5abc5485a9dadeff99216dfa12f7a68c2b24f410fdb7caaca1c90a43d3497e03bb9459dbb876543819dce5e210afd02e3a

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.1.1
+
+- Added more operations
+- Added support for more data types
+- Added MNIST dataset
+
 ## 0.1.0
 
 - First release

data/README.md

@@ -2,7 +2,9 @@
 
 [TensorFlow](https://github.com/tensorflow/tensorflow) - the end-to-end machine learning platform - for Ruby
 
-:fire: Uses the C API for blazing performance
+:fire: Uses the C API under the hood
+
+[![Build Status](https://travis-ci.org/ankane/tensorflow.svg?branch=master)](https://travis-ci.org/ankane/tensorflow)
 
 ## Installation
 
@@ -20,7 +22,7 @@ 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!
+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. Here’s the [current plan](https://github.com/ankane/tensorflow/issues/1). Additional PRs welcome!
 
 ## Constants
 
@@ -41,7 +43,6 @@ w = v + 1
 
 ```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
@@ -91,9 +92,11 @@ Run:
 brew install tensorflow
 ```
 
+Alternatively, download the [shared library](https://www.tensorflow.org/install/lang_c#download) and move the files in `lib` to `/usr/local/lib`.
+
 ### Linux
 
-Download the [shared library](https://www.tensorflow.org/install/lang_c#download) and move `libtensorflow.so` to `/usr/local/lib`.
+Download the [shared library](https://www.tensorflow.org/install/lang_c#download) and move the files in `lib` to `/usr/local/lib`.
 
 ### Windows
 

data/lib/tensorflow/ffi.rb

@@ -9,8 +9,15 @@ module TensorFlow
       raise LoadError, "Could not find TensorFlow"
     end
 
+    class Buffer < ::FFI::Struct
+      layout :data, :pointer,
+        :length, :size_t,
+        :data_deallocator, :pointer
+    end
+
     # https://github.com/tensorflow/tensorflow/blob/master/tensorflow/c/c_api.h
     attach_function :TF_Version, %i[], :string
+    attach_function :TF_GetAllOpList, %i[], Buffer.by_ref
 
     # https://github.com/tensorflow/tensorflow/blob/master/tensorflow/c/tf_attrtype.h
     AttrType = enum(:string, :int, :float, :bool, :type, :shape, :tensor, :placeholder, :func)

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

@@ -0,0 +1,17 @@
+module TensorFlow
+  module Keras
+    module Datasets
+      module MNIST
+        def self.load_data
+          # TODO verify hash
+          data = Utils.load_dataset(
+            "mnist.npz",
+            "https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz"
+          )
+
+          [[data["x_train"], data["y_train"]], [data["x_test"], data["y_test"]]]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module TensorFlow
+  module Keras
+    module Layers
+      class Dense
+        def initialize(units, activation: nil)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module TensorFlow
+  module Keras
+    module Layers
+      class Dropout
+        def initialize(rate)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module TensorFlow
+  module Keras
+    module Layers
+      class Flatten
+        def initialize(input_shape: nil)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+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
+      end
+    end
+  end
+end

data/lib/tensorflow/math.rb

@@ -0,0 +1,465 @@
+module TensorFlow
+  module Math
+    class << self
+      def abs(x)
+        RawOps.abs(x: x)
+      end
+
+      # def accumulate_n
+      # end
+
+      def acos(x)
+        RawOps.acos(x: x)
+      end
+
+      def acosh(x)
+        RawOps.acosh(x: x)
+      end
+
+      def add(x, y)
+        RawOps.add(x: x, y: y)
+      end
+
+      def add_n(inputs)
+        RawOps.add_n(inputs: inputs)
+      end
+
+      def angle(input)
+        RawOps.angle(input: input)
+      end
+
+      # def argmax
+      # end
+
+      # def argmin
+      # end
+
+      def asin(x)
+        RawOps.asin(x: x)
+      end
+
+      def asinh(x)
+        RawOps.asinh(x: x)
+      end
+
+      def atan(x)
+        RawOps.atan(x: x)
+      end
+
+      def atan2(y, x)
+        RawOps.atan2(y: y, x: x)
+      end
+
+      def atanh(x)
+        RawOps.atanh(x: x)
+      end
+
+      # def bessel_i0
+      # end
+
+      def bessel_i0e(x)
+        RawOps.bessel_i0e(x: x)
+      end
+
+      # def bessel_i1
+      # end
+
+      def bessel_i1e(x)
+        RawOps.bessel_i1e(x: x)
+      end
+
+      def betainc(a, b, x)
+        RawOps.betainc(a: a, b: b, x: x)
+      end
+
+      def bincount(arr, size, weights)
+        RawOps.bincount(arr: arr, size: size, weights: weights)
+      end
+
+      def ceil(x)
+        RawOps.ceil(x: x)
+      end
+
+      # def confusion_matrix
+      # end
+
+      def conj(input)
+        RawOps.conj(input: input)
+      end
+
+      def cos(x)
+        RawOps.cos(x: x)
+      end
+
+      def cosh(x)
+        RawOps.cosh(x: x)
+      end
+
+      # def count_nonzero
+      # end
+
+      def cumprod(x, axis, exclusive: nil, reverse: nil)
+        RawOps.cumprod(x: x, axis: axis, exclusive: exclusive, reverse: reverse)
+      end
+
+      def cumsum(x, axis, exclusive: nil, reverse: nil)
+        RawOps.cumsum(x: x, axis: axis, exclusive: exclusive, reverse: reverse)
+      end
+
+      # def cumulative_logsumexp
+      # end
+
+      def digamma(x)
+        RawOps.digamma(x: x)
+      end
+
+      def divide(x, y)
+        RawOps.div(x: x, y: y)
+      end
+
+      # def divide_no_nan
+      # end
+
+      def equal(x, y)
+        RawOps.equal(x: x, y: y)
+      end
+
+      def erf(x)
+        RawOps.erf(x: x)
+      end
+
+      def erfc(x)
+        RawOps.erfc(x: x)
+      end
+
+      def exp(x)
+        RawOps.exp(x: x)
+      end
+
+      def expm1(x)
+        RawOps.expm1(x: x)
+      end
+
+      def floor(x)
+        RawOps.floor(x: x)
+      end
+
+      def floordiv(x, y)
+        RawOps.floor_div(x: x, y: y)
+      end
+
+      def floormod(x, y)
+        RawOps.floor_mod(x: x, y: y)
+      end
+
+      def greater(x, y)
+        RawOps.greater(x: x, y: y)
+      end
+
+      def greater_equal(x, y)
+        RawOps.greater_equal(x: x, y: y)
+      end
+
+      def igamma(a, x)
+        RawOps.igamma(a: a, x: x)
+      end
+
+      def igammac(a, x)
+        RawOps.igammac(a: a, x: x)
+      end
+
+      def imag(input)
+        RawOps.imag(input: input)
+      end
+
+      def in_top_k(predictions, targets, k: nil)
+        RawOps.in_top_k(predictions: predictions, targets: targets, k: k)
+      end
+
+      def invert_permutation(x)
+        RawOps.invert_permutation(x: x)
+      end
+
+      def is_finite(x)
+        RawOps.is_finite(x: x)
+      end
+
+      def is_inf(x)
+        RawOps.is_inf(x: x)
+      end
+
+      def is_nan(x)
+        RawOps.is_nan(x: x)
+      end
+
+      # def is_non_decreasing
+      # end
+
+      # def is_strictly_increasing
+      # end
+
+      # def l2_normalize
+      # end
+
+      # def lbeta
+      # end
+
+      def less(x, y)
+        RawOps.less(x: x, y: y)
+      end
+
+      def less_equal(x, y)
+        RawOps.less_equal(x: x, y: y)
+      end
+
+      def lgamma(x)
+        RawOps.lgamma(x: x)
+      end
+
+      def log(x)
+        RawOps.log(x: x)
+      end
+
+      def log1p(x)
+        RawOps.log1p(x: x)
+      end
+
+      # def log_sigmoid
+      # end
+
+      def log_softmax(logits)
+        RawOps.log_softmax(logits: logits)
+      end
+
+      def logical_and(x, y)
+        RawOps.logical_and(x: x, y: y)
+      end
+
+      def logical_not(x)
+        RawOps.logical_not(x: x)
+      end
+
+      def logical_or(x, y)
+        RawOps.logical_or(x: x, y: y)
+      end
+
+      # def logical_xor
+      # end
+
+      def maximum(x, y)
+        RawOps.maximum(x: x, y: y)
+      end
+
+      def minimum(x, y)
+        RawOps.minimum(x: x, y: y)
+      end
+
+      def mod(x, y)
+        RawOps.mod(x: x, y: y)
+      end
+
+      def multiply(x, y)
+        RawOps.mul(x: x, y: y)
+      end
+
+      # def multiply_no_nan
+      # end
+
+      # def negative
+      # end
+
+      # def nextafter
+      # end
+
+      def not_equal(x, y)
+        RawOps.not_equal(x: x, y: y)
+      end
+
+      def polygamma(a, x)
+        RawOps.polygamma(a: a, x: x)
+      end
+
+      # def polyval
+      # end
+
+      def pow(x, y)
+        RawOps.pow(x: x, y: y)
+      end
+
+      def real(input)
+        RawOps.real(input: input)
+      end
+
+      def reciprocal(x)
+        RawOps.reciprocal(x: x)
+      end
+
+      # def reciprocal_no_nan
+      # end
+
+      # def reduce_all
+      # end
+
+      # def reduce_any
+      # end
+
+      # def reduce_euclidean_norm
+      # end
+
+      # def reduce_logsumexp
+      # end
+
+      # def reduce_max
+      # end
+
+      # def reduce_mean
+      # end
+
+      # def reduce_min
+      # end
+
+      # def reduce_prod
+      # end
+
+      # def reduce_std
+      # end
+
+      # def reduce_sum
+      # end
+
+      # def reduce_variance
+      # end
+
+      def rint(x)
+        RawOps.rint(x: x)
+      end
+
+      def round(x)
+        RawOps.round(x: x)
+      end
+
+      def rsqrt(x)
+        RawOps.rsqrt(x: x)
+      end
+
+      # def scalar_mul
+      # end
+
+      def segment_max(data, segment_ids)
+        RawOps.segment_max(data: data, segment_ids: segment_ids)
+      end
+
+      def segment_mean(data, segment_ids)
+        RawOps.segment_mean(data: data, segment_ids: segment_ids)
+      end
+
+      def segment_min(data, segment_ids)
+        RawOps.segment_min(data: data, segment_ids: segment_ids)
+      end
+
+      def segment_prod(data, segment_ids)
+        RawOps.segment_prod(data: data, segment_ids: segment_ids)
+      end
+
+      def segment_sum(data, segment_ids)
+        RawOps.segment_sum(data: data, segment_ids: segment_ids)
+      end
+
+      def sigmoid(x)
+        RawOps.sigmoid(x: x)
+      end
+
+      def sign(x)
+        RawOps.sign(x: x)
+      end
+
+      def sin(x)
+        RawOps.sin(x: x)
+      end
+
+      def sinh(x)
+        RawOps.sinh(x: x)
+      end
+
+      def softmax(logits)
+        RawOps.softmax(logits: logits)
+      end
+
+      def softplus(features)
+        RawOps.softplus(features: features)
+      end
+
+      def softsign(features)
+        RawOps.softsign(features: features)
+      end
+
+      def sqrt(x)
+        RawOps.sqrt(x: x)
+      end
+
+      def square(x)
+        RawOps.square(x: x)
+      end
+
+      def squared_difference(x, y)
+        RawOps.squared_difference(x: x, y: y)
+      end
+
+      def subtract(x, y)
+        RawOps.sub(x: x, y: y)
+      end
+
+      def tan(x)
+        RawOps.tan(x: x)
+      end
+
+      def tanh(x)
+        RawOps.tanh(x: x)
+      end
+
+      def top_k(input, k: nil, sorted: nil)
+        RawOps.top_k(input: input, k: k, sorted: sorted)
+      end
+
+      # def truediv
+      # end
+
+      def unsorted_segment_max(data, segment_ids, num_segments)
+        RawOps.unsorted_segment_max(data: data, segment_ids: segment_ids, num_segments: num_segments)
+      end
+
+      # def unsorted_segment_mean
+      # end
+
+      def unsorted_segment_min(data, segment_ids, num_segments)
+        RawOps.unsorted_segment_min(data: data, segment_ids: segment_ids, num_segments: num_segments)
+      end
+
+      def unsorted_segment_prod(data, segment_ids, num_segments)
+        RawOps.unsorted_segment_prod(data: data, segment_ids: segment_ids, num_segments: num_segments)
+      end
+
+      # def unsorted_segment_sqrt_n
+      # end
+
+      def unsorted_segment_sum(data, segment_ids, num_segments)
+        RawOps.unsorted_segment_sum(data: data, segment_ids: segment_ids, num_segments: num_segments)
+      end
+
+      def xdivy(x, y)
+        RawOps.xdivy(x: x, y: y)
+      end
+
+      def xlogy(x, y)
+        RawOps.xlogy(x: x, y: y)
+      end
+
+      # def zero_fraction
+      # end
+
+      def zeta(x, q)
+        RawOps.zeta(x: x, q: q)
+      end
+    end
+  end
+end

data/lib/tensorflow/ops.rb

@@ -0,0 +1,51 @@
+# keep in alphabetical order
+module TensorFlow
+  module Ops
+    def eye(num_rows,  num_columns: nil)
+      num_columns ||= num_rows
+      zeros = self.zeros([num_rows, num_columns])
+      ones = self.ones([num_rows])
+      RawOps.matrix_set_diag(input: zeros, diagonal: ones)
+    end
+
+    def fill(dims, value)
+      RawOps.fill(dims: dims, value: value)
+    end
+
+    def identity(input)
+      RawOps.identity(input: input)
+    end
+
+    def matmul(a, b)
+      RawOps.mat_mul(a: a, b: b)
+    end
+
+    def ones(dims)
+      fill(dims, 1)
+    end
+
+    def range(start, limit = nil, delta = 1)
+      unless limit
+        limit = start
+        start = 0
+      end
+      RawOps.range(start: start, limit: limit, delta: delta)
+    end
+
+    def timestamp
+      RawOps.timestamp
+    end
+
+    def transpose(x, perm: [1, 0])
+      RawOps.transpose(x: x, perm: perm)
+    end
+
+    def zeros(dims)
+      fill(dims, 0)
+    end
+
+    def zeros_like(x)
+      RawOps.zeros_like(x: x)
+    end
+  end
+end