tensor_stream 0.9.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: d5c4d8c8c2e586ef8c9cce0b57d31b68d9b30ddba682c79e0de5e0c905c76a22
-  data.tar.gz: c503cbef1dd51f563479a248b209f62b035fc076a531269b1d26656521a928a0
+SHA1:
+  metadata.gz: 9c6649e7cb423246d4886776bf93a8422e3be936
+  data.tar.gz: c62ffe26455cff685925a5a9a27c49babae6d17e
 SHA512:
-  metadata.gz: 8a9fb88f5ac1c4f8ec47809405370f28009630155b56e6f1f9e0b1cf0d975188bcfe522216226d425c135a43551e08ddc9603c6ccf2c37e6d78ea3321c52ff5d
-  data.tar.gz: '080d79da1a32290f9ee5b411270835a80f9dd9d1b9d1d10ee28d67ad82c856f2bb3b31bfd122812ba6ff3206b3ff25ccf5294a5a2837d22cd038940229161ce4'
+  metadata.gz: 9dd8519a7c4c34fc0d0c8f4900aa2bec73e6a0dfefe15db4f4c6703188e55080cd2dcce4c8df02993beaa1d6f753b2309fabda623f5ab6a0218c3bd4ce382c0c
+  data.tar.gz: 2e2f051ada324f4f220db702762a179f1ee20985ecbde51d5c8fc976ad50ff32a315459b97a2366c7cf9a718672b42910466b8e1e81ea388a878035807bae1e0

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.1] - 2018-10-19
+- Bug fix release
+  
+## [0.9.0] - 2018-10-05
+- Bug fix release for OpenCL gem
+
 ## [0.8.6] - 2018-09-11
 
 ### Added

data/lib/tensor_stream/dynamic_stitch.rb

@@ -12,7 +12,7 @@ module TensorStream
       @data_type = Tensor.detect_type(inputs[1])
       @name = [@graph.get_name_scope, options[:name] || set_name].compact.join('/')
       @ops = ops
-      @shape = TensorShape.new([inputs.size])
+      @shape = TensorShape.new(nil)
       @graph.add_node(self)
     end
 

data/lib/tensor_stream/evaluator/base_evaluator.rb

@@ -126,18 +126,24 @@ module TensorStream
 
       protected
 
+      ##
+      # called when passing control to another evaluator
+      def perform_transition(tensor, input, _next_evaluator)
+        cache_key = "#{tensor.graph.object_id}_#{input.name}:#{object_id}"
+        return @context[:_cache][cache_key] if @context[:_cache].key?(cache_key)
+
+        result = @session.delegate_to_evaluator(input, @context, execution_context)
+        convert_from_buffer(input, result).tap do |buffer|
+          @context[:_cache][cache_key] = buffer if input.is_const
+        end
+      end
+
       def global_eval(tensor, input, execution_context, op_options = {})
         return nil unless input
         return input unless input.is_a?(Tensor)
         @context[:_cache][:placement][input.name] = @session.assign_evaluator(input) if @context[:_cache][:placement][input.name].nil?
         if object_id != @context[:_cache][:placement][input.name][1].object_id # tensor is on another device or evaluator
-          cache_key = "#{tensor.graph.object_id}_#{input.name}:#{object_id}"
-          return @context[:_cache][cache_key] if @context[:_cache].key?(cache_key)
-
-          result = @session.delegate_to_evaluator(input, @context, execution_context)
-          convert_from_buffer(input, result).tap do |buffer|
-            @context[:_cache][cache_key] = buffer if input.is_const
-          end
+          perform_transition(tensor, input, @context[:_cache][:placement][input.name][1])
         else
           prepare_input(input, execution_context, op_options)
         end

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

@@ -158,8 +158,8 @@ module TensorStream
           TensorShape.reshape([val], new_shape)
         end
 
-        register_op :fill do |_context, _tensor, inputs|
-          shape = inputs[0]
+        register_op :fill do |_context, tensor, inputs|
+          shape = inputs[0] || tensor.shape.shape
           value = inputs[1]
 
           func = -> { value }

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

@@ -237,7 +237,7 @@ module TensorStream
           matrix_b = matrix_b.transpose if tensor.options[:transpose_b]
 
           # check matrix dimensions
