tensor_stream 0.6.1 → 0.7.0

data/lib/tensor_stream/helpers/op_helper.rb

@@ -13,10 +13,10 @@ module TensorStream
     # same as op but with a marker that it was internal generated
     def i_op(code, *args)
       options = if args.last.is_a?(Hash)
-        args.pop
-      else
-        {}
-      end
+                  args.pop
+                else
+                  {}
+                end
 
       args << options.merge(internal: true)
       Operation.new(code.to_sym, *args)
@@ -45,32 +45,6 @@ module TensorStream
       arr
     end
 
-    def dtype_eval(rank, value, data_type = nil)
-      dtype = if data_type.nil?
-        Tensor.detect_type(value[0])
-      else
-       data_type
-      end
-
-      rank += 1 if dtype == :array
-
-      [dtype, rank, value[0], value.size]
-    end
-
-    def val_to_dtype(value)
-      if value.is_a?(String)
-        :string
-      elsif value.is_a?(Float)
-        :float32
-      elsif value.is_a?(Integer)
-        :int32
-      elsif value.is_a?(Array)
-        :array
-      else
-        :float32
-      end
-    end
-
     def fp_type?(type)
       TensorStream::Ops::FLOATING_POINT_TYPES.include?(type)
     end
@@ -88,10 +62,10 @@ module TensorStream
     def shapes_fully_specified_and_equal(x, y)
       return false if !shape_full_specified(x) || !shape_full_specified(y)
       return false if x.shape.shape != y.shape.shape
-      
+
       true
     end
- 
+
     def shape_full_specified(tensor)
       return false if tensor.shape.nil?
       return false if tensor.shape.shape.nil?
@@ -108,7 +82,7 @@ module TensorStream
       axes = (axes + input_rank) % input_rank
       axes_shape = i_op(:shape, axes)
       TensorStream.dynamic_stitch([TensorStream.range(0, input_rank), axes],
-        [input_shape, i_op(:fill, axes_shape, 1)])
+                                  [input_shape, i_op(:fill, axes_shape, 1)])
     end
   end
 end

data/lib/tensor_stream/helpers/string_helper.rb

@@ -1,4 +1,6 @@
 module TensorStream
+  # helper string methods usually found in ActiveSupport but
+  # need to replicate here
   module StringHelper
     def camelize(string, uppercase_first_letter = true)
       string = if uppercase_first_letter
@@ -8,5 +10,19 @@ module TensorStream
                end
       string.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }.gsub('/', '::')
     end
+
+    def underscore(string)
+      string.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+    end
+
+    def symbolize_keys(hash)
+      hash.map do |k, v|
+        [k.to_sym, v]
+      end.to_h
+    end
   end
 end

data/lib/tensor_stream/math_gradients.rb

@@ -18,7 +18,7 @@ module TensorStream
 
       grad = i_op(:fill, tf.shape(tensor), tf.constant(1, dtype: wrt_dx.data_type))
 
-      _propagate(grad, tensor, wrt_dx, nodes_to_compute, options[:stop_gradients] || [] ) || i_op(:zeros_like, wrt_dx)
+      _propagate(grad, tensor, wrt_dx, nodes_to_compute, options[:stop_gradients] || []) || i_op(:zeros_like, wrt_dx)
     end
 
     def self._propagate(grad, tensor, stop_tensor, nodes_to_compute, stop_gradients = [])
@@ -29,16 +29,12 @@ module TensorStream
       computed_op = _compute_derivative(tensor, grad)
 
       if computed_op.is_a?(Array)
-        partials = []
-        computed_op.each_with_index do |op_grad, index|
+        computed_op.each_with_index.collect do |op_grad, index|
           next if op_grad.nil?
+          next unless nodes_to_compute.include?(tensor.inputs[index].name)
 
