tensor_stream 1.0.0 → 1.0.1

data/lib/tensor_stream/monkey_patches/array.rb

@@ -48,4 +48,4 @@ class Array
       index(min)
     end
   end
-end
+end

data/lib/tensor_stream/monkey_patches/float.rb

@@ -7,4 +7,4 @@ class Float
     data_type = :"float#{width}"
     TensorStream.placeholder(data_type, name: name, shape: shape)
   end
-end
+end

data/lib/tensor_stream/monkey_patches/integer.rb

@@ -7,4 +7,4 @@ class Integer
     data_type = :"int#{width}"
     TensorStream.placeholder(data_type, name: name, shape: shape)
   end
-end
+end

data/lib/tensor_stream/monkey_patches/op_patch.rb

@@ -2,10 +2,10 @@ module TensorStream
   module OpPatch
     def self.included(klass)
       ops = if klass == Array
-              {:+ => 'add', :- => 'sub', :* => 'mul'}
-            else
-              {:+ => 'add', :- => 'sub', :/ => 'div', :% => 'mod', :* => 'mul', :** => 'pow' }
-            end
+        {:+ => "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)
@@ -65,4 +65,4 @@ end
 
 Integer.include TensorStream::OpPatch
 Float.include TensorStream::OpPatch
-Array.include TensorStream::OpPatch
+Array.include TensorStream::OpPatch

data/lib/tensor_stream/monkey_patches/patch.rb

@@ -10,4 +10,4 @@ module TensorStream
       TensorStream.convert_to_tensor(self, name: name, dtype: dtype)
     end
   end
-end
+end

data/lib/tensor_stream/nn/nn_ops.rb

@@ -27,7 +27,7 @@ module TensorStream
         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)
+          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) && !(keep_prob > 0 && keep_prob <= 1)
 
           return x if keep_prob.is_a?(Float) && keep_prob.to_f == 1.0
 
@@ -35,10 +35,10 @@ module TensorStream
           return x if keep_prob.value == 1.0
 
           noise_shape = if noise_shape.nil?
-                          TensorStream.shape(x)
-                        else
-                          noise_shape
-                        end
+            TensorStream.shape(x)
+          else
+            noise_shape
+          end
 
           random_tensor = keep_prob
           random_tensor += TensorStream.random_uniform(noise_shape, seed: seed, dtype: x.dtype)
@@ -57,10 +57,10 @@ module TensorStream
       end
 
       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
+        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')
+          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)
@@ -80,11 +80,13 @@ module TensorStream
           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.known? && (labels_static_shape.known? && labels_static_shape.ndims != logits.shape.ndims - 1)
+            raise TensorStream::ValueError, "Rank mismatch: Rank of labels (received #{labels_static_shape.ndims}) " \
+                                            "should equal rank of logits minus 1 (received #{logits.shape.ndims})."
+          end
           if logits.shape.ndims == 2
             cost = _op(:sparse_softmax_cross_entropy_with_logits,
-                precise_logits, labels, name: name)
+              precise_logits, labels, name: name)
             if logits.data_type == :float16
               return tf.cast(cost[0], :float16)
             else
@@ -118,17 +120,17 @@ module TensorStream
       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|
+        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')
+          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)
+            tf.log1p(tf.exp(neg_abs_logits)), name: name)
         end
       end
 

data/lib/tensor_stream/op_maker.rb