-          raise "incompatible shape sizes for matrix multiplication (#{matrix_a[0].size} != #{matrix_b.size}) #{shape_eval(matrix_a)} vs #{shape_eval(matrix_b)}" if matrix_a[0].size != matrix_b.size
+          raise TensorStream::ValueError, "incompatible shape sizes for matrix multiplication (#{matrix_a[0].size} != #{matrix_b.size}) #{shape_eval(matrix_a)} vs #{shape_eval(matrix_b)}" if matrix_a[0].size != matrix_b.size
 
           (Matrix[*matrix_a] * Matrix[*matrix_b]).to_a
         end

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

@@ -40,7 +40,6 @@ module TensorStream
         register_op :apply_adagrad do |_context, tensor, inputs|
           target_var, accum, lr, grad = inputs
           assign = tensor.inputs[0] || tensor
-
           assign.value = multi_array_op(->(v, a, g) { v - (g * lr * (1.0 / Math.sqrt(a))) }, target_var, accum, grad)
           assign.value
         end

data/lib/tensor_stream/evaluator/ruby_evaluator.rb

@@ -250,8 +250,21 @@ module TensorStream
         softmax(inputs[0])
       end
 
-      register_op :save_v2 do |context, tensor, inputs|
-        # prefix, tensor_names, shape_and_slices = inputs[0..3]
+      register_op :save_ts do |_context, tensor, inputs|
+        outputfile = inputs[0]
+        inputs = tensor.inputs.dup
+
+        basename = File.basename(outputfile)
+        path = File.dirname(outputfile)
+
+        new_filename = File.join(path, [basename, gs].compact.join('-'))
+
+        inputs.shift
+        variables = {}
+        inputs.each do |savable|
+          variables[savable.name] = TensorStream::Packer.pack(savable.read_value, savable.data_type)
+        end
+        File.write(new_filename, variables.to_yaml)
       end
 
       register_op :restore_v2 do |context, tensor, inputs|
@@ -270,7 +283,14 @@ module TensorStream
       def eval_operation(tensor, child_context)
         return @context[tensor.name] if @context.key?(tensor.name)
         invoke(tensor, child_context).tap do |result|
-          # puts "ruby: #{tensor.name}"
+
+          # assertions to make sure inferred shapes == actual evaluated shapes
+          if tensor.shape.known? && (result.is_a?(Array) || result.is_a?(Float) || result.is_a?(Integer))
+            if shape_eval(result) != tensor.shape.shape
+              raise "assert error #{tensor.name} #{shape_eval(result)} != #{tensor.shape.shape}"
+            end
+          end
+  
           if tensor.breakpoint
             a = resolve_placeholder(tensor.inputs[0], child_context) if tensor.inputs && tensor.inputs[0]
             b = resolve_placeholder(tensor.inputs[1], child_context) if tensor.inputs && tensor.inputs[1]

data/lib/tensor_stream/graph_serializers/packer.rb

@@ -0,0 +1,60 @@
+require 'base64'
+
+module TensorStream
+  # Utility class to handle data type serialization
+  class Packer
+    def self.pack(value, data_type)
+      value = value.is_a?(Array) ? value.flatten : [value]
+      byte_value = case data_type
+                   when :float64
+                     value.pack('d*')
+                   when :float32, :float16, :float
+                     value.pack('f*')
+                   when :uint32
+                     value.pack('L*')
+                   when :int32, :int
+                     value.pack('l*')
+                   when :int64
+                     value.pack('q*')
+                   when :uint64
+                     value.pack('Q*')
+                   when :uint8
+                     value.pack('C*')
+                   when :boolean
+                     value.map { |v| v ? 1 : 0 }.pack('C*')
+                   end
+
+      byte_value
+    end
+
+    def self.pack_to_str(value, data_type)
+      pack(value, data_type).bytes.map { |b| b.chr =~ /[^[:print:]]/ ? "\\#{sprintf("%o", b).rjust(3, '0')}" : b.chr }.join
+    end
+
+    def self.unpack_from_str(content, data_type)
+      unpacked = eval(%("#{content}"), __FILE__)
+      unpack(unpacked, data_type)
+    end
+
+    def self.unpack(unpacked, data_type)
+      case data_type
+      when :float32, :float, :float16
+        unpacked.unpack('f*')
+      when :float64
+        unpacked.unpack('d*')
+      when :int32, :int
+        unpacked.unpack('L*')
+      when :uint32
+        unpacked.unpack('l*')
+      when :int64
+        unpacked.unpack('q*')
+      when :uint64
+        unpacked.unpack('Q*')
+      when :uint8
+        unpacked.unpack('C*')
+      when :boolean
+        unpacked.unpack('C*').map { |v| v == 1 }
+      end
+    end
+  end
+end