-          if nodes_to_compute.include?(tensor.inputs[index].name)
-            partials << _propagate(op_grad, tensor.inputs[index], stop_tensor, nodes_to_compute, stop_gradients)
-          end
-        end
-
-        partials.compact.reduce(:+)
+          _propagate(op_grad, tensor.inputs[index], stop_tensor, nodes_to_compute, stop_gradients)
+        end.compact.reduce(:+)
       else
         return nil if computed_op.nil?
         _propagate(computed_op, tensor.inputs[0], stop_tensor, nodes_to_compute, stop_gradients)
@@ -51,14 +47,32 @@ module TensorStream
         y = node.inputs[1] if node.inputs[1]
 
         case node.operation
+        when :add_n
+          return [grad] * node.inputs.size
         when :add
           return [grad, grad] if shapes_fully_specified_and_equal(x, y)
           sx = tf.shape(x, name: 'add/shape_x')
           sy = tf.shape(y, name: 'add/shape_y')
           rx, ry = _broadcast_gradient_args(sx, sy)
 
-          [ tf.reshape(tf.reduce_sum(grad, rx, name: 'add/reduce_sum_x'),sx),
-            tf.reshape(tf.reduce_sum(grad, ry, name: 'add/reduce_sum_y'),sy) ]
+          [tf.reshape(tf.reduce_sum(grad, rx, name: 'add/reduce_sum_x'), sx),
+           tf.reshape(tf.reduce_sum(grad, ry, name: 'add/reduce_sum_y'), sy)]
+        when :asin
+          tf.control_dependencies([grad]) do
+            x2 = tf.square(x)
+            one = tf.constant(1, dtype: grad.data_type)
+            den = tf.sqrt(tf.subtract(one, x2))
+            inv = tf.reciprocal(den)
+            grad * inv
+          end
+        when :acos
+          tf.control_dependencies([grad]) do
+            x2 = tf.square(x)
+            one = tf.constant(1, dtype: grad.data_type)
+            den = tf.sqrt(tf.subtract(one, x2))
+            inv = tf.reciprocal(den)
+            -grad * inv
+          end
         when :sub
           return [grad, -grad] if shapes_fully_specified_and_equal(x, y)
 
@@ -66,24 +80,22 @@ module TensorStream
           sy = tf.shape(y, name: 'sub/shape_y')
           rx, ry = _broadcast_gradient_args(sx, sy)
 
-          [ tf.reshape(tf.reduce_sum(grad, rx, name: 'add/reduce_sub_x'),sx),
-            -tf.reshape(tf.reduce_sum(grad, ry, name: 'add/reduce_sub_y'),sy) ]
+          [tf.reshape(tf.reduce_sum(grad, rx, name: 'add/reduce_sub_x'), sx),
+           -tf.reshape(tf.reduce_sum(grad, ry, name: 'add/reduce_sub_y'), sy)]
         when :mul
           sx = tf.shape(x)
           sy = tf.shape(y)
           rx, ry = _broadcast_gradient_args(sx, sy)
 
-          [ tf.reshape(tf.reduce_sum(tf.mul(grad, y), rx), sx),
-            tf.reshape(tf.reduce_sum(tf.mul(x, grad), ry), sy)]
+          [tf.reshape(tf.reduce_sum(tf.mul(grad, y), rx), sx),
+           tf.reshape(tf.reduce_sum(tf.mul(x, grad), ry), sy)]
         when :div
           sx = i_op(:shape, x)
           sy = i_op(:shape, y)
           rx, ry = _broadcast_gradient_args(sx, sy)
 
-          [
-            tf.reshape(tf.reduce_sum(tf.div(grad, y), rx), sx),
-            tf.reshape(tf.reduce_sum(grad * tf.div(tf.div(-x, y), y),
-                                  ry), sy)]
+          [tf.reshape(tf.reduce_sum(tf.div(grad, y), rx), sx),
+           tf.reshape(tf.reduce_sum(grad * tf.div(tf.div(-x, y), y), ry), sy)]
         when :mod
           sx = tf.shape(x)
           sy = tf.shape(y)
@@ -100,9 +112,9 @@ module TensorStream
 
           x_grad = tf.mul(2.0, grad) * (x - y)
 