@@ -0,0 +1,180 @@
+class TensorStream::OpMaker
+  attr_reader :operation, :description, :parameters,
+              :options, :gradient, :check_types,
+              :supports_broadcast, :data_type_coercion,
+              :aliases, :custom, :infer_type_proc, :exclude
+
+  def initialize(op)
+    @operation = op
+    @parameters = []
+    @options = {}
+    @gradient = nil
+    @supports_broadcast = false
+    @data_type_coercion = false
+    @exclude = false
+    @description = []
+    @aliases = []
+    @custom = []
+    @infer_type_proc = lambda { |tensor|
+      next nil if tensor.inputs[0].nil?
+      next tensor.inputs[0].shape.shape if tensor.inputs.size == 1
+
+      TensorStream::TensorShape.infer_shape(tensor.inputs[0].shape.shape, tensor.inputs[1].shape.shape) if tensor.inputs.size == 2 && tensor.inputs[0] && tensor.inputs[1]
+    }
+  end
+
+  def other_names(aliases)
+    @aliases += aliases
+  end
+
+  def add_custom(custom_code)
+    @custom << custom_code
+  end
+
+  def self.scan
+    op_files = Dir[File.join("lib", "tensor_stream", "ops", "*.rb")]
+    op_files.each { |file|
+      load File.join("tensor_stream", "ops", File.basename(file))
+    }
+  end
+
+  def self.define_operation(op_code, &block)
+    @ops ||= {}
+    op_maker = TensorStream::OpMaker.new(op_code.to_sym)
+    block.call(op_maker)
+    @ops[op_code.to_sym] = op_maker
+  end
+
+  # call an operations' gradient definition
+  def self.gradient_op(context_caller, node, grad)
+    raise "No derivative op defined for #{node.operation}" if @ops[node.operation].nil? || @ops[node.operation].gradient.nil?
+
+    context_caller.instance_exec(grad, node, node.inputs, &@ops[node.operation].gradient)
+  end
+
+  def self.infer_shape(context_caller, tensor)
+    return nil unless @ops[tensor.operation]
+
+    context_caller.instance_exec(tensor, &@ops[tensor.operation].infer_type_proc)
+  end
+
+  def self.each_op(&block)
+    @ops.values.sort_by { |op| op.operation }.reject(&:exclude).each do |op|
+      block.call(op)
+    end
+  end
+
+  def what_it_does(description)
+    @description << description
+  end
+
+  def what_it_does_code(description)
+    @description << "<tt>#{description}</tt>"
+  end
+
+  def exclude!
+    @exclude = true
+  end
+
+  def description_lines
+    description.map { |line| line.split("\n") }.flatten
+  end
+
+  def generate_body
+    body = []
+    parameters.select { |p| p[:validate] }.each do |p|
+      body << "check_allowed_types(#{p[:name]}, TensorStream::Ops::#{p[:validate]})"
+    end
+    if data_type_coercion?
+      body << "#{expand_params(false).join(', ')} = apply_data_type_coercion(#{expand_params(false).join(', ')})"
+    end
+    if check_types?
+      body << "check_data_types(#{expand_params(false).join(', ')})"
+    end
+    custom.each do |c|
+      body << c
+    end
+    body << "_op(:#{operation}, #{(expand_params(false) + options_call).join(', ')})"
+    body.map { |line| "      #{line}"}.join("\n")
+  end
+
+  ##
+  # adds a parameter to the op
+  #
+  def parameter(name, description, default_value = nil, validate: nil)
+    @parameters << {
+      name: name.to_s,
+      description: description,
+      default_value: default_value,
+      validate: validate
+    }
+  end
+
+  def option(name, description, default_value = nil, options = {})
+    @options[name] = { description: description, default_value: default_value, options: options }
+  end
+
+  def define_gradient(&block)
+    @gradient = block
+  end
+
+  def define_shape(&block)
+    @infer_type_proc = block
+  end
+
+  def expand_params(print_defaults)
+    @parameters.map { |param|
+      print_defaults && param[:default_value] ? "#{param[:name]} = #{default_with_nil(param[:default_value])}" : "#{param[:name]}"
+    }
+  end
+
+  def parameters_must_have_same_data_type!
+    @check_types = true
+  end
+
+  def apply_data_type_coercion!
+    @data_type_coercion = true
+  end
+
+  def supports_broadcasting!
+    if (@parameters.size> 1)
+      @supports_broadcast = true
+    else
+      raise "Ops with parameters < 2 cannot support broadcasting"
+    end
+  end
+
+  def supports_broadcasting?
+    @supports_broadcast
+  end
+
+  def data_type_coercion?
+    @data_type_coercion
+  end
+
+  def check_types?
+    @check_types
+  end
+
+  def expand_options(print_defaults)
+    @options.map { |k, v|
+      print_defaults && v[:default_value] ? "#{k}: #{default_with_nil(v[:default_value])}" : "#{k}:"
+    }
+  end
+
+  def options_call
+    @options.map { |k, v|
+      if v.dig(:options, :alias)
+        "#{v.dig(:options, :alias)}: #{k}"
+      else
+        "#{k}: #{k}"
+      end
+    }
+  end
+
+  def default_with_nil(v)
+    v == :nil ? 'nil' : v
+  end
+end
+
+TensorStream::OpMaker.scan