data/lib/tensor_stream/graph_serializers/serializer.rb

@@ -1,13 +1,9 @@
 module TensorStream
   class Serializer
-    def initialize
-    end
-
     def serialize(filename, tensor, session = nil)
       File.write(filename, get_string(tensor, session))
     end
 
-    def get_string(tensor, session = nil)
-    end
+    def get_string(tensor, session = nil); end
   end
 end

data/lib/tensor_stream/math_gradients.rb

@@ -267,7 +267,7 @@ module TensorStream
           [_broadcast_mul(grad, output[1]), -ts.nn.log_softmax(logits)]
         when :sparse_softmax_cross_entropy_with_logits
           output = node
-           [_broadcast_mul(grad, output[1]), nil]
+          [_broadcast_mul(grad, output[1]), nil]
         when :floor, :ceil
           # non differentiable
           nil
@@ -280,16 +280,16 @@ module TensorStream
         when :transpose
           return [ts.transpose(grad, ts.invert_permutation(y)), nil]
         when :index
-          #hack!! not sure how to fix this yet
+          # hack!! not sure how to fix this yet
           return grad if %i[softmax_cross_entropy_with_logits_v2 sparse_softmax_cross_entropy_with_logits].include?(node.inputs[0].operation)
 
           if node.inputs[0].shape.known? && node.inputs[1].value
             multiplier = node.inputs[0].shape.shape[0]
             filler = ts.zeros_like(grad)
 
-            res = Array.new(multiplier) { |index|
+            res = Array.new(multiplier) do |index|
               index == node.inputs[1].value ? grad : filler
-            }
+            end
             [res]
           end
         when :squeeze
@@ -312,9 +312,9 @@ module TensorStream
 
           if t.key?(src_type) && t.key?(dst_type)
             ts.cast(grad, src_type)
-          else
-            nil
           end
+
+          nil
         else
           raise "no derivative op for #{node.operation}"
         end

data/lib/tensor_stream/operation.rb

@@ -221,23 +221,44 @@ module TensorStream
 
     def infer_shape
       case operation
+      when :assign
+        possible_shape = if inputs[0] && inputs[0].shape.shape
+                           inputs[0].shape.shape
+                         else
+                           inputs[1].shape.shape
+                         end
+
+        possible_shape
       when :index
-        input_shape = inputs[0].shape.shape
-        return nil if input_shape.nil?
-        input_shape[1, input_shape.size]
+        return nil unless inputs[0].is_a?(Tensor)
+        return nil unless inputs[0].const_value
+
+        input_shape = inputs[0].shape
+        return nil unless input_shape.known?
+
+        s = input_shape.shape.dup
+        s.shift
+        s
       when :mean, :prod, :sum
         return [] if inputs[1].nil?
         return nil if inputs[0].nil?
-        input_shape = inputs[0].shape.shape
-        return nil if input_shape.nil?
-        return nil if inputs[1].is_a?(Tensor) && inputs[1].value.nil?
+        return nil unless inputs[0].shape.known?
 
-        axis = inputs[1].is_a?(Tensor) ? inputs[1].value : inputs[1]
+        input_shape = inputs[0].shape.shape
+        rank = input_shape.size
+        
+        axis = inputs[1].const_value
+        return nil if axis.nil?
 
         axis = [axis] unless axis.is_a?(Array)
-        input_shape.each_with_index.map do |s, index|
-          next nil if axis.include?(index)
-          s
+        axis = axis.map { |a| a < 0 ? rank - a.abs : a }
+
+        input_shape.each_with_index.map do |item, index|
+          if axis.include?(index)
+            next 1 if options[:keepdims]
+            next nil
+          end
+          item
         end.compact
       when :reshape
         new_shape = inputs[1] && inputs[1].value ? inputs[1].value : nil