-          [ tf.reshape(tf.reduce_sum(x_grad, rx), sx),
-            tf.reshape(-tf.reduce_sum(x_grad, ry), sy)]
-        when :matmul
+          [tf.reshape(tf.reduce_sum(x_grad, rx), sx),
+           tf.reshape(-tf.reduce_sum(x_grad, ry), sy)]
+        when :mat_mul
           t_a = node.options[:transpose_a]
           t_b = node.options[:transpose_b]
 
@@ -140,14 +152,12 @@ module TensorStream
           grad * tf.sign(x)
         when :log
           grad * tf.reciprocal(x)
-        when :tanh
-          i_op(:tanh_grad, x) * grad
         when :cos
           -grad * tf.sin(x)
         when :max
-          x_mask = tf.where(x > y, tf.ones_like(x), tf.zeros_like(y))
-          y_mask = tf.where(x < y, tf.zeros_like(x), tf.ones_like(y))
-          [x_mask * grad, y_mask * grad]
+          _min_or_max_grad(node.inputs, grad, ->(x, y) { tf.greater_equal(x, y) } )
+        when :min
+          _min_or_max_grad(node.inputs, grad, ->(x, y) { tf.less_equal(x, y) } )
         when :tan
           secx = tf.reciprocal(tf.cos(x))
           secx2 = tf.square(secx)
@@ -158,6 +168,8 @@ module TensorStream
           grad * node
         when :identity, :print
           grad
+        when :sign
+          tf.zeros(tf.shape(x), dtype: x.data_type)
         when :sum
           _sum_grad(x, y, grad)
         when :reciprocal
@@ -178,7 +190,7 @@ module TensorStream
           y_cond = i_op(:cond, i_op(:zeros_like, x), i_op(:ones_like, x), pred: node.options[:pred])
           [x_cond * grad, y_cond * grad]
         when :mean
-          sum_grad  = _sum_grad(x, y, grad)[0]
+          sum_grad = _sum_grad(x, y, grad)[0]
           input_shape = tf.shape(x)
           output_shape = tf.shape(node)
           factor = _safe_shape_div(tf.reduce_prod(input_shape), tf.reduce_prod(output_shape))
@@ -187,19 +199,20 @@ module TensorStream
           grad * tf.reciprocal(i_cons(1, dtype: grad.data_type) + x)
         when :sigmoid
           i_op(:sigmoid_grad, x, grad)
+        when :sigmoid_grad
+          gb = grad * y
+          [gb - 2.0 * gb * x, i_op(:sigmoid_grad, x, grad)]
         when :softmax
           i_op(:softmax_grad, x, grad)
         when :softmax_cross_entropy_with_logits_v2
-          # -grad * tf.reciprocal(i_op(:softmax, x))
           [i_op(:softmax_cross_entropy_with_logits_v2_grad, x, y, grad), nil]
-          # i_op(:softmax_grad, x, -grad * tf.reciprocal(i_op(:softmax, x)))
         when :floor, :ceil
           # non differentiable
           nil
         when :zeros_like
           # non differentiable
           nil
-        when :argmin, :argmax
+        when :argmin, :argmax, :floor_div
           # non differentiable
           [nil, nil]
         else
@@ -217,19 +230,19 @@ module TensorStream
       _op(:broadcast_transform, input_a, input_b)
     end
 
-    def self._safe_shape_div(x, y)
-      _op(:floor_div, x , tf.maximum(y, 1))
+    def self._safe_shape_div(arg_x, arg_y)
+      _op(:floor_div, arg_x, tf.maximum(arg_y, 1))
     end
 
-    def self._sum_grad(x, y, grad)
-      input_shape = _op(:shape, x)
-      output_shape_kept_dims = tf.reduced_shape(input_shape, y)
+    def self._sum_grad(arg_x, arg_y, grad)
+      input_shape = _op(:shape, arg_x)
+      output_shape_kept_dims = tf.reduced_shape(input_shape, arg_y)
       tile_scaling = _safe_shape_div(input_shape, output_shape_kept_dims)
       new_grad = _op(:reshape, grad, output_shape_kept_dims)
 