data/lib/tensor_stream/operation.rb

@@ -1,4 +1,4 @@
-require 'tensor_stream/helpers/infer_shape'
+require "tensor_stream/helpers/infer_shape"
 module TensorStream
   # TensorStream class that defines an operation
   class Operation < Tensor
@@ -17,7 +17,7 @@ module TensorStream
     end
 
     def inspect
-      "Op(#{operation} name: #{name} shape: #{@shape || '?'} data_type: #{data_type})"
+      "Op(#{operation} name: #{name} shape: #{@shape || "?"} data_type: #{data_type})"
     end
 
     def to_s
@@ -30,7 +30,7 @@ module TensorStream
         name: name.to_s,
         data_type: @data_type,
         inputs: @inputs.map(&:name),
-        attrs: serialize_options
+        attrs: serialize_options,
       }
     end
 
@@ -145,11 +145,11 @@ module TensorStream
             when :slice
               "#{sub_input}[#{sub_input2}]"
             when :assign_sub
-              "(#{inputs[0] ? inputs[0].name : 'self'} -= #{auto_math(inputs[1], name_only, 1)})"
+              "(#{inputs[0] ? inputs[0].name : "self"} -= #{auto_math(inputs[1], name_only, 1)})"
             when :assign_add
-              "(#{inputs[0] ? inputs[0].name : 'self'} += #{auto_math(inputs[1], name_only, 1)})"
+              "(#{inputs[0] ? inputs[0].name : "self"} += #{auto_math(inputs[1], name_only, 1)})"
             when :assign
-              "(#{inputs[0] ? inputs[0].name : 'self'} = #{auto_math(inputs[1], name_only, 1)})"
+              "(#{inputs[0] ? inputs[0].name : "self"} = #{auto_math(inputs[1], name_only, 1)})"
             when :sin, :cos, :tanh
               "#{operation}(#{sub_input})"
             when :add
@@ -193,7 +193,7 @@ module TensorStream
             when :ones_like
               "ones_like(#{sub_input})"
             when :flow_group
-              "flow_group(#{inputs.collect { |i| auto_math(i, name_only, max_depth - 1, cur_depth) }.join(',')})"
+              "flow_group(#{inputs.collect { |i| auto_math(i, name_only, max_depth - 1, cur_depth) }.join(",")})"
             when :zeros
               "zeros(#{sub_input})"
             when :reshape
@@ -243,8 +243,8 @@ module TensorStream
             else
               "#{operation}(#{sub_input})" if sub_input
               "#{operation}(#{sub_input}, #{sub_input2})" if sub_input && sub_input2
-            end
-      ["\n", Array.new(cur_depth + 1) { ' ' }, out].flatten.join
+      end
+      ["\n", Array.new(cur_depth + 1) { " " }, out].flatten.join
     end
 
     def run
@@ -260,21 +260,21 @@ module TensorStream
     def serialize_options
       excludes = %i[internal_name source]
 