@@ -250,16 +271,36 @@ module TensorStream
         TensorShape.fix_inferred_elements(new_shape, input_shape.reduce(:*))
       when :flow_group
         []
-      when :zeros, :ones, :fill
-        inputs[0] ? inputs[0].value : options[:shape]
+      when :zeros, :ones, :fill, :random_standard_normal, :random_uniform
+        a_shape = inputs[0] ? inputs[0].const_value : options[:shape]
+        return nil if a_shape.nil?
+        a_shape.is_a?(Array) ? a_shape : [a_shape]
       when :zeros_like, :ones_like
         inputs[0].shape.shape
       when :shape
         inputs[0].shape.shape ? [inputs[0].shape.shape.size] : nil
       when :mat_mul
-        shape1 = inputs[0].shape.shape.nil? ? nil : inputs[0].shape.shape[0]
-        shape2 = inputs[1].shape.shape.nil? ? nil : inputs[1].shape.shape[1]
-        [shape1, shape2]
+        return nil if inputs[0].shape.shape.nil? || inputs[1].shape.shape.nil?
+        return [] if inputs[0].shape.shape.empty? || inputs[1].shape.shape.empty?
+        return nil if inputs[0].shape.shape.size != 2 || inputs[1].shape.shape.size != 2
+
+        shape1, m = if options[:transpose_a]
+                   [inputs[0].shape.shape[0], inputs[0].shape.shape[1]]
+                 else
+                   [inputs[0].shape.shape[1], inputs[0].shape.shape[0]]
+                 end
+
+        shape2, n = if options[:transpose_b]
+                   [inputs[1].shape.shape[1], inputs[1].shape.shape[0]]
+                 else
+                   [inputs[1].shape.shape[0], inputs[1].shape.shape[1]]
+                 end
+
+        return nil if shape1.nil? || shape2.nil? || shape1 < 0 || shape2 < 0
+
+        raise TensorStream::ValueError, "incompatible shape sizes for matrix multiplication (#{shape1} != #{shape2}) #{inputs[0].shape.shape} vs #{inputs[1].shape.shape}" if shape1 != shape2
+
+        [m, n]
       when :transpose
         return nil unless shape_full_specified(inputs[0])
         return nil if inputs[1].is_a?(Tensor)
@@ -298,10 +339,35 @@ module TensorStream
         nil
       when :tile
         nil
+      when :expand_dims
+        nil
+      when :broadcast_gradient_args
+        nil
+      when :no_op
+        nil
+      when :softmax_cross_entropy_with_logits_v2, :sparse_softmax_cross_entropy_with_logits
+        nil
+      when :decode_png, :flow_dynamic_stitch, :dynamic_stitch, :gather
+        nil
+      when :eye
+        return [inputs[0].const_value, inputs[1].const_value] if inputs[0].const_value && inputs[1].const_value
+
+        nil
+      when :size
+        []
+      when :unstack
+        return nil unless inputs[0].shape.known?
+
+        new_shape = inputs[0].shape.shape.dup
+        rank = new_shape.size - 1
+        axis = options[:axis] || 0
+        axis = rank + axis if axis < 0
+        rotated_shape = Array.new(axis + 1) { new_shape.shift }
+        rotated_shape.rotate!(-1) + new_shape
       else
         return nil if inputs[0].nil?
         return inputs[0].shape.shape if inputs.size == 1
-        TensorShape.infer_shape(inputs[0].shape.shape, inputs[1].shape.shape) if inputs.size == 2 && inputs[0] && inputs[1]
+        TensorShape.infer_shape(inputs[0].shape.shape, inputs[1].shape.shape) if inputs.size == 2 && inputs[0] && inputs[1] && inputs[0].shape.known? && inputs[1].shape.known?
       end
     end
 

data/lib/tensor_stream/ops.rb

@@ -6,8 +6,8 @@ module TensorStream
         @op = op
       end
     end
-    FLOATING_POINT_TYPES = %i[float32 float64 float].freeze
-    INTEGER_TYPES = %i[uint8 int32 int int64].freeze
+    FLOATING_POINT_TYPES = %i[float32 float64 float float16].freeze
+    INTEGER_TYPES = %i[uint8 int32 int int16 uint16 int64 uint32 uint64].freeze
     NUMERIC_TYPES = FLOATING_POINT_TYPES + INTEGER_TYPES
 
     ##