-      grad = _op(:cond, _op(:fill, input_shape, grad) , _op(:tile, new_grad, tile_scaling), pred: _op(:rank, grad) == 0 )
+      grad = _op(:cond, _op(:fill, input_shape, grad), _op(:tile, new_grad, tile_scaling), pred: _op(:rank, grad).zero?)
 
-      [grad, nil ]
+      [grad, nil]
     end
 
     def self._op_supports_broadcast?(node)
@@ -237,11 +250,21 @@ module TensorStream
       false
     end
 
-    def self._min_or_max_grad(op, grad)
-      y = op
-      indicators = tf.cast(tf.equal(y, op.inputs[0]), grad.data_type)
-      num_selected = tf.reduce_sum(indicators, op.inputs[1])
-      _safe_shape_div(indicators, num_selected) * grad
+    def self._min_or_max_grad(inputs, grad, selector_op)
+      x = inputs[0]
+      y = inputs[1]
+      gdtype = grad.data_type
+      sx = tf.shape(x)
+      sy = tf.shape(y)
+      gradshape = tf.shape(grad)
+      zeros = tf.zeros(gradshape, dtype: gdtype)
+      xmask = selector_op.call(x, y)
+      rx, ry = _broadcast_gradient_args(sx, sy)
+      xgrad = tf.where(xmask, grad, zeros, name: 'x')
+      ygrad = tf.where(xmask, zeros, grad, name: 'y')
+      gx = tf.reshape(tf.reduce_sum(xgrad, rx), sx)
+      gy = tf.reshape(tf.reduce_sum(ygrad, ry), sy)
+      [gx, gy]
     end
 
     def self._include?(arr, obj)
@@ -249,4 +272,4 @@ module TensorStream
       false
     end
   end
-end
+end

data/lib/tensor_stream/nn/nn_ops.rb

@@ -2,6 +2,7 @@ module TensorStream
   # High level machine learning functions
   class NN
     extend TensorStream::OpHelper
+
     def self.softmax(logits, axis: nil, name: nil)
       _op(:softmax, logits, nil, axis: axis, name: name)
     end
@@ -29,8 +30,13 @@ module TensorStream
       end
     end
 
+    # Computes log softmax activations.
+    def self.log_softmax(logits, axis: -1, name: nil)
+      _op(:log_softmax, logits, axis: axis, name: name)
+    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|
+      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')

data/lib/tensor_stream/operation.rb

@@ -6,10 +6,10 @@ module TensorStream
 
     def initialize(operation, *args)
       options = if args.last.is_a?(Hash)
-        args.pop
-      else
-        {}
-      end
+                  args.pop
+                else
+                  {}
+                end
 
       inputs = args
 
@@ -42,24 +42,10 @@ module TensorStream
       }
     end
 
-    def self.empty_matrix?(input)
-      if input.is_a?(Array)
-        input.each do |input|
-          if input.is_a?(Array)
-            return false unless empty_matrix?(input)
-          elsif input != 0 || input != 0.0
-            return false
-          end
-        end
-      end
-
-      true
-    end
-
     def infer_const
       return false if breakpoint
       case operation
-      when :random_normal, :random_uniform, :glorot_uniform, :print
+      when :random_standard_normal, :random_uniform, :glorot_uniform, :print
         false
       else
         non_const = @inputs.compact.find { |input| !input.is_const }
@@ -75,7 +61,7 @@ module TensorStream
         :boolean
       when :shape, :rank
         options[:out_type] || :int32
-      when :random_normal, :random_uniform, :glorot_uniform
+      when :random_standard_normal, :random_uniform, :glorot_uniform
         passed_data_type || :float32
       when :index
         if @inputs[0].is_a?(ControlFlow)
@@ -150,7 +136,7 @@ module TensorStream
         "gradient(#{sub_input})"
       when :stop_gradient
         sub_input
-      when :matmul
+      when :mat_mul
         "#{sub_input}.matmul(#{sub_input2})"
       when :eye
         "eye(#{sub_input})"