-      @options.reject { |k, v| excludes.include?(k) || v.nil? }.map do |k, v|
+      @options.reject { |k, v| excludes.include?(k) || v.nil? }.map { |k, v|
         v = case v.class.to_s
-            when 'TensorStream::TensorShape'
+            when "TensorStream::TensorShape"
               v.shape
-            when 'Array'
+            when "Array"
               v
-            when 'String', 'Integer', 'Float', 'Symbol', 'FalseClass', "TrueClass"
+            when "String", "Integer", "Float", "Symbol", "FalseClass", "TrueClass"
               v
-            when 'TensorStream::Variable'
-              { name: v.name, options: v.options, shape: v.shape.shape.dup }
+            when "TensorStream::Variable"
+              {name: v.name, options: v.options, shape: v.shape.shape.dup}
             else
               raise "unknown type #{v.class}"
-            end
+        end
         [k.to_sym, v]
-      end.to_h
+      }.to_h
     end
 
     def add_consumer(consumer)

data/lib/tensor_stream/ops.rb

@@ -1,6 +1,12 @@
+
 module TensorStream
   # Class that defines all available ops supported by TensorStream
   module Ops
+    if File.exists?(File.join(__dir__, 'generated_stub', 'ops.rb'))
+      require 'tensor_stream/generated_stub/ops'
+      include TensorStream::OpStub
+    end
+
     class OutputHolder
       def initialize(op)
         @op = op
@@ -10,30 +16,6 @@ module TensorStream
     INTEGER_TYPES = %i[uint8 int32 int int16 uint16 int64 uint32 uint64].freeze
     NUMERIC_TYPES = FLOATING_POINT_TYPES + INTEGER_TYPES
 
-    ##
-    # Returns the index with the largest value across axes of a tensor.
-    #
-    # Argmuments
-    #
-    # +input+ A Tensor. Must be one of the following types: float32, float64, int32, int16
-    # +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, axis, name: name, dimension: dimension, data_type: output_type)
-    end
-
-    ##
-    # Returns the index with the smallest value across axes of a tensor.
-    #
-    # Argmuments
-    #
-    # +input+ A Tensor. Must be one of the following types: float32, float64, int32, int16
-    # +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, axis, name: name, dimension: dimension, data_type: output_type)
-    end
-
     ##
     # Assert the condition x == y holds element-wise.
     #
@@ -57,46 +39,39 @@ module TensorStream
     # +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(tensor_ys, wrt_xs, name: 'gradients', stop_gradients: nil)
+    def gradients(tensor_ys, wrt_xs, name: "gradients", stop_gradients: nil)
       tensor_ys = tensor_ys.op
-      gs = wrt_xs.map(&:op).collect do |x|
-        stops = stop_gradients ? stop_gradients.map(&:name).join('_') : ''
+      gs = wrt_xs.map(&:op).collect { |x|
+        stops = stop_gradients ? stop_gradients.map(&:name).join("_") : ""
         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_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
+      }
 
       gs
     end
 
-    ##
-    # Outputs random values from a uniform distribution.
-    def random_uniform(shape, dtype: :float32, minval: 0, maxval: 1, seed: nil, name: nil)
-      options = { dtype: dtype, minval: minval, maxval: maxval, seed: seed, name: name }
-      _op(:random_uniform, shape, 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 = { dtype: dtype, mean: mean, stddev: stddev, seed: seed, name: name }
+      options = {dtype: dtype, mean: mean, stddev: stddev, seed: seed, name: name}
       _op(:random_standard_normal, shape, options)
     end
 
     ##
     # Outputs random values from a truncated normal distribution.
     def truncated_normal(shape, dtype: :float32, mean: 0.0, stddev: 1.0, seed: nil, name: nil)
-      options = { dtype: dtype, mean: mean, stddev: stddev, seed: seed, name: name }
+      options = {dtype: dtype, mean: mean, stddev: stddev, seed: seed, name: name}
       _op(:truncated_normal, shape, options)
     end
 
@@ -118,14 +93,6 @@ module TensorStream
       _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)
-      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}_c") if shape_full_specified(input)
-
-      _op(:shape, input, name: name, out_type: out_type)
-    end
 
     def shape_n(inputs, name: nil, out_type: :int32)
       shapes_known = true
@@ -146,29 +113,6 @@ module TensorStream
       end
     end
 
