tensor_stream 0.9.5 → 0.9.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51cb6686663dece94714073ff12b13ad7e57de1aadbee44506897c69a2d5fd67
-  data.tar.gz: 47152a908b2cc966cba6721da8f0c3170e3198a70f416fd224caee7d35a1fca2
+  metadata.gz: 4059c6bb82fc83c5aee32090e9c58231f9fd421afb3aa8bea1cbff4857edeb18
+  data.tar.gz: b7ceee8509455146402c3b3cdf9fa0a63eeec3dfee5512dd6e097221f1247481
 SHA512:
-  metadata.gz: 7fff67042fd35c651409e04e890feafab25e618d88d4c3f69c97b39e839a943c64a4e05be388a4464e32328a777f6ee56dc5ede0a6c69c977cc94bcb7cd38bad
-  data.tar.gz: a30230994e81062626eaae5ca7a13ece36d2a5ea6210cfe1e3e465b5e5e24adad525547223f27e15991f74728d53d8b02e7cac0710fe16bf3c602402f5b65b5c
+  metadata.gz: 329eb6875b1add417656537beac95d67c1c061fa3eba3b04031d3ac6f1a20f7e26bf12e66873b70ad575fe7d9f0482c02888f0b544405ba9d73d5b325070966f
+  data.tar.gz: 639a4d90dc1525e063bcdac3b30805a38697b009634d17cb745c99189b88b10b95ce49a9136d5c9c0617fbf3ca3ee1a74429a8579437b7896954ff6529952e79

data/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.9.5] - 2018-11-05
+- [NEW OP] assert_equal, relu6
+- [TRAINING] learning_rate_decay, dropout
+- [BUG FIX] argmin, argmax now works properly
+- [BUG FIX] shape inference fixes
+
 ## [0.9.2] - 2018-10-19
 - Add profiling support
 - Make sure sparse ruby arrays are caught

data/lib/tensor_stream/evaluator/ruby/images_ops.rb

@@ -7,11 +7,25 @@ module TensorStream
         register_op :decode_png do |_context, tensor, inputs|
           content = inputs[0]
           channels = tensor.options[:channels]
+          resample_new_shape = tensor.options[:new_shape]
+          resample_method = tensor.options[:resample_method] || :bilinear
           channels = 4 if channels.zero?
 
           image = ChunkyPNG::Image.from_blob(content)
 
           image.grayscale! if channels == 1