@@ -261,13 +247,13 @@ module TensorStream
         return TensorShape.fix_inferred_elements(new_shape, input_shape.reduce(:*))
       when :flow_group
         return []
-      when :zeros, :ones
+      when :zeros, :ones, :fill
         return inputs[0] ? inputs[0].value : options[:shape]
       when :zeros_like, :ones_like
         inputs[0].shape.shape
       when :shape
         return inputs[0].shape.shape ? [inputs[0].shape.shape.size] : nil
-      when :matmul
+      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]
         return [shape1, shape2]
@@ -285,11 +271,12 @@ module TensorStream
       super
       @inputs.compact.each do |input|
         if input.is_a?(Array)
-          input.flatten.compact.each do |t|
-            t.send(:propagate_consumer, consumer) if t.is_a?(Tensor)
+          input.flatten.compact.select { |t| t.is_a?(Tensor) }.each do |t|
+            next if t.consumers.include?(consumer.name)
+            t.send(:propagate_consumer, consumer)
           end
-        else
-          input.send(:propagate_consumer, consumer) if input.name != name
+        elsif input.name != name && !input.consumers.include?(consumer.name)
+          input.send(:propagate_consumer, consumer)
         end
       end
     end

data/lib/tensor_stream/ops.rb

@@ -35,24 +35,24 @@ module TensorStream
     # ys and xs are each a Tensor or a list of tensors. grad_ys is a list of Tensor, holding the gradients received by the ys. The list must be the same length as ys.
     #
     # Arguments:
-    # +ys+     : A Tensor or list of tensors to be differentiated.
+    # +tensor_ys+ : A Tensor or list of tensors to be differentiated.
     # +wrt_xs+ : A Tensor or list of tensors to be used for differentiation.
-    # +stop_gradients+:  Optional. A Tensor or list of tensors not to differentiate through
-    def gradients(ys, wrt_xs, name: 'gradients', stop_gradients: nil)
-
+    # +stop_gradients+ :  Optional. A Tensor or list of tensors not to differentiate through
+    def gradients(tensor_ys, wrt_xs, name: 'gradients', stop_gradients: nil)
       gs = wrt_xs.collect do |x|
         stops = stop_gradients ? stop_gradients.map(&:name).join('_') : ''
-        gradient_program_name = "grad_#{ys.name}_#{x.name}_#{stops}".to_sym
-
-        tensor_program = if ys.graph.node_added?(gradient_program_name)
-                          ys.graph.get_node(gradient_program_name)
-                        else
-                          ys.graph.name_scope("gradient_wrt_#{x.name}") do
-                            derivative_ops = TensorStream::MathGradients.derivative(ys, x, graph: ys.graph,
-                              stop_gradients: stop_gradients)
-                            ys.graph.add_node!(gradient_program_name, derivative_ops)
-                          end
-                        end
+        gradient_program_name = "grad_#{tensor_ys.name}_#{x.name}_#{stops}".to_sym
+        tensor_graph = tensor_ys.graph
+
+        tensor_program = if tensor_graph.node_added?(gradient_program_name)
+                           tensor_graph.get_node(gradient_program_name)
+                         else
+                           tensor_graph.name_scope("gradient_wrt_#{x.name}") do
+                             derivative_ops = TensorStream::MathGradients.derivative(tensor_ys, x, graph: tensor_graph,
+                                                                                                   stop_gradients: stop_gradients)
+                             tensor_graph.add_node!(gradient_program_name, derivative_ops)
+                           end
+                         end
         tensor_program
       end
       TensorStream.group(gs)
@@ -69,7 +69,7 @@ module TensorStream
     # 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_normal, nil, nil, options)
+      _op(:random_standard_normal, nil, nil, options)
     end
 
     ##
@@ -86,6 +86,10 @@ module TensorStream
       _op(:eye, num_rows, num_columns || num_rows, data_type: dtype, name: name)
     end
 