-    ##
-    # 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].
-    def tile(input, multiples, name: nil)
-      _op(:tile, input, multiples, name: name)
-    end
-
-    ##
-    # Returns the rank of a tensor.
-    def rank(input, name: nil)
-      input = convert_to_tensor(input)
-      return cons(input.shape.ndims) if input.shape.known?
-
-      _op(:rank, input, name: name)
-    end
-
-    def constant_initializer(value, dtype: nil, verify_shape: false)
-      TensorStream::Initializer.new(-> { _op(:fill, nil, convert_to_tensor(value, dtype: dtype)) })
-    end
-
     ##
     # initializer that generates tensors initialized to 0.
     #
@@ -183,6 +127,10 @@ module TensorStream
       TensorStream::Initializer.new(-> { _op(:ones, data_type: dtype) })
     end
 
+    def constant_initializer(value, dtype: nil, verify_shape: false)
+      TensorStream::Initializer.new(-> { _op(:fill, nil, convert_to_tensor(value, dtype: dtype)) })
+    end
+
     ##
     # The Glorot uniform initializer, also called Xavier uniform initializer.
     #
@@ -209,119 +157,45 @@ module TensorStream
       _op(:slice, input, start, size: size, name: name)
     end
 
-    ##
-    # Creates a tensor with all elements set to zero
-    def zeros(shape, dtype: :float32, name: nil)
-      _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, data_type: dtype, name: name)
     end
 
-    ##
-    # Returns element-wise largest integer not greater than x.
-    def floor(input, name: nil)
-      check_allowed_types(input, FLOATING_POINT_TYPES)
-      _op(:floor, input, name: name)
-    end
-
-    ##
-    # Returns element-wise smallest integer in not less than x
-    def ceil(input, name: nil)
-      check_allowed_types(input, FLOATING_POINT_TYPES)
-      _op(:ceil, input, name: name)
-    end
-
     ##
     # Returns the truth value of (x < y) element-wise.
     # This operation supports broadcasting
     def less(input_a, input_b, name: nil)
-      input_a, input_b = check_data_types(input_a, input_b)
+      check_data_types(input_a, input_b)
       _op(:less, input_a, input_b, name: name)
     end
 
     ##
     # Returns the truth value of x AND y element-wise.
     def logical_and(input_a, input_b, name: nil)
-      input_a, input_b = check_data_types(input_a, input_b)
+      check_data_types(input_a, input_b)
       _op(:logical_and, input_a, input_b, name: name)
     end
 
-    ##
-    # Returns the truth value of (x > y) element-wise.
-    # This operation supports broadcasting
-    def greater(input_a, input_b, name: nil)
-      input_a, input_b = check_data_types(input_a, input_b)
-      _op(:greater, input_a, input_b, name: name)
-    end
-
-    ##
-    # 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)
-      _op(:greater_equal, input_a, input_b, name: name)
-    end
-
-    ##
-    # Returns the truth value of (x <= y) element-wise.
-    def less_equal(input_a, input_b, name: nil)
-      input_a, input_b = check_data_types(input_a, input_b)
-      _op(:less_equal, input_a, input_b, name: name)
-    end
-
     ##
     # Computes the mean of elements across dimensions of a tensor.
     def reduce_mean(input_tensor, axis = nil, keepdims: false, name: nil)
       reduce(: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.
-    def reduce_sum(input_tensor, axis = nil, keepdims: false, name: nil)
-      reduce(:sum, input_tensor, axis, keepdims: keepdims, name: name)
-    end
-
-    ##
-    # 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.
-    #
-    # 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)
-      reduce(:prod, input, axis, keepdims: keepdims, name: name)
-    end
-
     def reduce(op, input, axis = nil, keepdims: false, name: nil)
       input = TensorStream.convert_to_tensor(input)
-      axis = if !axis.nil?
-               axis
-             elsif input.shape.scalar?
-               op
-             elsif input.shape.known?
-               (0...input.shape.ndims).to_a
-             else
-               range(0, rank(input))
-             end
+      return input if input.shape.scalar?
+
+      axis = cast_axis(input, axis)
 
       _op(op, input, axis, keepdims: keepdims, name: name)
     end
 
     ##
     # Concatenates tensors along one dimension.
-    def concat(values, axis, name: 'concat')
+    def concat(values, axis, name: "concat")
       if values.is_a?(Array)
         _op(:concat, axis, *values, name: name)
       else
@@ -329,7 +203,7 @@ module TensorStream
       end
     end
 
-    def split(value, num_or_size_splits, axis: 0, num: nil, name: 'split')
+    def split(value, num_or_size_splits, axis: 0, num: nil, name: "split")
       value = convert_to_tensor(value)
       num_or_size_splits = convert_to_tensor(num_or_size_splits)
       axis = convert_to_tensor(axis)
@@ -339,33 +213,33 @@ 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
-                    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"
-                end
-               else
-                 raise TensorStream::ValueError, "Cannot automatically determine num, please specify num: in options" if num.nil?
-
-                 Array.new(num) { nil }
-               end
+        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
+        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"
+        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}")
@@ -395,13 +269,6 @@ module TensorStream
       _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, name: name)
-    end
-
     ##
     # Computes the reciprocal of x element-wise.
     def reciprocal(tensor, name: nil)
@@ -420,15 +287,6 @@ module TensorStream
       _op(:where, condition, true_t, false_t, name: name)
     end
 
-    ##
-    # Returns x + y element-wise.
-    #
-    # This operation supports broadcasting
-    def add(input_a, input_b, name: nil)
-      input_a, input_b = check_data_types(input_a, input_b)
-      _op(:add, input_a, input_b, name: name)
-    end
-
     ##
     # Adds all input tensors element-wise.
     #
@@ -458,53 +316,20 @@ module TensorStream
       _op(:atan, input, name: name)
     end
 
-    ##
-    # Returns x - y element-wise.
-    #
-    # This operation supports boradcasting
-    def sub(input_a, input_b, name: nil)
-      input_a, input_b = check_data_types(input_a, input_b)
-      _op(:sub, input_a, input_b, name: name)
-    end
-
-    ##
-    # Returns element-wise remainder of division.
-    def mod(input_a, input_b, name: nil)
-      input_a = convert_to_tensor(input_a)
-      input_b = convert_to_tensor(input_b)
-
-      input_a, input_b = check_data_types(input_a, input_b)
-       _op(:mod, input_a, input_b, name: name)
-    end
-
     ##
     # Returns element-wise integer divistion.
     def floor_div(input_a, input_b, name: nil)
-      input_a, input_b = check_data_types(input_a, input_b)
+      check_data_types(input_a, input_b)
       _op(:floor_div, input_a, input_b, name: name)
     end
 
-    def range(start, limit, delta = 1, dtype: nil, name: 'range')
-      _op(:range, start, limit, delta, data_type: dtype, name: name)
-    end
-
     ##
-    # Returns x - y element-wise.
-    #
-    # This operation supports boradcasting
-    def subtract(input_a, input_b, name: nil)
-      input_a, input_b = check_data_types(input_a, input_b)
-      sub(input_a, input_b, name: name)
-    end
-
-    ##
-    # Returns the max of x and y (i.e. x > y ? x : y) element-wise.
-    def max(input_a, input_b, name: nil)
-      check_allowed_types(input_a, NUMERIC_TYPES)
-      check_allowed_types(input_b, NUMERIC_TYPES)
+    # Casts a tensor to a new type, if needed
+    def cast(input, dtype, name: nil)
+      input = convert_to_tensor(input)
+      return input if input.data_type == dtype
 
-      input_a, input_b = check_data_types(input_a, input_b)
-      _op(:max, input_a, input_b, name: name)
+      _op(:cast, input, data_type: dtype, name: name)
     end
 
     ##
@@ -513,30 +338,12 @@ module TensorStream
       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)
-      _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
 
-    ##
-    # Casts a tensor to a new type, if needed
-    def cast(input, dtype, name: nil)
-      input = convert_to_tensor(input)
-      return input if input.data_type == dtype
-
-      _op(:cast, input, data_type: dtype, name: name)
-    end
-
     ##
     # Prints a list of tensors.
     #
@@ -545,30 +352,17 @@ module TensorStream
       _op(:print, input, data, message: message, name: name)
     end
 
-    ##
-    # Computes numerical negative value element-wise.
-    def negate(input, name: nil)
-      _op(:negate, input, name: name)
-    end
-
     ##
     # Computes numerical negative value element-wise.
     def negative(input, name: nil)
       negate(input, name: name)
     end
 
-    ##
-    # Returns the truth value of (x == y) element-wise.
-    def equal(input_a, input_b, name: nil)
-      input_a, input_b = check_data_types(input_a, input_b)
-      _op(:equal, input_a, input_b, name: name)
-    end
-
     ##
     # Returns the truth value of (x != y) element-wise.
     # This ops supports broadcasting
     def not_equal(input_a, input_b, name: nil)
-      input_a, input_b = check_data_types(input_a, input_b)
+      check_data_types(input_a, input_b)
       _op(:not_equal, input_a, input_b, name: name)
     end
 
@@ -600,33 +394,10 @@ module TensorStream
     # Returns x * y element-wise.
     # This operation supports broadcasting
     def multiply(input_a, input_b, name: nil)
-      input_a, input_b = check_data_types(input_a, input_b)
+      check_data_types(input_a, input_b)
       _op(:mul, input_a, input_b, name: name)
     end
 
-    ##
-    # Returns x * y element-wise.
-    # This operation supports broadcasting
-    def mul(input_a, input_b, name: nil)
-      input_a, input_b = check_data_types(input_a, input_b)
-      _op(:mul, input_a, input_b, name: name)
-    end
-
-    ##
-    # Divides x / y elementwise
-    # This operation supports broadcasting
-    def div(input_a, input_b, name: nil)
-      input_a, input_b = check_data_types(input_a, input_b)
-      _op(:div, input_a, input_b, name: name)
-    end
-
-    ##
-    # Computes the power of one value to another.
-    def pow(input_a, input_e, name: nil)
-      input_a, input_e = check_data_types(input_a, input_e)
-      _op(:pow, input_a, input_e, name: name)
-    end
-
     ##
     # Computes the absolute value of a tensor.
     def abs(input, name: nil)
@@ -634,42 +405,6 @@ module TensorStream
     end
 
     ##
-    # Returns an element-wise indication of the sign of a number.
-    # 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, name: name)
-    end
-
-    ##
-    # Computes sin of input element-wise.
-    def sin(input, name: nil)
-      check_allowed_types(input, FLOATING_POINT_TYPES)
-      _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, name: name)
-    end
-
-    ##
-    # Computes tan of input element-wise.
-    def tan(input, name: nil)
-      check_allowed_types(input, FLOATING_POINT_TYPES)
-      _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, name: name)
-    end
-
-        ##
     # Computes sec of input element-wise.
     def sec(input, name: nil)
       check_allowed_types(input, FLOATING_POINT_TYPES)
@@ -704,46 +439,16 @@ module TensorStream
       _op(:exp, input, name: name)
     end
 
-    ##
-    # Creates a tensor filled with a scalar value.
-    #
-    # This operation creates a tensor of shape dims and fills it with value.
-    #
-    # For example:
-    # Output tensor has shape [2, 3].
-    # fill([2, 3], 9) => [[9, 9, 9]
-    #                    [9, 9, 9]]
-    def fill(dims, value, name: nil)
-      _op(:fill, dims, value, name: name)
-    end
-
-    ##
-    # Computes sigmoid of x element-wise.
-    def sigmoid(input, name: nil)
-      check_allowed_types(input, FLOATING_POINT_TYPES)
-      _op(:sigmoid, input, name: name)
-    end
-
-    ##
-    # Multiplies matrix a by matrix b, producing a * b.
-    # The inputs must, following any transpositions, be tensors of rank 2 .
-    def matmul(input_a, input_b, transpose_a: false,
-               transpose_b: false,
-               name: nil)
-      input_a, input_b = check_data_types(input_a, input_b)
-      _op(:mat_mul, input_a, input_b, transpose_a: transpose_a, transpose_b: transpose_b, name: name)
-    end
-
     ##
     # Transposes a. Permutes the dimensions according to perm.