+
+          if resample_new_shape
+            case resample_method
+            when :bilinear
+              image.resample_bilinear!(resample_new_shape[1], resample_new_shape[0]) # width, # height
+            when :nearest_neighbor
+              image.resample_nearest_neighbor!(resample_new_shape[1], resample_new_shape[0])
+            else
+              raise TensorStream::ValueError, "invalid resample method provided #{resample_method}. Available (:bilinear, :nearest_neighbor)"
+            end
+          end
+
           image_data = image.pixels.collect do |pixel|
             color_values = if channels == 4
                              [ChunkyPNG::Color.r(pixel),
@@ -35,10 +49,13 @@ module TensorStream
           TensorShape.reshape(image_data, [image.height, image.width, channels])
         end
 
-        register_op :encode_png do |_context, _tensor, inputs|
+        register_op :encode_png do |_context, tensor, inputs|
           image_data = inputs[0]
           height, width, channels = shape_eval(image_data)
 
+          resample_new_shape = tensor.options[:new_shape]
+          resample_method = tensor.options[:resample_method] || :bilinear
+
           png = ChunkyPNG::Image.new(width, height)
           image_data.each_with_index do |rows, h_index|
             rows.each_with_index do |p_data, w_index|
@@ -51,6 +68,18 @@ module TensorStream
               end
             end
           end
+
+          if resample_new_shape
+            case resample_method
+            when :bilinear
+              png.resample_bilinear!(resample_new_shape[1], resample_new_shape[0]) # width, # height
+            when :nearest_neighbor
+              png.resample_nearest_neighbor!(resample_new_shape[1], resample_new_shape[0])
+            else
+              raise TensorStream::ValueError, "invalid resample method provided #{resample_method}. Available (:bilinear, :nearest_neighbor)"
+            end
+          end
+
           png.to_s
         end
       end

data/lib/tensor_stream/evaluator/ruby/nn_ops.rb

@@ -211,6 +211,114 @@ module TensorStream
         register_op :relu6 do |context, tensor, inputs|
           call_vector_op(tensor, :relu6, inputs[0], inputs[1], context, ->(t, u) { [[t, 0].max, 6].min })
         end
+
+        register_op :conv2d do |_context, tensor, inputs|
+          filter = inputs[1]
+          filter_shape = shape_eval(filter)
+          strides = tensor.options[:strides]
+          height_stride = strides[1]
+          width_stride = strides[2]
+
+          raise TensorStream::ValueError, " Current implementation does not yet support strides in the batch and depth dimensions." if strides[0] != 1 || strides[3] != 1
+
+          inputs[0].collect do |image|
+            height, width, _channels = shape_eval(image)
+            f_height, f_width, _input_channels, _output_channels = filter_shape
+
+            (0...height).step(height_stride).map do |y|
+              (0...width).step(width_stride).map do |x|
+                filter_result = (0...f_height).map do |f_y|
+                  (0...f_width).map do |f_x|
+                    f_element = filter[f_y][f_x]
+
+                    next if x + f_x >= width
+                    next if y + f_y >= height
+
+                    image[y + f_y][x + f_x].zip(f_element).map do |image_channel, filter_channels|
+                      filter_channels.map { |c| image_channel * c }
+                    end
+                  end.compact
+                end.flatten(2)
+
+                filter_result.transpose.map { |e| e.reduce(:+) }
+              end
+            end
+          end
+        end
+
+        register_op :conv2d_backprop_input do |_context, tensor, inputs|
+          image_shape, filter, grad = inputs
+
+          strides = tensor.options[:strides]
+
+          height_stride = strides[1]
+          width_stride = strides[2]
+
+          filter_shape = shape_eval(filter)
+
+          f_height, f_width, _input_channels, output_channels = filter_shape
+          batch, height, width, channels = image_shape
+
+          Array.new(batch) do |b|
+            image_gradient = TensorShape.reshape(Array.new(height * width * channels) { 0.0 }, [height, width, channels])
+
+            (0...height).step(height_stride).each do |y|
+              (0...width).step(width_stride).each do |x|
+                (0...f_height).each do |f_y|
+                  (0...f_width).each do |f_x|
+                    next if x + f_x >= width
+                    next if y + f_y >= height
+
+                    channels.times.each do |c|
+                      image_gradient[y + f_y][x + f_x][c] += Array.new(output_channels) do |o_c|
+                        filter[f_y][f_x][c][o_c] * grad[b][(y/height_stride) + f_y][(x/width_stride) + f_x][o_c]
+                      end.reduce(:+)
+                    end
+                  end
+                end
+              end
+            end
+
+            image_gradient
+          end
+        end
+
+        register_op :conv2d_backprop_filter do |_context, tensor, inputs|
+          images, filter_shape, grad = inputs
+
+          strides = tensor.options[:strides]
+          height_stride = strides[1]
+          width_stride = strides[2]
+
+          filter_gradient_sum = Array.new(filter_shape.reduce(:*)) { 0.0 }
+
+          images.each_with_index.map do |image, index|
+            height, width, _channels = shape_eval(image)
+            f_height, f_width, input_channels, output_channels = filter_shape
+
+            (0...height).step(height_stride).each do |y|
+              (0...width).step(width_stride).each do |x|
+                filter_result = (0...f_height).map do |f_y|
+                  (0...f_width).map do |f_x|
+
+                    next Array.new(input_channels * output_channels) { 0.0 } if x + f_x >= width
+                    next Array.new(input_channels * output_channels) { 0.0 } if y + f_y >= height
+
+                    image[y + f_y][x + f_x].each_with_index.map do |image_channel, c_channel|
+                      output_channels.times.map do |o_c|
+                        image_channel * grad[index][(y/height_stride) + f_y][(x/width_stride) + f_x][o_c]
+                      end
+                    end
+                  end
+                end.flatten
+
+                filter_gradient_sum = multi_array_op(->(a, b) { a + b }, filter_gradient_sum, filter_result)
+              end
+            end
+          end
+
+          TensorShape.reshape(filter_gradient_sum, filter_shape)
+        end
       end
     end
   end

data/lib/tensor_stream/evaluator/ruby_evaluator.rb

@@ -364,7 +364,7 @@ module TensorStream
 
       def get_op_with_axis(a, target_axis, current_axis, op)
         rank = get_rank(a)
-        return a.index(a.send(:"#{op}")) if rank == 1
+        return a.send(:"#{op}_index") if rank == 1
 
         if current_axis == target_axis
           compare_items = a.collect(&:flatten).transpose
@@ -372,7 +372,7 @@ module TensorStream
         elsif a[0].is_a?(Array)
           a.map { |item| get_op_with_axis(item, target_axis, current_axis + 1, op) }
         else
-          return a.index(a.send(:"#{op}"))
+          return a.send(:"#{op}_index")
         end
       end
 

data/lib/tensor_stream/helpers/infer_shape.rb

@@ -171,6 +171,13 @@ module TensorStream
         axis = rank + axis if axis < 0
         rotated_shape = Array.new(axis + 1) { new_shape.shift }
         rotated_shape.rotate!(-1) + new_shape
+      when :conv2d
+        return nil unless tensor.inputs[0].shape.known?
+        return nil unless tensor.inputs[1].shape.known?
+
+        new_shape = tensor.inputs[0].shape.shape.dup
+        new_shape[3] = tensor.inputs[1].shape.shape[3]
+        new_shape
       else
         return nil if tensor.inputs[0].nil?
         return tensor.inputs[0].shape.shape if tensor.inputs.size == 1

data/lib/tensor_stream/images.rb

@@ -3,14 +3,14 @@ module TensorStream
     extend OpHelper
     extend TensorStream::Utils
 
-    def self.decode_png(contents, channels: 0, dtype: :uint8, name: nil)
-      _op(:decode_png, contents, channels: channels, data_type: dtype, name: name)
+    def self.decode_png(contents, channels: 0, dtype: :uint8, name: nil, new_shape: nil)
+      _op(:decode_png, contents, channels: channels, data_type: dtype, name: name, new_shape: new_shape)
     end
 
-    def self.encode_png(contents, compression: -1, name: nil)
+    def self.encode_png(contents, compression: -1, name: nil, new_shape: nil, resample_method: nil)
       check_allowed_types(contents, %i[uint8 uint16])
       contents = convert_to_tensor(contents, dtype: :uint16)
-      _op(:encode_png, contents, compression: compression, name: name)
+      _op(:encode_png, contents, compression: compression, name: name, new_shape: new_shape, resample_method: resample_method)
     end
   end
 end

data/lib/tensor_stream/math_gradients.rb

@@ -305,6 +305,8 @@ module TensorStream
           Array.new(node.inputs.size) { |i| res[i] }
         when :unstack
           ts.stack(grad, axis: node.options[:axis])
+        when :conv2d
+          _Conv2DGrad(node, grad)
         when :cast
           t = %i[float16 float32 float64]
           src_type = node.inputs[0].data_type
@@ -416,5 +418,33 @@ module TensorStream
       out_grads = ts.split(grad, sizes, axis: non_neg_concat_dim, num: op.inputs.size - 1)
       end_value_index <= dim_index ? out_grads + [nil] : [nil] + out_grads
     end
+
+    def self._Conv2DGrad(op, grad)
+      # dilations = op.get_attr("dilations")
+      strides = op.options[:strides]
+      padding = op.options[:padding]
+      use_cudnn_on_gpu = op.options[:use_cudnn_on_gpu]
+      data_format = op.options[:data_format]
+
+      shape_0, shape_1 = ts.shape_n([op.inputs[0], op.inputs[1]])
+      [
+          _op(:conv2d_backprop_input,
+              shape_0,
+              op.inputs[1],
+              grad,
+              strides: strides,
+              padding: padding,
+              use_cudnn_on_gpu: use_cudnn_on_gpu,
+              data_format: data_format),
+          _op(:conv2d_backprop_filter,
+              op.inputs[0],
+              shape_1,
+              grad,
+              strides: strides,
+              padding: padding,
+              use_cudnn_on_gpu: use_cudnn_on_gpu,
+              data_format: data_format)
+      ]
+    end
   end
 end

data/lib/tensor_stream/monkey_patches/array.rb

@@ -12,4 +12,40 @@ class Array
   def **(other)
     TensorStream.convert_to_tensor(self)**other
   end
+
+  def max_index
+    if first.is_a?(Float)
+      highest = first
+      highest_index = 0
+      each_with_index do |item, index|
+        next if item.nan?
+
+        if item > highest
+          highest = item
+          highest_index = index
+        end
+      end
+      highest_index
+    else
+      index(max)
+    end
+  end
+
+  def min_index
+    if first.is_a?(Float)
+      highest = first
+      highest_index = 0
+      each_with_index do |item, index|
+        next if item.nan?
+
+        if item < highest
+          highest = item
+          highest_index = index
+        end
+      end
+      highest_index
+    else
+      index(min)
+    end
+  end
 end

data/lib/tensor_stream/monkey_patches/patch.rb

@@ -15,6 +15,10 @@ module TensorStream
       end
     end
 
+    def shape
+      TensorStream.shape_eval(self)
+    end
+
     def t(name = nil)
       TensorStream.convert_to_tensor(self, name: name)
     end

data/lib/tensor_stream/nn/nn_ops.rb

@@ -3,131 +3,137 @@ module TensorStream
   class NN
     extend TensorStream::OpHelper
 
-    def self.softmax(logits, axis: nil, name: nil)
-      _op(:softmax, logits, nil, axis: axis, name: name)
-    end
+    class << self
+      def softmax(logits, axis: nil, name: nil)
+        _op(:softmax, logits, nil, axis: axis, name: name)
+      end
 
-    def self.relu(features, name: nil)
-      TensorStream.max(features, 0, name: "relu_#{name}")
-    end
+      def relu(features, name: nil)
+        TensorStream.max(features, 0, name: "relu_#{name}")
+      end
 
-    def self.relu6(features, name: nil)
-      TensorStream.name_scope(name, "Relu6", values: [features]) do
-        features = TensorStream.convert_to_tensor(features, name: "features")
-        _op(:relu6, features, name: name)
+      def relu6(features, name: nil)
+        TensorStream.name_scope(name, "Relu6", values: [features]) do
+          features = TensorStream.convert_to_tensor(features, name: "features")
+          _op(:relu6, features, name: name)
+        end
       end
-    end
 
-    ##
-    # Computes dropout.
-    #
-    # With probability keep_prob, outputs the input element scaled up by 1 / keep_prob, otherwise outputs 0. The scaling is so that the expected sum is unchanged.
-    def self.dropout(x, keep_prob, noise_shape: nil, seed: nil, name: nil)
-      TensorStream.name_scope(name, "dropout", values: [x]) do
-        x = TensorStream.convert_to_tensor(x, name: "x")
-        raise TensorStream::ValueError, "x has to be a floating point tensor since it's going to be scaled. Got a #{x.data_type} tensor instead." unless fp_type?(x.data_type)
-        raise TensorStream::ValueError, "keep_prob must be a scalar tensor or a float in the range (0, 1], got #{keep_prob}" unless (0 < keep_prob && keep_prob <= 1)
+      ##
+      # Computes dropout.
+      #
+      # With probability keep_prob, outputs the input element scaled up by 1 / keep_prob, otherwise outputs 0. The scaling is so that the expected sum is unchanged.
+      def dropout(x, keep_prob, noise_shape: nil, seed: nil, name: nil)
+        TensorStream.name_scope(name, "dropout", values: [x]) do
+          x = TensorStream.convert_to_tensor(x, name: "x")
+          raise TensorStream::ValueError, "x has to be a floating point tensor since it's going to be scaled. Got a #{x.data_type} tensor instead." unless fp_type?(x.data_type)
+          raise TensorStream::ValueError, "keep_prob must be a scalar tensor or a float in the range (0, 1], got #{keep_prob}" if keep_prob.is_a?(Float) && !(0 < keep_prob && keep_prob <= 1)
 
-        return x if keep_prob.is_a?(Float) && keep_prob.to_f == 1.0
+          return x if keep_prob.is_a?(Float) && keep_prob.to_f == 1.0
 
-        keep_prob = TensorStream.convert_to_tensor(keep_prob, dtype: x.dtype, name: "keep_prob")
-        return x if keep_prob.value == 1.0
+          keep_prob = TensorStream.convert_to_tensor(keep_prob, dtype: x.dtype, name: "keep_prob")
+          return x if keep_prob.value == 1.0
 
-        noise_shape = if noise_shape.nil?
-                        TensorStream.shape(x)
-                      else
-                        noise_shape
-                      end
+          noise_shape = if noise_shape.nil?
+                          TensorStream.shape(x)
+                        else
+                          noise_shape
+                        end
 
-        random_tensor = keep_prob
-        random_tensor += TensorStream.random_uniform(noise_shape, seed: seed, dtype: x.dtype)
+          random_tensor = keep_prob
+          random_tensor += TensorStream.random_uniform(noise_shape, seed: seed, dtype: x.dtype)
 
-        binary_tensor = TensorStream.floor(random_tensor)
-        TensorStream.div(x, keep_prob) * binary_tensor
+          binary_tensor = TensorStream.floor(random_tensor)
+          TensorStream.div(x, keep_prob) * binary_tensor
+        end
       end
-    end
 
-    def self.sigmoid(input, name: nil)
-      TensorStream.sigmoid(input, name: name)
-    end
+      def sigmoid(input, name: nil)
+        TensorStream.sigmoid(input, name: name)
+      end
 
-    def self.softmax_cross_entropy_with_logits(labels: nil, logits: nil, name: nil)
-      softmax_cross_entropy_with_logits_v2(labels: labels, logits: logits, name: name)
-    end
+      def softmax_cross_entropy_with_logits(labels: nil, logits: nil, name: nil)
+        softmax_cross_entropy_with_logits_v2(labels: labels, logits: logits, name: name)
+      end
 
-    def self.softmax_cross_entropy_with_logits_v2(labels: nil, logits: nil, name: nil)
-      TensorStream.name_scope(name, default: 'softmax_cross_entropy_with_logits', values: [logits, labels]) do
-        ts = TensorStream
-        logits = ts.convert_to_tensor(logits, name: 'logits')
-        labels = ts.convert_to_tensor(labels, name: 'labels')
-        labels = ts.cast(labels, logits.dtype)
+      def softmax_cross_entropy_with_logits_v2(labels: nil, logits: nil, name: nil)
+        TensorStream.name_scope(name, default: 'softmax_cross_entropy_with_logits', values: [logits, labels]) do
+          ts = TensorStream
+          logits = ts.convert_to_tensor(logits, name: 'logits')
+          labels = ts.convert_to_tensor(labels, name: 'labels')
+          labels = ts.cast(labels, logits.dtype)
 
-        output = _op(:softmax_cross_entropy_with_logits_v2, logits, labels)
-        output[0]
+          output = _op(:softmax_cross_entropy_with_logits_v2, logits, labels)
+          output[0]
+        end
       end
-    end
 
-    def self.sparse_softmax_cross_entropy_with_logits(labels: nil, logits: nil, name: nil)
-      TensorStream.name_scope(name, default: "SparseSoftmaxCrossEntropyWithLogits", values: [logits, labels]) do
-        tf = TensorStream
-        labels = tf.convert_to_tensor(labels)
-        logits = tf.convert_to_tensor(logits)
-        precise_logits = logits.data_type == :float16 ? tf.cast(logits, :float32) : logits
-
-        labels_static_shape = labels.shape
-        labels_shape = tf.shape(labels)
-        static_shapes_fully_defined = labels_static_shape.known? && logits.shape.known?
-
-        raise TensorStream::ValueError, "Logits cannot be scalars - received shape #{logits.shape.shape}." if logits.shape.known? && logits.shape.scalar?
-        raise TensorStream::ValueError, "Rank mismatch: Rank of labels (received #{labels_static_shape.ndims}) " +
-          "should equal rank of logits minus 1 (received #{logits.shape.ndims})." if logits.shape.known? && (labels_static_shape.known? && labels_static_shape.ndims != logits.shape.ndims - 1)
-        if logits.shape.ndims == 2
-          cost = _op(:sparse_softmax_cross_entropy_with_logits,
-              precise_logits, labels, name: name)
-          if logits.data_type == :float16
-            return tf.cast(cost[0], :float16)
-          else
-            return cost[0]
+      def sparse_softmax_cross_entropy_with_logits(labels: nil, logits: nil, name: nil)
+        TensorStream.name_scope(name, default: "SparseSoftmaxCrossEntropyWithLogits", values: [logits, labels]) do
+          tf = TensorStream
+          labels = tf.convert_to_tensor(labels)
+          logits = tf.convert_to_tensor(logits)
+          precise_logits = logits.data_type == :float16 ? tf.cast(logits, :float32) : logits
+
+          labels_static_shape = labels.shape
+          labels_shape = tf.shape(labels)
+          static_shapes_fully_defined = labels_static_shape.known? && logits.shape.known?
+
+          raise TensorStream::ValueError, "Logits cannot be scalars - received shape #{logits.shape.shape}." if logits.shape.known? && logits.shape.scalar?
+          raise TensorStream::ValueError, "Rank mismatch: Rank of labels (received #{labels_static_shape.ndims}) " +
+            "should equal rank of logits minus 1 (received #{logits.shape.ndims})." if logits.shape.known? && (labels_static_shape.known? && labels_static_shape.ndims != logits.shape.ndims - 1)
+          if logits.shape.ndims == 2
+            cost = _op(:sparse_softmax_cross_entropy_with_logits,
+                precise_logits, labels, name: name)
+            if logits.data_type == :float16
+              return tf.cast(cost[0], :float16)
+            else
+              return cost[0]
+            end
           end
-        end
 
-        shape_checks = []
+          shape_checks = []
 
-        shape_checks << tf.assert_equal(tf.rank(labels), tf.rank(logits) - 1) unless static_shapes_fully_defined
+          shape_checks << tf.assert_equal(tf.rank(labels), tf.rank(logits) - 1) unless static_shapes_fully_defined
 
-        tf.control_dependencies(shape_checks) do
-          num_classes = tf.shape(logits)[tf.rank(logits) - 1]
-          precise_logits = tf.reshape(precise_logits, [-1, num_classes])
-          labels = tf.reshape(labels, [-1])
-          cost = _op(:sparse_softmax_cross_entropy_with_logits, precise_logits, labels, name: name)
-          cost = tf.reshape(cost[0], labels_shape)
+          tf.control_dependencies(shape_checks) do
+            num_classes = tf.shape(logits)[tf.rank(logits) - 1]
+            precise_logits = tf.reshape(precise_logits, [-1, num_classes])
+            labels = tf.reshape(labels, [-1])
+            cost = _op(:sparse_softmax_cross_entropy_with_logits, precise_logits, labels, name: name)
+            cost = tf.reshape(cost[0], labels_shape)
 
-          if logits.data_type == :float16
-            tf.cast(cost, :float16)
-          else
-            cost
+            if logits.data_type == :float16
+              tf.cast(cost, :float16)
+            else
+              cost
+            end
           end
         end
       end
-    end
 
-    # Computes log softmax activations.
-    def self.log_softmax(logits, axis: -1, name: nil)
-      _op(:log_softmax, logits, axis: axis, name: name)
-    end
+      # Computes log softmax activations.
+      def log_softmax(logits, axis: -1, name: nil)
+        _op(:log_softmax, logits, axis: axis, name: name)
+      end
+
+      def sigmoid_cross_entropy_with_logits(labels: nil, logits: nil, name: nil)
+        TensorStream.name_scope(name, default: 'logistic_loss', values: [logits, labels]) do |_name|
+          tf = TensorStream
+          logits = tf.convert_to_tensor(logits, name: 'logits')
+          labels = tf.convert_to_tensor(labels, name: 'labels')
+          zeros = tf.zeros_like(logits, dtype: logits.dtype)
+          cond = (logits >= zeros)
+          relu_logits = tf.where(cond, logits, zeros)
+          neg_abs_logits = tf.where(cond, -logits, logits)
+
+          tf.add(relu_logits - logits * labels,
+                 tf.log1p(tf.exp(neg_abs_logits)), name: name)
+        end
+      end
 
-    def self.sigmoid_cross_entropy_with_logits(labels: nil, logits: nil, name: nil)
-      TensorStream.name_scope(name, default: 'logistic_loss', values: [logits, labels]) do |_name|
-        tf = TensorStream
-        logits = tf.convert_to_tensor(logits, name: 'logits')
-        labels = tf.convert_to_tensor(labels, name: 'labels')
-        zeros = tf.zeros_like(logits, dtype: logits.dtype)
-        cond = (logits >= zeros)
-        relu_logits = tf.where(cond, logits, zeros)
-        neg_abs_logits = tf.where(cond, -logits, logits)
-
-        tf.add(relu_logits - logits * labels,
-               tf.log1p(tf.exp(neg_abs_logits)), name: name)
+      def conv2d(input, filter, strides, padding, name: nil)
+        _op(:conv2d, input, filter, strides: strides, padding: padding, name: name)
       end
     end
   end

data/lib/tensor_stream/train/saver.rb

@@ -1,4 +1,5 @@
 require 'json'
+require "zlib"
 
 module TensorStream
   module Train
@@ -12,11 +13,12 @@ module TensorStream
                write_meta_graph: true,
                write_state: true,
                strip_default_attrs: false)