+    def expand_dims(input, axis = nil, name: nil)
+      _op(:expand_dims, input, axis, name: name)
+    end
+
     ##
     # This operation returns a 1-D integer tensor representing the shape of input
     def shape(input, name: nil, out_type: :int32)
@@ -98,7 +102,9 @@ module TensorStream
     ##
     # Constructs a tensor by tiling a given tensor.
     #
-    # This operation creates a new tensor by replicating input multiples times. The output tensor's i'th dimension has input.dims(i) * multiples[i] elements, and the values of input are replicated multiples[i] times along the 'i'th dimension. For example, tiling [a b c d] by [2] produces [a b c d a b c d].
+    # This operation creates a new tensor by replicating input multiples times.
+    # The output tensor's i'th dimension has input.dims(i) * multiples[i] elements,
+    # and the values of input are replicated multiples[i] times along the 'i'th dimension. For example, tiling [a b c d] by [2] produces [a b c d a b c d].
     def tile(input, multiples, name: nil)
       _op(:tile, input, multiples, name: name)
     end
@@ -118,7 +124,9 @@ module TensorStream
     ##
     # The Glorot uniform initializer, also called Xavier uniform initializer.
     #
-    # It draws samples from a uniform distribution within [-limit, limit] where limit is sqrt(6 / (fan_in + fan_out)) where fan_in is the number of input units in the weight tensor and fan_out is the number of output units in the weight tensor.
+    # It draws samples from a uniform distribution within [-limit, limit]
+    # where limit is sqrt(6 / (fan_in + fan_out)) where fan_in is the number
+    # of input units in the weight tensor and fan_out is the number of output units in the weight tensor.
     def glorot_uniform_initializer(seed: nil, dtype: nil)
       TensorStream::Initializer.new(-> { _op(:glorot_uniform, nil, nil, seed: seed, data_type: dtype) })
     end
@@ -132,7 +140,9 @@ module TensorStream
     ##
     # Extracts a slice from a tensor.
     #
-    # This operation extracts a slice of size size from a tensor input starting at the location specified by begin. The slice size is represented as a tensor shape, where size[i] is the number of elements of the 'i'th dimension of input that you want to slice. The starting location (begin) for the slice is represented as an offset in each dimension of input. In other words, begin[i] is the offset into the 'i'th dimension of input that you want to slice from.
+    # This operation extracts a slice of size size from a tensor input starting at the location specified by begin.
+    # The slice size is represented as a tensor shape, where size[i] is the number of elements of the 'i'th dimension of input that you want to slice. The starting location (begin) for the slice is
+    # represented as an offset in each dimension of input. In other words, begin[i] is the offset into the 'i'th dimension of input that you want to slice from.
     def slice(input, start, size, name: nil)
       _op(:slice, input, start, size: size, name: name)
     end
@@ -188,7 +198,7 @@ module TensorStream
 
     ##
     # Returns the truth value of (x >= y) element-wise.
-    # 
+    #
     # This operation supports broadcasting
     def greater_equal(input_a, input_b, name: nil)
       input_a, input_b = check_data_types(input_a, input_b)
@@ -205,14 +215,17 @@ module TensorStream
     ##
     # Computes the mean of elements across dimensions of a tensor.
     def reduce_mean(input_tensor, axis = nil, keepdims: false, name: nil)
-      _op(:mean, input_tensor, axis,  keepdims: keepdims, name: name)
+      _op(:mean, input_tensor, axis, keepdims: keepdims, name: name)
     end
 
     ##
     # Computes the sum of elements across dimensions of a tensor.
     #
-    # Reduces input_tensor along the dimensions given in axis. Unless keepdims is true, the rank of the tensor is reduced by 1 for each entry in axis. If keepdims is true, the reduced dimensions are retained with length 1.
-    # If axis has no entries, all dimensions are reduced, and a tensor with a single element is returned.
+    # Reduces input_tensor along the dimensions given in axis. Unless keepdims is true,
+    # the rank of the tensor is reduced by 1 for each entry in axis. If keepdims is true,
+    # the reduced dimensions are retained with length 1.
+    # If axis has no entries, all dimensions are reduced, and a tensor with a single element
+    # is returned.
     def reduce_sum(input_tensor, axis = nil, keepdims: false, name: nil)
       _op(:sum, input_tensor, axis, keepdims: keepdims, name: name)
     end