@@ -99,7 +99,7 @@ module TensorStream
     ##
     # This operation returns a 1-D integer tensor representing the shape of input
     def shape(input, name: nil, out_type: :int32)
-      return constant(shape_eval(input, out_type), dtype: out_type, name: name) if input.is_a?(Array) && !input[0].is_a?(Tensor)
+      return constant(shape_eval(input, out_type), dtype: out_type, name: "Shape/#{name}") if input.is_a?(Array) && !input[0].is_a?(Tensor)
       return constant(input.shape.shape, dtype: out_type, name: "Shape/#{input.name}") if shape_full_specified(input)
 
       _op(:shape, input, name: name, out_type: out_type)
@@ -144,7 +144,7 @@ module TensorStream
     end
 
     def constant_initializer(value, dtype: nil, verify_shape: false)
-      TensorStream::Initializer.new(-> { convert_to_tensor(value, dtype: dtype) })
+      TensorStream::Initializer.new(-> { _op(:fill, nil, convert_to_tensor(value, dtype: dtype)) })
     end
 
     ##
@@ -303,17 +303,17 @@ module TensorStream
 
       pieces = if value.shape.known? && num_or_size_splits.is_const && num_or_size_splits.value && axis.is_const
                   if num_or_size_splits.shape.scalar?
-                    raise TensorStream::ValueError, "num_or_size_splits must divide dimension #{value.shape.shape[axis.value]} evenly" unless value.shape.shape[axis.value] % num_or_size_splits.value == 0
+                    raise TensorStream::ValueError, "num_or_size_splits must divide dimension #{value.shape.shape[axis.value]} evenly" unless (value.shape.shape[axis.value] % num_or_size_splits.value).zero?
                     div = num_or_size_splits.value
                     n = value.shape.shape[axis.value] / div
 
-                    Array.new(div) { |i|
+                    Array.new(div) do |i|
                       new_shape = value.shape.shape.dup
                       new_shape[axis.value] = n
                       new_shape
-                    }
+                    end
                   elsif num_or_size_splits.shape.ndims == 1
-                    raise TensorStream::ValueError, "Sum of splits do not match total dimen in axis #{value.shape.shape[axis.value]} != #{ num_or_size_splits.value.reduce(:+)}" if value.shape.shape[axis.value] != num_or_size_splits.value.reduce(:+)
+                    raise TensorStream::ValueError, "Sum of splits do not match total dimen in axis #{value.shape.shape[axis.value]} != #{num_or_size_splits.value.reduce(:+)}" if value.shape.shape[axis.value] != num_or_size_splits.value.reduce(:+)
                     num_or_size_splits.value.collect do |v|
                       new_shape = value.shape.shape.dup
                       new_shape[axis.value] = v

data/lib/tensor_stream/tensor.rb

@@ -33,6 +33,7 @@ module TensorStream
         else
           @value = Tensor.cast_dtype(options[:value], @data_type)
         end
+        @shape = TensorShape.new(shape_eval(@value))
       end
 
       @graph.add_node(self)
@@ -170,6 +171,12 @@ module TensorStream
       @name
     end
 
+    def const_value
+      return nil unless is_const
+
+      @value
+    end
+
     def op
       @op ||= is_const ? _op(:const, self, nil, name: name) : _op(:variable, self, nil, name: name)
     end
@@ -249,7 +256,7 @@ module TensorStream
       dtype = dtype[:dtype] if dtype.is_a?(Hash)
 
       case dtype.to_sym
-      when :float64, :float32, :float
+      when :float64, :float32, :float16, :float
         if !!val == val
           val ? 1.0 : 0.0
         else
@@ -257,7 +264,7 @@ module TensorStream
         end
       when :string
         val.to_s
-      when :int32, :int16, :uint8, :int
+      when :uint32, :int32, :uint64, :uint16, :int16, :int64, :uint8, :int
         if !!val == val
           val ? 1 : 0
         else

data/lib/tensor_stream/tensor_shape.rb

@@ -29,7 +29,9 @@ module TensorStream
 
     def known?
       return false if shape.nil?