-    def transpose(tensor, perm = nil, name: 'transpose')
+    def transpose(tensor, perm = nil, name: "transpose")
       _op(:transpose, tensor, perm, name: name)
     end
 
     ##
     # Pads a tensor.
     # This operation pads a tensor according to the paddings you specify.
-    def pad(tensor, paddings, mode: 'CONSTANT', name: nil)
+    def pad(tensor, paddings, mode: "CONSTANT", name: nil)
       _op(:pad, tensor, paddings, mode: mode, name: name)
     end
 
@@ -754,10 +459,6 @@ module TensorStream
       _op(:check_numerics, tensor, message: message, name: name)
     end
 
-    def size(tensor, name: nil, out_type: :int32)
-      _op(:size, tensor, name: name, out_type: out_type)
-    end
-
     def squared_difference(input_a, input_b, name: nil)
       _op(:squared_difference, input_a, input_b, name: name)
     end
@@ -771,36 +472,36 @@ module TensorStream
     # Gather slices from params and axis according to indices.
     #
     def gather(params, indices, validate_indices: nil,
-                                name: nil,
-                                axis: 0)
+      name: nil,
+      axis: 0)
       _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.
     #
-    def stack(values, axis: 0, name: 'stack')
+    def stack(values, axis: 0, name: "stack")
       _op(:stack, *values, axis: axis, name: name)
     end
 
     ##
     # Unpacks the given dimension of a rank-R tensor into rank-(R-1) tensors.
     #
-    def unstack(value, num: nil, axis: 0, name: 'unstack')
+    def unstack(value, num: nil, axis: 0, name: "unstack")
       res = _op(:unstack, value, num: num, axis: axis, name: name)
 
       num_vars = if value.shape.known?
-                   new_shape = value.shape.shape.dup
-                   rank = new_shape.size - 1
-                   axis = rank + axis if axis < 0
-                   rotated_shape = Array.new(axis + 1) { new_shape.shift }
-                   new_shape = rotated_shape.rotate!(-1) + new_shape
-                   new_shape[0]
-                 else
-                   raise TensorStream::ValueError, "num is unspecified and cannot be inferred." if num.nil?
-
-                   num
-                 end
+        new_shape = value.shape.shape.dup
+        rank = new_shape.size - 1
+        axis = rank + axis if axis < 0
+        rotated_shape = Array.new(axis + 1) { new_shape.shift }
+        new_shape = rotated_shape.rotate!(-1) + new_shape
+        new_shape[0]
+      else
+        raise TensorStream::ValueError, "num is unspecified and cannot be inferred." if num.nil?
+
+        num
+      end
 
       return res[0] if num_vars == 1
 
@@ -811,14 +512,14 @@ module TensorStream
 
     ##
     # Same as stack
-    def pack(values, axis: 0, name: 'pack')
+    def pack(values, axis: 0, name: "pack")
       _op(:stack, *values, axis: axis, name: name)
     end
 
     ##
     # Same as unstack
     #
-    def unpack(value, num: nil, axis: 0, name: 'unpack')
+    def unpack(value, num: nil, axis: 0, name: "unpack")
       unstack(value, num: num, axis: axis, name: name)
     end
 
@@ -878,5 +579,15 @@ module TensorStream
     def invert_permutation(x, name: nil)
       _op(:invert_permutation, x, name: name)
     end
+
+    def cast_axis(input, axis)
+      if !axis.nil?
+        axis
+      elsif input.shape.known?
+        (0...input.shape.ndims).to_a
+      else
+        range(0, rank(input))
+      end
+    end
   end
 end