-        vars = TensorStream::Graph.get_default_graph.get_collection(GraphKeys::GLOBAL_VARIABLES)
+        graph = TensorStream::Graph.get_default_graph
+        vars = graph.get_collection(GraphKeys::GLOBAL_VARIABLES)
 
         variables = {}
-        graph = {}
-        gs =  eval_global_step(session, global_step)
+
+        gs = eval_global_step(session, global_step)
         output_dump = {
           'variables' => variables,
           'global_step' => gs
@@ -24,7 +26,7 @@ module TensorStream
 
         vars.each do |variable|
           val = variable.read_value
-          packed_data = TensorStream::Packer.pack(val, variable.data_type)
+          packed_data = Zlib::Deflate.deflate(TensorStream::Packer.pack(val, variable.data_type))
           variables[variable.name] = {
             'shape' => shape_eval(val),
             'data' => Base64.strict_encode64(packed_data)
@@ -36,18 +38,21 @@ module TensorStream
 
         new_filename = File.join(path, [basename, gs].compact.join('-'))
         File.write(new_filename, output_dump.to_yaml)
-
+        if write_meta_graph
+          graph_filename = "#{basename}.pbtext"
+          TensorStream.train.write_graph(graph, path, graph_filename)
+        end
         path
       end
 
       def restore(_session, inputfile)
-        input_dump = YAML.load(File.read(inputfile))
+        input_dump = YAML.safe_load(File.read(inputfile))
 
         vars = TensorStream::Graph.get_default_graph.get_collection(GraphKeys::GLOBAL_VARIABLES)
         vars.each do |variable|
           next unless input_dump['variables'].key?(variable.name)
 
-          data = TensorStream::Packer.unpack(Base64.decode64(input_dump['variables'][variable.name]['data']), variable.data_type)
+          data = TensorStream::Packer.unpack(Zlib::Inflate.inflate(Base64.decode64(input_dump['variables'][variable.name]['data'])), variable.data_type)
           shape = input_dump['variables'][variable.name]['shape']
           variable.buffer = nil
           variable.value = TensorShape.reshape(data, shape)

data/lib/tensor_stream/version.rb

@@ -1,5 +1,5 @@
 module TensorStream
-  VERSION = '0.9.5'.freeze
+  VERSION = '0.9.6'.freeze
 
   def self.version
     VERSION

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tensor_stream
 version: !ruby/object:Gem::Version
-  version: 0.9.5
+  version: 0.9.6
 platform: ruby
 authors:
 - Joseph Emmanuel Dayo
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-04 00:00:00.000000000 Z
+date: 2018-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler