tensor_stream 0.3.0 → 0.4.0

data/lib/tensor_stream/evaluator/opencl_template_helper.rb

@@ -4,8 +4,18 @@ class OpenclTemplateHelper
     @source = source
   end
 
-  def generate
-    ERB.new(@source, nil, '%').result(binding)
+  def generate(args = {})
+    current_scope = binding
+
+    args.each do |k, v|
+      current_scope.local_variable_set(k.to_sym, v)
+    end
+
+    ERB.new(@source, nil, '%').result(current_scope)
+  end
+
+  def is_floating_point?(dtype)
+    TensorStream::Ops::FLOATING_POINT_TYPES.include?(dtype)
   end
 
   def render(template, locals = {})
@@ -19,11 +29,36 @@ class OpenclTemplateHelper
   end
 
   def dtype_to_c_type(dtype)
-    case(dtype)
-    when 'fp'
+    case(dtype.to_s)
+    when 'float64'
+      'double'
+    when 'float32', 'float'
       'float'
-    when 'int'
+    when 'int32', 'int'
       'int'
+    when 'int16'
+      'short'
+    when 'boolean'
+      'int'
+    else
+      raise "unknown dtype #{dtype}"
+    end
+  end
+
+  def min_value_for(dtype)
+    case(dtype.to_s)
+    when 'float64'
+      'DBL_MIN'
+    when 'float32', 'float'
+      'FLT_MIN'
+    when 'int32', 'int'
+      'INT_MIN'
+    when 'int16'
+      'SHRT_MIN'
+    when 'boolean'
+      '0'
+    else
+      raise "unknown dtype #{dtype}"
     end
   end
 

data/lib/tensor_stream/evaluator/operation_helpers/array_ops_helper.rb

@@ -2,6 +2,7 @@ module TensorStream
   # varoius utility functions for array processing
   module ArrayOpsHelper
     def slice_tensor(input, start, size)
+      return input if size.empty?
       start_index = start.shift
       dimen_size = start_index + size.shift
 
@@ -164,5 +165,39 @@ module TensorStream
 
       get_rank(value[0], rank + 1)
     end
+
+    def softmax(arr)
+      return arr if arr.empty?
+
+      sum = if !arr[0].is_a?(Array)
+        arr.map { |a| Math.exp(a - arr.max) }.reduce(:+)
+      end
+
+      arr.collect do |item|
+        if item.is_a?(Array)
+          softmax(item)
+        else
+          Math.exp(item - arr.max) / sum
+        end
+      end
+    end
+
+    def softmax_grad(arr)
+      return arr if arr.empty?
+
+      arr.each_with_index.collect do |item, index|
+        if item.is_a?(Array)
+          softmax_grad(item)
+        else
+          arr.each_with_index.collect do |item2, index2|
+            if index != index2
+              -item * item2
+            else
+              item * (1.0 - item)
+            end
+          end
+        end
+      end
+    end
   end
 end

data/lib/tensor_stream/evaluator/ruby_evaluator.rb

@@ -41,7 +41,9 @@ module TensorStream
       end
 
       def run(tensor, execution_context)
-        return tensor.map { |t| run(t, execution_context) } if tensor.is_a?(Array)
+        if tensor.is_a?(Array) && tensor.size > 0 && tensor[0].is_a?(Tensor)
+          return tensor.map { |t| run(t, execution_context) }
+        end
 
         return tensor if retain.include?(tensor) # if var is in retain don't eval to value
 
@@ -89,10 +91,9 @@ module TensorStream
 
       def eval_operation(tensor, child_context)
         return @context[tensor.name] if @context.key?(tensor.name)
-
         a = resolve_placeholder(tensor.items[0], child_context) if tensor.items && tensor.items[0]
         b = resolve_placeholder(tensor.items[1], child_context) if tensor.items && tensor.items[1]
-
+        # puts tensor.name
         case tensor.operation
         when :const
           complete_eval(a, child_context)
@@ -459,6 +460,26 @@ module TensorStream
 
           tile = tile_arr(input, 0, multiples)
           tile.nil? ? [] : tile
+        when :softmax
+          input = complete_eval(a, child_context)
+          softmax(input)
+        when :softmax_grad
+          input = complete_eval(a, child_context)
+          grad = complete_eval(b, child_context)
+          softmax_input = softmax(input)
+          f_grad = softmax_grad(softmax_input)
+          f_grad.transpose.each_with_index.collect do |row, index|
+            sum = 0.0
+            row.each_with_index do |r, g_index|
+              sum += r * grad[g_index]
+            end
+            sum
+          end
+        when :check_numerics
+          a = complete_eval(a, child_context)
+          message = tensor.options[:message]
+          f = ->(t, _b) { raise  "#{message} Invalid argument" if t.nan? || t.infinite?; t }
+          call_op(:check_numerics, a, child_context, f)
         else
           raise "unknown op #{tensor.operation}"
         end.tap do |result|
@@ -486,19 +507,19 @@ module TensorStream
         puts e.message
         puts e.backtrace.join("\n")
 
-        shape_a = a.shape.shape if a
-        shape_b = b.shape.shape if b
-        dtype_a = a.data_type if a
-        dtype_b = b.data_type if b
+        # shape_a = a.shape.shape if a
+        # shape_b = b.shape.shape if b
+        # dtype_a = a.data_type if a
+        # dtype_b = b.data_type if b
         a = complete_eval(a, child_context)
         b = complete_eval(b, child_context)
+
         # puts "name: #{tensor.given_name}"
         # # puts "op: #{tensor.to_math(true, 1)}"
         # puts "A #{shape_a} #{dtype_a}: #{a}" if a
         # puts "B #{shape_b} #{dtype_b}: #{b}" if b
         # dump_intermediates if @log_intermediates
         # File.write('/home/jedld/workspace/tensor_stream/samples/error.graphml', TensorStream::Graphml.new.get_string(tensor, @session))
-
         # File.write('/Users/josephemmanueldayo/workspace/gradients.graphml', TensorStream::Graphml.new.get_string(tensor, @session))
         raise EvaluatorExcecutionException.new(e, tensor), "error #{e.message} while evaluating #{tensor.name} : #{tensor.to_math(true,1)} defined at #{tensor.source}"
       end
@@ -741,7 +762,7 @@ module TensorStream
 
         v_a.each_with_index.collect do |v1, index|
           v2 = v_b[index]
-          v3 = v_c[index]
+          v3 = v_c.is_a?(Array) ? v_c[index] : v_c
           if v1.is_a?(Array)
             call_3way_vector_op(v1, v2, v3, child_context, op)
           else

data/lib/tensor_stream/graph_serializers/graphml.rb

@@ -101,7 +101,7 @@ module TensorStream
 
     def _val(tensor)
       # JSON.pretty_generate(@last_session_context[tensor.name])
-      @last_session_context[tensor.name]
+      @last_session_context[tensor.name] || @last_session_context[:_cache][tensor.name]
     end
 
     def to_graph_ml(tensor, arr_buf = [], added = {}, groups = {}, _id = 0)

data/lib/tensor_stream/graph_serializers/pbtext.rb

@@ -110,8 +110,12 @@ module TensorStream
       case type
       when :int32, :int
         "DT_INT32"
+      when :int16
+        "DT_INT16"
       when :float, :float32
         "DT_FLOAT"
+      when :float64
+        "DT_FLOAT64"
       when :string
         "DT_STRING"
       else

data/lib/tensor_stream/math_gradients.rb

@@ -127,11 +127,10 @@ module TensorStream
           sx = tf.shape(x)
           sy = tf.shape(y)
           rx, ry = _broadcast_gradient_args(sx, sy)
-          gx = tf.reshape(
-            tf.reduce_sum(grad * y * tf.pow(x, y - 1), rx), sx)
+          gx = tf.reduce_sum(grad * y * tf.pow(x, y - 1), rx)
 
           log_x = tf.where(x > 0, tf.log(x), tf.zeros_like(x))
-          gy = tf.reshape(tf.reduce_sum(grad * z * log_x, ry), sy)
+          gy = tf.reduce_sum(grad * z * log_x, ry)
 
           [gx, gy]
         when :abs
@@ -182,9 +181,11 @@ module TensorStream
           factor = _safe_shape_div(tf.reduce_prod(input_shape), tf.reduce_prod(output_shape))
           tf.div(sum_grad, tf.cast(factor, sum_grad.data_type))
         when :log1p
-          grad * tf.reciprocal(i_cons(1, data_type: grad.data_type) + x)
+          grad * tf.reciprocal(i_cons(1, dtype: grad.data_type) + x)
         when :sigmoid
           i_op(:sigmoid_grad, x, grad)
+        when :softmax
+          i_op(:softmax_grad, x, grad)
         when :zeros_like
           # non differentiable
           nil
@@ -210,7 +211,7 @@ module TensorStream
     end
 
     def self._sum_grad(x, y, grad)
-      tf.ones_like(x) * grad
+      tf.ones_like(grad) * grad
     end
 
     def self._op_supports_broadcast?(node)

data/lib/tensor_stream/nn/nn_ops.rb

@@ -1,14 +1,30 @@
 module TensorStream
   # High level machine learning functions
   class NN
-    def self.softmax(logits, _options = {})
-      TensorStream.exp(logits) / TensorStream.reduce_sum(TensorStream.exp(logits))
+    extend TensorStream::OpHelper
+    def self.softmax(logits, axis: nil, name: nil)
+      _op(:softmax, logits, nil, axis: axis, name: name)
     end
 
     def self.relu(features, name: nil)
       TensorStream.max(features, 0, name: "relu_#{name}")
     end
 
+    def self.sigmoid(input, name: nil)
+      TensorStream.sigmoid(input, name)
+    end
+
+    def self.softmax_cross_entropy_with_logits(labels: nil, logits: nil, name: nil)
+      TensorStream.name_scope(name, default: 'softmax_cross_entropy_with_logits', values: [logits, labels]) do |name|
+        tf = TensorStream
+        logits = tf.convert_to_tensor(logits, name: 'logits')
+        labels = tf.convert_to_tensor(labels, name: 'labels')
+        labels = tf.cast(labels, logits.dtype)
+        softmax_logits = -tf.log(softmax(logits)) * labels
+        tf.reduce_sum(softmax_logits, tf.rank(logits) - 1)
+      end
+    end
+
     def self.sigmoid_cross_entropy_with_logits(labels: nil, logits: nil, name: nil)
       TensorStream.name_scope(name, default: 'logistic_loss', values: [logits, labels]) do |name|
         tf = TensorStream

data/lib/tensor_stream/ops.rb

@@ -5,32 +5,52 @@ module TensorStream
     INTEGER_TYPES = %i[int32 int int64].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, nil, axis: 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, nil, axis: axis, name: name, dimension: dimension, data_type: output_type)
     end
 
-    def gradients(input, wrt_xs, grad_ys: nil,
-      name: 'gradients',
-      colocate_gradients_with_ops: false,
-      gate_gradients: false,
-      aggregation_method: nil,
-      stop_gradients: nil)
+    ##
+    # Constructs symbolic derivatives of ys of input w.r.t. x in wrt_xs.
+    #
+    # 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.
+    # +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)
 
       gs = wrt_xs.collect do |x|
         stops = stop_gradients ? stop_gradients.map(&:name).join('_') : ''
-        gradient_program_name = "grad_#{input.name}_#{x.name}_#{stops}".to_sym
+        gradient_program_name = "grad_#{ys.name}_#{x.name}_#{stops}".to_sym
 
-        tensor_program = if input.graph.node_added?(gradient_program_name)
-                          input.graph.get_node(gradient_program_name)
+        tensor_program = if ys.graph.node_added?(gradient_program_name)
+                          ys.graph.get_node(gradient_program_name)
                         else
-                          input.graph.name_scope("gradient_wrt_#{x.name}") do
-                            derivative_ops = TensorStream::MathGradients.derivative(input, x, graph: input.graph,
+                          ys.graph.name_scope("gradient_wrt_#{x.name}") do
+                            derivative_ops = TensorStream::MathGradients.derivative(ys, x, graph: ys.graph,
                               stop_gradients: stop_gradients)
-                            input.graph.add_node!(gradient_program_name, derivative_ops)
+                            ys.graph.add_node!(gradient_program_name, derivative_ops)
                           end
                         end
         tensor_program
@@ -38,272 +58,445 @@ module TensorStream
       TensorStream.group(gs)
     end
 
+    ##
+    # 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)
     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_normal, nil, nil, options)
     end
 
+    ##
+    # Stops gradient computation.
+    #
+    # When executed in a graph, this op outputs its input tensor as-is.
     def stop_gradient(tensor, options = {})
       _op(:stop_gradient, tensor, nil, options)
     end
 
+    ##
+    # Construct an identity matrix
     def eye(num_rows, num_columns: nil, dtype: :float32, name: nil)
       _op(:eye, num_rows, num_columns || num_rows, data_type: dtype, name: name)
     end
 
+    ##
+    # This operation returns a 1-D integer tensor representing the shape of input
     def shape(input, name: nil, out_type: :int32)
       _op(:shape, input, nil, name: name, out_type: out_type)
     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)
       _op(:rank, input, name: name)
     end
 
-    def zeros_initializer(options = {})
-      _op(:zeros, nil, nil, options)
+    ##
+    # initializer that generates tensors initialized to 0.
+    def zeros_initializer(dtype: nil)
+      TensorStream::Initializer.new(-> { _op(:zeros, nil, nil, data_type: dtype) })
     end
 
-    def glorot_uniform_initializer(seed: nil, dtype: :float32)
+    ##
+    # 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.
+    def glorot_uniform_initializer(seed: nil, dtype: nil)
       TensorStream::Initializer.new(-> { _op(:glorot_uniform, nil, nil, seed: seed, data_type: dtype) })
     end
 
+    ##
+    # Initializer that generates tensors with a uniform distribution.
     def random_uniform_initializer(minval: 0, maxval: 1, seed: nil, dtype: nil)
       TensorStream::Initializer.new(-> { _op(:random_uniform, nil, nil, minval: 0, maxval: 1, seed: seed, data_type: dtype) })
     end
 
+    ##
+    # 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.
     def slice(input, start, size, name: nil)
       _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, nil, 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)
     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)
       _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)
       _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)
       _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.
     def reduce_sum(input_tensor, axis = nil, keepdims: false, name: nil)
       _op(: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)
       _op(:prod, input, axis, keepdims: keepdims, name: name)
     end
 
+    ##
+    # Concatenates tensors along one dimension.
     def concat(values, axis, name: 'concat')
       _op(:concat, values, nil, axis: axis, name: name)
     end
 
+    ##
+    # Reshapes a tensor.
+    #
+    # Given tensor, this operation returns a tensor that has the same values as tensor with shape shape.
     def reshape(tensor, shape, name: nil)
       _op(:reshape, tensor, shape, name: name)
     end
 
+    ##
+    # Computes square of x element-wise.
     def square(tensor, name: nil)
       _op(:square, tensor, nil, 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)
     end
 
+    ##
+    # Computes the reciprocal of x element-wise.
     def reciprocal(tensor, name: nil)
       _op(:reciprocal, tensor, nil, name: name)
     end
 
+    ##
+    # Return true_fn() if the predicate pred is true else false_fn().
     def cond(pred, true_fn, false_fn, name: nil)
       _op(:cond, true_fn, false_fn, pred: pred, name: name)
     end
 
+    ##
+    # Return the elements, either from x or y, depending on the condition.
     def where(condition, true_t = nil, false_t = nil, name: nil)
       _op(:where, true_t, false_t, pred: condition, 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
 
+    ##
+    # 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 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)
-
+      input_a, input_b = check_data_types(input_a, input_b)
       _op(:max, input_a, input_b, name: name)
     end
 
+    ##
+    # Returns the max of x and y (i.e. x > y ? x : y) element-wise.
     def maximum(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)
     end
-  
+
+    ##
+    # Casts a tensor to a new type.
     def cast(input, dtype, name: nil)
       _op(:cast, input, nil, data_type: dtype, name: name)
     end
 
+    ##
+    # Prints a list of tensors.
+    #
+    # This is an identity op (behaves like tf.identity) with the side effect of printing data when evaluating.
     def print(input, data, message: nil, name: nil)
       _op(:print, input, data, message: message, name: name)
     end
 
+    ##
+    # Computes numerical negative value element-wise.
     def negate(input, name: nil)
       _op(:negate, input, nil, 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)
       _op(:not_equal, input_a, input_b, name: name)
     end
 
+    ##
+    # 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.
     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.
     def ones_like(tensor, dtype: nil, name: nil)
       _op(:ones_like, tensor, nil, 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)
     end
 
+    ##
+    # 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)
       _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)
       _op(:abs, input, nil, name: name)
     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, nil, name: name)
     end
 
-    def sin(input, options = {})
-      options[:data_type] ||= :float32
+    ##
+    # Computes sin of input element-wise.
+    def sin(input, name: nil)
       check_allowed_types(input, FLOATING_POINT_TYPES)
-      _op(:sin, input, nil, options)
+      _op(:sin, input, nil, name: name)
     end
 
-    def cos(input, options = {})
-      options[:data_type] ||= :float32
+    ##
+    # Computes cos of input element-wise.
+    def cos(input, name: nil)
       check_allowed_types(input, FLOATING_POINT_TYPES)
-      _op(:cos, input, nil, options)
+      _op(:cos, input, nil, name: name)
     end
 
-    def tan(input, options = {})
-      options[:data_type] ||= :float32
+    ##
+    # Computes tan of input element-wise.
+    def tan(input, name: nil)
       check_allowed_types(input, FLOATING_POINT_TYPES)
-      _op(:tan, input, nil, options)
+      _op(:tan, input, nil, name: name)
     end
 
-    def tanh(input, options = {})
-      options[:data_type] ||= :float32
+    ##
+    # Computes tanh of input element-wise.
+    def tanh(input, name: nil)
       check_allowed_types(input, FLOATING_POINT_TYPES)
-      _op(:tanh, input, nil, options)
+      _op(:tanh, input, nil, name: name)
     end
 
+    ##
+    # Computes sqrt of input element-wise.
     def sqrt(input, name: nil)
-      options = {
-        data_type: input.data_type,
-        name: name
-      }
       check_allowed_types(input, FLOATING_POINT_TYPES)
-      _op(:sqrt, input, nil, options)
+      _op(:sqrt, input, nil, name: name)
     end
 
-    def log(input, options = {})
-      options[:data_type] ||= :float32
+    ##
+    # Computes natural logarithm of x element-wise.
+    def log(input, name: nil)
       check_allowed_types(input, FLOATING_POINT_TYPES)
-      _op(:log, input, nil, options)
+      _op(:log, input, nil, name: name)
     end
-      
-    def log1p(input, options = {})
-      options[:data_type] ||= :float32
+
+    ##
+    # Computes natural logarithm of (1 + x) element-wise.
+    def log1p(input, name: nil)
       check_allowed_types(input, FLOATING_POINT_TYPES)
-      _op(:log1p, input, nil, options)
+      _op(:log1p, input, nil, name: name)
     end
 
-    def exp(input, options = {})
-      options[:data_type] ||= :float32
+    ##
+    # Computes exponential of x element-wise.
+    def exp(input, name: nil)
       check_allowed_types(input, FLOATING_POINT_TYPES)
-      _op(:exp, input, nil, options)
+      _op(:exp, input, nil, name: name)
     end
 
+    ##
+    # Computes sigmoid of x element-wise.
     def sigmoid(input, name: nil)
       check_allowed_types(input, FLOATING_POINT_TYPES)
       _op(:sigmoid, input, nil, 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(:matmul, 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')
       _op(:transpose, tensor, nil, perm: 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)
       _op(:pad, tensor, nil, paddings: 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)
+    end
   end
 end