tensor_stream 0.9.2 → 0.9.5

data/lib/tensor_stream/math_gradients.rb

@@ -268,7 +268,7 @@ module TensorStream
         when :sparse_softmax_cross_entropy_with_logits
           output = node
           [_broadcast_mul(grad, output[1]), nil]
-        when :floor, :ceil
+        when :floor, :ceil, :round
           # non differentiable
           nil
         when :zeros_like

data/lib/tensor_stream/monkey_patches/array.rb

@@ -0,0 +1,15 @@
+class Array
+  include TensorStream::MonkeyPatch
+
+  def /(other)
+    TensorStream.convert_to_tensor(self) * other
+  end
+
+  def %(other)
+    TensorStream.convert_to_tensor(self) % other
+  end
+
+  def **(other)
+    TensorStream.convert_to_tensor(self)**other
+  end
+end

data/lib/tensor_stream/monkey_patches/float.rb

@@ -0,0 +1,3 @@
+class Float
+  include TensorStream::MonkeyPatch
+end

data/lib/tensor_stream/monkey_patches/integer.rb

@@ -0,0 +1,3 @@
+class Integer
+  include TensorStream::MonkeyPatch
+end

data/lib/tensor_stream/monkey_patches/patch.rb

@@ -0,0 +1,70 @@
+require 'pry-byebug'
+module TensorStream
+  # various monkey patches to FixNum types
+  module MonkeyPatch
+    def self.included(klass)
+      ops = if klass == Array
+              {:+ => 'add', :- => 'sub', :* => 'mul'}
+            else
+              {:+ => 'add', :- => 'sub', :/ => 'div', :% => 'mod', :* => 'mul', :** => 'pow' }
+            end
+
+      ops.each do |m, name|
+        klass.send(:alias_method, :"_tensor_stream_#{name}_orig", m)
+        klass.send(:remove_method, m)
+      end
+    end
+
+    def t(name = nil)
+      TensorStream.convert_to_tensor(self, name: name)
+    end
+
+    def +(other)
+      if other.is_a?(TensorStream::Tensor)
+        TensorStream.convert_to_tensor(self) + other
+      else
+        _tensor_stream_add_orig(other)
+      end
+    end
+
+    def -(other)
+      if other.is_a?(TensorStream::Tensor)
+        TensorStream.convert_to_tensor(self) - other
+      else
+        _tensor_stream_sub_orig(other)
+      end
+    end
+
+    def *(other)
+      if other.is_a?(TensorStream::Tensor)
+        TensorStream.convert_to_tensor(self) * other
+      else
+        _tensor_stream_mul_orig(other)
+      end
+    end
+
+    def /(other)
+      if other.is_a?(TensorStream::Tensor)
+        TensorStream.convert_to_tensor(self) * other
+      else
+        _tensor_stream_div_orig(other)
+      end
+    end
+
+    def %(other)
+      if other.is_a?(TensorStream::Tensor)
+        TensorStream.convert_to_tensor(self) % other
+      else
+        _tensor_stream_mod_orig(other)
+      end
+    end
+
+    def **(other)
+      if other.is_a?(TensorStream::Tensor)
+        TensorStream.convert_to_tensor(self)**other
+      else
+        _tensor_stream_pow_orig(other)
+      end
+    end
+  end
+end

data/lib/tensor_stream/nn/nn_ops.rb

@@ -11,6 +11,42 @@ module TensorStream
       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)
+      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)
+
+        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
+
+        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)
+
+        binary_tensor = TensorStream.floor(random_tensor)
+        TensorStream.div(x, keep_prob) * binary_tensor
+      end
+    end
+
     def self.sigmoid(input, name: nil)
       TensorStream.sigmoid(input, name: name)
     end
@@ -21,10 +57,10 @@ module TensorStream
 
     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
-        tf = TensorStream
-        logits = tf.convert_to_tensor(logits, name: 'logits')
-        labels = tf.convert_to_tensor(labels, name: 'labels')
-        labels = tf.cast(labels, logits.dtype)
+        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]
@@ -45,7 +81,6 @@ module TensorStream
         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)
@@ -57,14 +92,13 @@ module TensorStream
         end
 
         shape_checks = []
-        if !static_shapes_fully_defined
-          shape_checks << tf.append(tf.assert_equal(tf.rank(labels), tf.rank(logits) - 1))
-        end
+
+        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 = array_ops.reshape(labels, [-1])
+          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)
 

data/lib/tensor_stream/operation.rb

@@ -1,3 +1,4 @@
+require 'tensor_stream/helpers/infer_shape'
 module TensorStream
   # TensorStream class that defines an operation
   class Operation < Tensor