@@ -220,7 +233,9 @@ module TensorStream
     ##
     # Computes the product of elements across dimensions of a tensor.
     #
-    # Reduces input_tensor along the dimensions given in axis. Unless keepdims is true, the rank of the tensor is reduced by 1 for each entry in axis. If keepdims is true, the reduced dimensions are retained with length 1.
+    # Reduces input_tensor along the dimensions given in axis. Unless keepdims is true, the rank of the
+    # tensor is reduced by 1 for each entry in axis. If keepdims is true, the reduced dimensions are
+    # retained with length 1.
     #
     # If axis has no entries, all dimensions are reduced, and a tensor with a single element is returned.
     def reduce_prod(input, axis = nil, keepdims: false, name: nil)
@@ -281,6 +296,28 @@ module TensorStream
       _op(:add, input_a, input_b, name: name)
     end
 
+    ##
+    # Adds all input tensors element-wise.
+    #
+    # Elements must all be the same shape and type
+    def add_n(inputs, name: nil)
+      _op(:add_n, *inputs, name: name)
+    end
+
+    ##
+    # Computes asin of input element-wise
+    def asin(input, name: nil)
+      check_allowed_types(input, FLOATING_POINT_TYPES)
+      _op(:asin, input, name: name)
+    end
+
+    ##
+    # Computes acos of input element-wise
+    def acos(input, name: nil)
+      check_allowed_types(input, FLOATING_POINT_TYPES)
+      _op(:acos, input, name: name)
+    end
+
     ##
     # Returns x - y element-wise.
     #
@@ -329,10 +366,22 @@ module TensorStream
     ##
     # Returns the max of x and y (i.e. x > y ? x : y) element-wise.
     def maximum(input_a, input_b, name: nil)
+      max(input_a, input_b, name: name)
+    end
+
+    ##
+    # Returns the min of x and y (i.e. x < y ? x : y) element-wise.
+    def min(input_a, input_b, name: nil)
       check_allowed_types(input_a, NUMERIC_TYPES)
       check_allowed_types(input_b, NUMERIC_TYPES)
       input_a, input_b = check_data_types(input_a, input_b)
-      max(input_a, input_b, name: name)
+      _op(:min, input_a, input_b, name: name)
+    end
+
+    ##
+    # Returns the min of x and y (i.e. x < y ? x : y) element-wise.
+    def minimum(input_a, input_b, name: nil)
+      min(input_a, input_b, name: name)
     end
 
     ##
@@ -378,14 +427,18 @@ module TensorStream
 
     ##
     # reates a tensor with all elements set to zero.
-    # Given a single tensor (tensor), this operation returns a tensor 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.
+    # Given a single tensor (tensor), this operation returns a tensor
+    # 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)
     end
 
     ##
     # Creates a tensor with all elements set to 1.
-    # Given a single tensor (tensor), this operation returns a 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.
+    # Given a single tensor (tensor), this operation returns a
+    # 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)
     end
@@ -505,7 +558,7 @@ module TensorStream
     # For example:
     # Output tensor has shape [2, 3].
     # fill([2, 3], 9) => [[9, 9, 9]
-     #                    [9, 9, 9]]
+    #                    [9, 9, 9]]
     def fill(dims, value, name: nil)
       _op(:fill, dims, value, name: name)
     end
@@ -524,7 +577,7 @@ module TensorStream
                transpose_b: false,
                name: nil)
       input_a, input_b = check_data_types(input_a, input_b)
-      _op(:matmul, input_a, input_b, transpose_a: transpose_a, transpose_b: transpose_b, name: name)
+      _op(:mat_mul, input_a, input_b, transpose_a: transpose_a, transpose_b: transpose_b, name: name)
     end
 
     ##