-      shape.each { |s| return false if s.nil? }
+      
+      a_shape = shape.is_a?(Array) ? shape : [shape]
+      a_shape.each { |s| return false if s.nil? || s < 0 }
 
       true
     end

data/lib/tensor_stream/train/saver.rb

@@ -18,30 +18,39 @@ module TensorStream
         graph = {}
         gs =  eval_global_step(session, global_step)
         output_dump = {
-          variables: variables,
-          graph: graph,
-          global_step: gs
+          'variables' => variables,
+          'global_step' => gs
         }
 
         vars.each do |variable|
-          variables[variable.name] = variable.read_value
+          val = variable.read_value
+          packed_data = TensorStream::Packer.pack(val, variable.data_type)
+          variables[variable.name] = {
+            'shape' => shape_eval(val),
+            'data' => Base64.strict_encode64(packed_data)
+          }
         end
 
         basename = File.basename(outputfile)
         path = File.dirname(outputfile)
 
         new_filename = File.join(path, [basename, gs].compact.join('-'))
-        File.write(new_filename, output_dump.to_json)
+        File.write(new_filename, output_dump.to_yaml)
 
         path
       end
 
       def restore(_session, inputfile)
-        input_dump = JSON.parse(File.read(inputfile))
+        input_dump = YAML.load(File.read(inputfile))
 
         vars = TensorStream::Graph.get_default_graph.get_collection(GraphKeys::GLOBAL_VARIABLES)
         vars.each do |variable|
-          variable.value = input_dump['variables'][variable.name]
+          next unless input_dump['variables'].key?(variable.name)
+
+          data = TensorStream::Packer.unpack(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)
         end
       end
 
@@ -70,7 +79,7 @@ module TensorStream
       end
 
       def _add_saveable(saveables, seen_ops, saveable)
-        raise TensorStreamm::ValueError, "The same saveable will be restored with two names: #{saveable.name}" if seen_ops.include?(saveable.op)
+        raise TensorStream::ValueError, "The same saveable will be restored with two names: #{saveable.name}" if seen_ops.include?(saveable.op)
         saveables << saveable
         seen_ops << saveable.op
       end
@@ -87,7 +96,7 @@ module TensorStream
             tensor_slices << spec.slice_spec
           end
         end
-        i_op(:save_v2, filename_tensor, tensor_names, tensor_slices, tensors)
+        i_op(:save_ts, filename_tensor, *tensors)
       end
 
       def eval_global_step(session, global_step)

data/lib/tensor_stream/types.rb

@@ -7,6 +7,14 @@ module TensorStream
       :int16
     end
 
+    def self.uint16
+      :uint16
+    end
+
+    def self.float16
+      :float16
+    end
+
     def self.float32
       :float32
     end
@@ -15,6 +23,10 @@ module TensorStream
       :int32
     end
 
+    def self.uint32
+      :uint32
+    end
+
     def self.uint8
       :uint8
     end

data/lib/tensor_stream/version.rb

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

data/lib/tensor_stream.rb

@@ -22,6 +22,7 @@ require 'tensor_stream/control_flow'
 require 'tensor_stream/dynamic_stitch'
 require 'tensor_stream/nn/nn_ops'
 require 'tensor_stream/evaluator/evaluator'
+require 'tensor_stream/graph_serializers/packer'
 require 'tensor_stream/graph_serializers/serializer'
 require 'tensor_stream/graph_deserializers/protobuf'
 require 'tensor_stream/graph_serializers/pbtext'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tensor_stream
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.1
 platform: ruby
 authors:
 - Joseph Emmanuel Dayo
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-05 00:00:00.000000000 Z
+date: 2018-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -272,6 +272,7 @@ files:
 - lib/tensor_stream/graph_deserializers/protobuf.rb
 - lib/tensor_stream/graph_keys.rb
 - lib/tensor_stream/graph_serializers/graphml.rb
+- lib/tensor_stream/graph_serializers/packer.rb
 - lib/tensor_stream/graph_serializers/pbtext.rb
 - lib/tensor_stream/graph_serializers/serializer.rb
 - lib/tensor_stream/helpers/op_helper.rb
@@ -335,7 +336,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
 summary: A Pure ruby tensorflow implementation