@@ -26,7 +27,7 @@ module TensorStream
       @inputs = inputs.map { |i| options[:preserve_params_type] ? i : TensorStream.convert_to_tensor(i) }
       @data_type = set_data_type(options[:data_type])
       @is_const = infer_const
-      @shape = TensorShape.new(infer_shape)
+      @shape = TensorShape.new(TensorStream::InferShape.infer_shape(self))
       @graph.add_node(self)
     end
 
@@ -219,158 +220,6 @@ module TensorStream
 
     private
 
-    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
-        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?
-        return nil unless inputs[0].shape.known?
-
-        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)
-        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
-        return nil if new_shape.nil?
-        return nil if inputs[0].shape.nil?
-
-        input_shape = inputs[0].shape.shape
-        return new_shape if input_shape.nil?
-        return nil if input_shape.include?(nil)
-        TensorShape.fix_inferred_elements(new_shape, input_shape.reduce(:*))
-      when :flow_group
-        []
-      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
-        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)
-
-        rank = inputs[0].shape.shape.size
-        perm = inputs[1] || (0...rank).to_a.reverse
-        perm.map { |p| inputs[0].shape.shape[p] }
-      when :stack
-        return nil unless shape_full_specified(inputs[0])
-
-        axis = options[:axis] || 0
-        new_shape = [inputs.size]
-        inputs[0].shape.shape.inject(new_shape) { |ns, s| ns << s }
-        rank = inputs[0].shape.shape.size + 1
-        axis = rank + axis if axis < 0
-        rotated_shape = Array.new(axis + 1) { new_shape.shift }
-        rotated_shape.rotate! + new_shape
-      when :concat
-        return nil if inputs[0].value.nil?
-
-        axis = inputs[0].value # get axis
-
-        axis_size = 0
-
-        inputs[1..inputs.size].each do |input_item|
-          return nil if input_item.shape.shape.nil?
-          return nil if input_item.shape.shape[axis].nil?
-
-          axis_size += input_item.shape.shape[axis]
-        end
-
-        new_shape = inputs[1].shape.shape.dup
-        new_shape[axis] = axis_size
-        new_shape
-      when :slice, :squeeze
-        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] && inputs[0].shape.known? && inputs[1].shape.known?
-      end
-    end
-
     def propagate_consumer(consumer)
       super
       @inputs.compact.each do |input|

data/lib/tensor_stream/ops.rb

@@ -19,7 +19,7 @@ module TensorStream
     # +axis+  Describes which axis of the input Tensor to reduce across. For vectors, use axis = 0
     # +output_type+ Output data type defaults to int32
     def argmax(input, axis = nil, name: nil, dimension: nil, output_type: :int32)
-      _op(:argmax, input, nil, axis: axis, name: name, dimension: dimension, data_type: output_type)
+      _op(:argmax, input, axis, name: name, dimension: dimension, data_type: output_type)
     end
 
     ##
@@ -31,7 +31,21 @@ module TensorStream
     # +axis+  Describes which axis of the input Tensor to reduce across. For vectors, use axis = 0
     # +output_type+ Output data type defaults to int32
     def argmin(input, axis = nil, name: nil, dimension: nil, output_type: :int32)
-      _op(:argmin, input, nil, axis: axis, name: name, dimension: dimension, data_type: output_type)
+      _op(:argmin, input, axis, name: name, dimension: dimension, data_type: output_type)
+    end
+
+    ##
+    # Assert the condition x == y holds element-wise.
+    #
+    # Argmuments
+    #
+    # +x+ Numeric Tensor.
+    # +y+ Numeric Tensor, same dtype as and broadcastable to x.
+    #
+    # Returns
+    # Op that raises InvalidArgumentError if x == y is false
+    def assert_equal(x, y, data: nil, summarize: nil, message: nil, name: nil)
+      _op(:assert_equal, x, y, data: data, summarize: summarize, message: message, name: name)
     end
 
     ##
@@ -67,15 +81,15 @@ module TensorStream
     ##
     # Outputs random values from a uniform distribution.
     def random_uniform(shape, dtype: :float32, minval: 0, maxval: 1, seed: nil, name: nil)
-      options = { shape: shape, dtype: dtype, minval: minval, maxval: maxval, seed: seed, name: name }
-      _op(:random_uniform, nil, nil, options)
+      options = { dtype: dtype, minval: minval, maxval: maxval, seed: seed, name: name }
+      _op(:random_uniform, shape, nil, options)
     end
 
     ##
     # Outputs random values from a normal distribution.
     def random_normal(shape, dtype: :float32, mean: 0.0, stddev: 1.0, seed: nil, name: nil)
-      options = { shape: shape, dtype: dtype, mean: mean, stddev: stddev, seed: seed, name: name }
-      _op(:random_standard_normal, nil, nil, options)
+      options = { dtype: dtype, mean: mean, stddev: stddev, seed: seed, name: name }
+      _op(:random_standard_normal, shape, nil, options)
     end
 
     ##
@@ -83,7 +97,7 @@ module TensorStream
     #
     # When executed in a graph, this op outputs its input tensor as-is.
     def stop_gradient(tensor, options = {})
-      _op(:stop_gradient, tensor, nil, options)
+      _op(:stop_gradient, tensor, options)
     end
 
     ##
@@ -190,13 +204,13 @@ module TensorStream
     ##
     # Creates a tensor with all elements set to zero
     def zeros(shape, dtype: :float32, name: nil)
-      _op(:zeros, shape, nil, data_type: dtype, name: name)
+      _op(:zeros, shape, data_type: dtype, name: name)
     end
 
     ##
     # Creates a tensor with all elements set to 1.
     def ones(shape, dtype: :float32, name: nil)
-      _op(:ones, shape, nil, data_type: dtype, name: name)
+      _op(:ones, shape, data_type: dtype, name: name)
     end
 
     ##
@@ -302,37 +316,38 @@ module TensorStream
       res = _op(:split, value, num_or_size_splits, axis, name: name)
 
       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).zero?
-                    div = num_or_size_splits.value
-                    n = value.shape.shape[axis.value] / div
-
-                    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(:+)
-                    num_or_size_splits.value.collect do |v|
-                      new_shape = value.shape.shape.dup
-                      new_shape[axis.value] = v
-                      new_shape
-                    end
-                  else
-                    raise TensorStream::ValueError, "Scalar or 1D Tensor expected for num_or_size_splits"
+                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).zero?
+
+                  div = num_or_size_splits.value
+                  n = value.shape.shape[axis.value] / div
+
+                  Array.new(div) do
+                    new_shape = value.shape.shape.dup
+                    new_shape[axis.value] = n
+                    new_shape
                   end
-                else
-                  raise TensorStream::ValueError, "Cannot automatically determine num, please specify num: in options" if num.nil?
+                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(:+)
 
-                  Array.new(num) { nil }
+                  num_or_size_splits.value.collect do |v|
+                    new_shape = value.shape.shape.dup
+                    new_shape[axis.value] = v
+                    new_shape
+                  end
+                else
+                  raise TensorStream::ValueError, "Scalar or 1D Tensor expected for num_or_size_splits"
                 end
+               else
+                 raise TensorStream::ValueError, "Cannot automatically determine num, please specify num: in options" if num.nil?
+
+                 Array.new(num) { nil }
+               end
 
       pieces.collect.with_index do |shape, i|
         op = index(res, i, name: "split/index:#{i}")
-        if shape
-          op.shape = TensorShape.new(shape)
-        end
+        op.shape = TensorShape.new(shape) if shape
+
         op
       end
     end
@@ -354,20 +369,20 @@ module TensorStream
     ##
     # Computes square of x element-wise.
     def square(tensor, name: nil)
-      _op(:square, tensor, nil, name: name)
+      _op(:square, tensor, name: name)
     end
 
     ##
     # Rounds the values of a tensor to the nearest integer, element-wise
     def round(tensor, name: nil)
       check_allowed_types(tensor, FLOATING_POINT_TYPES)
-      _op(:round, tensor, nil, name: name)
+      _op(:round, tensor, name: name)
     end
 
     ##
     # Computes the reciprocal of x element-wise.
     def reciprocal(tensor, name: nil)
-      _op(:reciprocal, tensor, nil, name: name)
+      _op(:reciprocal, tensor, name: name)
     end
 
     ##
@@ -495,7 +510,7 @@ module TensorStream
       input = convert_to_tensor(input)
       return input if input.data_type == dtype
 
-      _op(:cast, input, nil, data_type: dtype, name: name)
+      _op(:cast, input, data_type: dtype, name: name)
     end
 
     ##
@@ -509,7 +524,7 @@ module TensorStream
     ##
     # Computes numerical negative value element-wise.
     def negate(input, name: nil)
-      _op(:negate, input, nil, name: name)
+      _op(:negate, input, name: name)
     end
 
     ##
@@ -539,7 +554,7 @@ module TensorStream
     # of the same type and shape as tensor with all elements set to zero.
     # Optionally, you can use dtype to specify a new type for the returned tensor.
     def zeros_like(tensor, dtype: nil, name: nil)
-      _op(:zeros_like, tensor, nil, data_type: dtype, name: name)
+      _op(:zeros_like, tensor, data_type: dtype, name: name)
     end
 
     ##
@@ -548,13 +563,13 @@ module TensorStream
     # tensor of the same type and shape as tensor with all elements set to 1.
     # Optionally, you can specify a new type (dtype) for the returned tensor.
     def ones_like(tensor, dtype: nil, name: nil)
-      _op(:ones_like, tensor, nil, data_type: dtype, name: name)
+      _op(:ones_like, tensor, data_type: dtype, name: name)
     end
 
     ##
     # Return a tensor with the same shape and contents as input.
     def identity(input, name: nil)
-      _op(:identity, input, nil, name: name)
+      _op(:identity, input, name: name)
     end
 
     ##
@@ -591,7 +606,7 @@ module TensorStream
     ##
     # Computes the absolute value of a tensor.
     def abs(input, name: nil)
-      _op(:abs, input, nil, name: name)
+      _op(:abs, input, name: name)
     end
 
     ##
@@ -599,63 +614,63 @@ module TensorStream
     # y = sign(x) = -1 if x < 0; 0 if x == 0 or tf.is_nan(x); 1 if x > 0.
     # Zero is returned for NaN inputs.
     def sign(input, name: nil)
-      _op(:sign, input, nil, name: name)
+      _op(:sign, input, name: name)
     end
 
     ##
     # Computes sin of input element-wise.
     def sin(input, name: nil)
       check_allowed_types(input, FLOATING_POINT_TYPES)
-      _op(:sin, input, nil, name: name)
+      _op(:sin, input, name: name)
     end
 
     ##
     # Computes cos of input element-wise.
     def cos(input, name: nil)
       check_allowed_types(input, FLOATING_POINT_TYPES)
-      _op(:cos, input, nil, name: name)
+      _op(:cos, input, name: name)
     end
 
     ##
     # Computes tan of input element-wise.
     def tan(input, name: nil)
       check_allowed_types(input, FLOATING_POINT_TYPES)
-      _op(:tan, input, nil, name: name)
+      _op(:tan, input, name: name)
     end
 
     ##
     # Computes tanh of input element-wise.
     def tanh(input, name: nil)
       check_allowed_types(input, FLOATING_POINT_TYPES)
-      _op(:tanh, input, nil, name: name)
+      _op(:tanh, input, name: name)
     end
 
     ##
     # Computes sqrt of input element-wise.
     def sqrt(input, name: nil)
       check_allowed_types(input, FLOATING_POINT_TYPES)
-      _op(:sqrt, input, nil, name: name)
+      _op(:sqrt, input, name: name)
     end
 
     ##
     # Computes natural logarithm of x element-wise.
     def log(input, name: nil)
       check_allowed_types(input, FLOATING_POINT_TYPES)
-      _op(:log, input, nil, name: name)
+      _op(:log, input, name: name)
     end
 
     ##
     # Computes natural logarithm of (1 + x) element-wise.
     def log1p(input, name: nil)
       check_allowed_types(input, FLOATING_POINT_TYPES)
-      _op(:log1p, input, nil, name: name)
+      _op(:log1p, input, name: name)
     end
 
     ##
     # Computes exponential of x element-wise.
     def exp(input, name: nil)
       check_allowed_types(input, FLOATING_POINT_TYPES)
-      _op(:exp, input, nil, name: name)
+      _op(:exp, input, name: name)
     end
 
     ##
@@ -675,7 +690,7 @@ module TensorStream
     # Computes sigmoid of x element-wise.
     def sigmoid(input, name: nil)
       check_allowed_types(input, FLOATING_POINT_TYPES)
-      _op(:sigmoid, input, nil, name: name)
+      _op(:sigmoid, input, name: name)
     end
 
     ##
@@ -698,14 +713,14 @@ module TensorStream
     # Pads a tensor.
     # This operation pads a tensor according to the paddings you specify.
     def pad(tensor, paddings, mode: 'CONSTANT', name: nil)
-      _op(:pad, tensor, nil, paddings: paddings, mode: mode, name: name)
+      _op(:pad, tensor, paddings, mode: mode, name: name)
     end
 
     ##
     # Checks a tensor for NaN and Inf values.
     # When run, reports an InvalidArgument error if tensor has any values that are not a number (NaN) or infinity (Inf). Otherwise, passes tensor as-is.
     def check_numerics(tensor, message, name: nil)
-      _op(:check_numerics, tensor, nil, message: message, name: name)
+      _op(:check_numerics, tensor, message: message, name: name)
     end
 
     def size(tensor, name: nil, out_type: :int32)
@@ -730,7 +745,6 @@ module TensorStream
       _op(:gather, params, indices, validate_indices: validate_indices, name: name, axis: axis)
     end
 
-
     ##
     # Stacks a list of rank-R tensors into one rank-(R+1) tensor.
     #
@@ -753,6 +767,7 @@ module TensorStream
                    new_shape[0]
                  else
                    raise TensorStream::ValueError, "num is unspecified and cannot be inferred." if num.nil?
+
                    num
                  end