tensor_stream 1.0.4 → 1.0.9

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

@@ -7,22 +7,20 @@ module TensorStream
           target_var, learning_rate, delta = inputs
           assign = tensor.inputs[0] || tensor
 
-          assign.container = process_vector_math_op(tensor, target_var, delta, context) { |t, u| t - u * learning_rate }
-          assign.container
+          var_assign_value(assign, process_vector_math_op(tensor, target_var, delta, context) { |t, u| t - u * learning_rate })
         end
 
         register_op :apply_momentum do |_context, tensor, inputs|
           target_var, momentum_var, learning_rate, grad, momentum = inputs
           assign = tensor.inputs[0] || tensor
           assign_acc = tensor.inputs[1]
-          assign_acc.container = multi_array_op(->(t, u) { t * momentum + u }, momentum_var, grad)
-          assign.container = if tensor.options[:use_nesterov]
-            multi_array_op(->(v, g, acc) { v - (g * learning_rate + acc * momentum * learning_rate) }, target_var, grad, momentum_var)
-          else
-            multi_array_op(->(v, acc) { v - acc * learning_rate }, target_var, momentum_var)
-          end
-
-          assign.container
+          var_assign_value(assign_acc, multi_array_op(->(t, u) { t * momentum + u }, momentum_var, grad))
+          var = if tensor.options[:use_nesterov]
+                  multi_array_op(->(v, g, acc) { v - (g * learning_rate + acc * momentum * learning_rate) }, target_var, grad, momentum_var)
+                else
+                  multi_array_op(->(v, acc) { v - acc * learning_rate }, target_var, momentum_var)
+                end
+          var_assign_value(assign, var)
         end
 
         register_op :apply_adadelta do |_context, tensor, inputs|
@@ -30,19 +28,18 @@ module TensorStream
           assign = tensor.inputs[0] || tensor
           assign_acc = tensor.inputs[1]
           assign_acc_update = tensor.inputs[2]
-          assign_acc.container = multi_array_op(->(acc_t, grad_t) { acc_t * rho + (grad_t * grad_t) * (1.0 - rho) }, accum, grad)
-          update = multi_array_op(->(acc_update_t, acc_t, grad_t) { Math.sqrt(acc_update_t + epsilon) * (1.0 / Math.sqrt(acc_t + epsilon)) * grad_t }, accum_update, assign_acc.container, grad)
-          assign.container = multi_array_op(->(v, u) { v - (u * lr) }, target_var, update)
-          assign_acc_update.container = multi_array_op(->(acc_update_t, u) { acc_update_t * rho + (u * u) * (1.0 - rho) }, accum_update, update)
+          acc_val = var_assign_value(assign_acc, multi_array_op(->(acc_t, grad_t) { acc_t * rho + (grad_t * grad_t) * (1.0 - rho) }, accum, grad))
+          update = multi_array_op(->(acc_update_t, acc_t, grad_t) { Math.sqrt(acc_update_t + epsilon) * (1.0 / Math.sqrt(acc_t + epsilon)) * grad_t }, accum_update, acc_val, grad)
+          result = var_assign_value(assign, multi_array_op(->(v, u) { v - (u * lr) }, target_var, update))
+          var_assign_value(assign_acc_update,multi_array_op(->(acc_update_t, u) { acc_update_t * rho + (u * u) * (1.0 - rho) }, accum_update, update))
 
-          assign.container
+          result
         end
 
         register_op :apply_adagrad do |_context, tensor, inputs|
           target_var, accum, lr, grad = inputs
           assign = tensor.inputs[0] || tensor
-          assign.container = multi_array_op(->(v, a, g) { v - (g * lr * (1.0 / Math.sqrt(a))) }, target_var, accum, grad)
-          assign.container
+          var_assign_value(assign, multi_array_op(->(v, a, g) { v - (g * lr * (1.0 / Math.sqrt(a))) }, target_var, accum, grad))
         end
 
         register_op :apply_adam do |_context, tensor, inputs|
@@ -52,10 +49,9 @@ module TensorStream
           assign_m = tensor.inputs[1]
           assign_v = tensor.inputs[2]
 
-          assign_m.container = multi_array_op(->(u_d, g) { u_d + (g - u_d) * (1.0 - beta1_t) }, m, grad)
-          assign_v.container = multi_array_op(->(u_d, v_d) { u_d + (v_d**2 - u_d) * (1.0 - beta2_t)}, v, grad)
-          assign.container = multi_array_op(->(t, m_d, v_d) { t - ((m_d * alpha) / (Math.sqrt(v_d) + epsilon_t)) }, target_var, assign_m.container, assign_v.container)
-          assign.container
+          m_val = var_assign_value(assign_m, multi_array_op(->(u_d, g) { u_d + (g - u_d) * (1.0 - beta1_t) }, m, grad))
+          v_val = var_assign_value(assign_v, multi_array_op(->(u_d, v_d) { u_d + (v_d**2 - u_d) * (1.0 - beta2_t)}, v, grad))
+          var_assign_value(assign, multi_array_op(->(t, m_d, v_d) { t - ((m_d * alpha) / (Math.sqrt(v_d) + epsilon_t)) }, target_var, m_val, v_val))
         end
 
         register_op :apply_rms_prop do |_context, tensor, inputs|
@@ -63,9 +59,9 @@ module TensorStream
           assign = tensor.inputs[0]
           assign_ms = tensor.inputs[1]
           assign_mom = tensor.inputs[2]
-          assign_ms.container = multi_array_op(->(g, m) { m + (g * g - m) * (1.0 - rho)}, grad, ms)
-          assign_mom.container = multi_array_op(->(mom_t, g, m) { mom_t * momentum + (g * lr) / Math.sqrt(m + epsilon)}, mom, grad, assign_ms.container)
-          assign.container = multi_array_op(->(v, m) { v - m }, var, assign_mom.container)
+          ms_val = var_assign_value(assign_ms, multi_array_op(->(g, m) { m + (g * g - m) * (1.0 - rho)}, grad, ms))
+          mom_val = var_assign_value(assign_mom, multi_array_op(->(mom_t, g, m) { mom_t * momentum + (g * lr) / Math.sqrt(m + epsilon)}, mom, grad, ms_val))
+          var_assign_value(assign, multi_array_op(->(v, m) { v - m }, var, mom_val))
         end
 
         register_op :apply_centered_rms_prop do |_context, tensor, inputs|
@@ -75,11 +71,11 @@ module TensorStream
           assign_ms = tensor.inputs[2]
           assign_mom = tensor.inputs[3]
 
-          assign_ms.container = multi_array_op(->(g, m) { m + (g * g - m) * (1.0 - rho) }, grad, ms)
-          assign_mg.container = multi_array_op(->(g, mg_t) {  (g - mg_t) * (1.0 - rho) }, grad, mg)
-          denom =  multi_array_op(->(s, mg_t) { (s - mg_t * mg_t) + epsilon }, assign_ms.container, mg)
-          assign_mom.container = multi_array_op(->(mom_t, g, d) { mom_t * momentum + (g * lr) / Math.sqrt(d)}, mom, grad, denom)
-          assign.container = multi_array_op(->(v, m) { v - m }, var, assign_mom.container)
+          val_ms = var_assign_value(assign_ms, multi_array_op(->(g, m) { m + (g * g - m) * (1.0 - rho) }, grad, ms))
+          var_assign_value(assign_mg, multi_array_op(->(g, mg_t) {  (g - mg_t) * (1.0 - rho) }, grad, mg))
+          denom =  multi_array_op(->(s, mg_t) { (s - mg_t * mg_t) + epsilon }, val_ms, mg)
+          val_mom = var_assign_value(assign_mom, multi_array_op(->(mom_t, g, d) { mom_t * momentum + (g * lr) / Math.sqrt(d)}, mom, grad, denom))
+          var_assign_value(assign, multi_array_op(->(v, m) { v - m }, var, val_mom))
         end
 
         register_op %i[softmax_cross_entropy_with_logits_v2 softmax_cross_entropy_with_logits] do |_context, tensor, inputs|

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

@@ -9,12 +9,12 @@ module TensorStream
 
           shape = tensor.options[:shape] || tensor.shape.shape
           fan_in, fan_out = if shape.size.zero?
-            [1, 1]
-          elsif shape.size == 1
-            [1, shape[0]]
-          else
-            [shape[0], shape.last]
-          end
+                              [1, 1]
+                            elsif shape.size == 1
+                              [1, shape[0]]
+                            else
+                              [shape[0], shape.last]
+                            end
 
           limit = Math.sqrt(6.0 / (fan_in + fan_out))
 
@@ -50,7 +50,7 @@ module TensorStream
           seed = tensor.options[:seed]
           random = _get_randomizer(tensor, seed)
           r = RandomGaussian.new(tensor.options.fetch(:mean), tensor.options.fetch(:stddev), -> { random.rand })
-          random = _get_randomizer(tensor, seed)
+
           generator = -> { r.rand }
           shape = inputs[0] || tensor.shape.shape
           random_values = Array.new(shape.reduce(:*) || 1) {
@@ -75,9 +75,6 @@ module TensorStream
 
           norm_min = (minval - mean) / stddev
           norm_max = (maxval - mean) / stddev
-          sqrt_factor = Math.sqrt((norm_min * norm_min) + 4.0)
-          cutoff = 2.0 * Math.exp(0.5 + (norm_min * (norm_min - sqrt_factor)) / 4.0) / (norm_min + sqrt_factor)
-          diff = norm_max - norm_min
 
           val = random_values.map { |v|
             iterations = 0
@@ -93,7 +90,6 @@ module TensorStream
 
             pick
           }
-
           TensorShape.reshape(val, shape)
         end
       end

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

@@ -0,0 +1,40 @@
+module TensorStream
+  class RubyStorageManager
+    def self.current_storage_manager
+      @storage_manager ||= RubyStorageManager.new
+    end
+
+    def initialize
+      @variables = {}
+    end
+
+    def exists?(graph, name)
+      return false if !@variables.key?(graph.object_id)
+
+      @variables[graph.object_id].key?(name.to_sym)
+    end
+
+    def create_variable(graph, name, value)
+      raise "no name specified" if name.nil?
+
+      @variables[graph.object_id][name.to_sym] = value
+    end
+
+    def assign_value(graph, name, value)
+      raise "no name specified" if name.nil?
+
+      @variables[graph.object_id] ||= {}
+      @variables[graph.object_id][name.to_sym] = value
+    end
+
+    def read_value(graph, name)
+      raise "no name specified" if name.nil?
+
+      @variables[graph.object_id][name.to_sym]
+    end
+
+    def clear_variables(graph)
+      @variables[graph.object_id] = {}
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module TensorStream
+  ## Collection of machine learning related ops
+  module VariableOps
+    def self.included(klass)
+      klass.class_eval do
+        register_op :variable_v2 do |_context, tensor, _inputs|
+          value = var_read_value(tensor)
+          raise "variable #{tensor.options[:var_name]} not initalized" if value.nil?
+
+          value
+        end
+
+        register_op :assign do |context, tensor, inputs|
+          var_assign_value(tensor, inputs[0])
+        end
+
+        register_op :assign_add, no_eval: true do |context, tensor, inputs|
+          current_val = var_read_value(tensor)
+
+          raise "variable #{tensor.options[:var_name]} not initialized" if current_val.nil?
+          eval_a, eval_b = broadcast(current_val, inputs[0])
+          result = multi_array_op(->(var, val) { var + val }, eval_a, eval_b)
+          var_assign_value(tensor, result)
+        end
+
+        register_op :assign_sub do |context, tensor, inputs|
+          current_val = var_read_value(tensor)
+          raise "variable #{tensor.options[:var_name]} not initialized" if current_val.nil?
+          eval_a, eval_b = broadcast(current_val, inputs[0])
+          result = multi_array_op(->(var, val) { var - val }, eval_a, eval_b)
+          var_assign_value(tensor, result)
+        end
+
+        register_op :save_ts do |_context, tensor, inputs|
+          outputfile = inputs[0]
+          inputs = tensor.inputs.dup
+
+          inputs.shift
+          variables = {}
+          inputs.each do |savable|
+            val = var_read_value(savable)
+
+            packed_data = Zlib::Deflate.deflate(TensorStream::Packer.pack(val, savable.data_type))
+            variables[savable.options[:var_name]] = {
+              "shape" => shape_eval(val),
+              "data" => Base64.strict_encode64(packed_data),
+            }
+          end
+
+          File.write(outputfile, {"variables" => variables}.to_yaml)
+          nil
+        end
+
+        register_op :restore_ts do |_context, tensor, inputs|
+          inputs = inputs.dup
+          filename = inputs.shift
+          tensor_names = inputs
+
+          input_dump = YAML.safe_load(File.read(filename), [Symbol])
+          vars = tensor.graph.get_collection(GraphKeys::GLOBAL_VARIABLES)
+          vars.select! { |v| input_dump["variables"].key?(v.name) && tensor_names.include?(v.name) }
+          vars.each do |variable|
+            data = TensorStream::Packer.unpack(Zlib::Inflate.inflate(Base64.decode64(input_dump["variables"][variable.name]["data"])), variable.data_type)
+            shape = input_dump["variables"][variable.name]["shape"]
+            variable.buffer = nil
+            var_assign_value(variable, TensorShape.reshape(data, shape))
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/tensor_stream/evaluator/ruby_evaluator.rb

@@ -2,12 +2,14 @@ require "tensor_stream/evaluator/operation_helpers/random_gaussian"
 require "tensor_stream/evaluator/operation_helpers/array_ops_helper"
 require "tensor_stream/evaluator/operation_helpers/math_helper"
 require "tensor_stream/evaluator/base_evaluator"
+require "tensor_stream/evaluator/ruby/storage_manager"
 require "tensor_stream/evaluator/ruby/math_ops"
 require "tensor_stream/evaluator/ruby/nn_ops"
 require "tensor_stream/evaluator/ruby/array_ops"
 require "tensor_stream/evaluator/ruby/random_ops"
 require "tensor_stream/evaluator/ruby/images_ops"
 require "tensor_stream/evaluator/ruby/check_ops"
+require "tensor_stream/evaluator/ruby/variable_ops"
 
 module TensorStream
   module Evaluator
@@ -41,6 +43,11 @@ module TensorStream
       include TensorStream::RandomOps
       include TensorStream::ImagesOps
       include TensorStream::CheckOps
+      include TensorStream::VariableOps
+
+      def self.get_storage_manager
+        RubyStorageManager.current_storage_manager
+      end
 
       def run(tensor, execution_context)
         return tensor.map { |t| run(t, execution_context) } if tensor.is_a?(Array) && !tensor.empty? && tensor[0].is_a?(Tensor)
@@ -49,12 +56,12 @@ module TensorStream
 
         child_context = execution_context.dup
         res = if tensor.is_a?(Operation)
-          eval_operation(tensor, child_context)
-        elsif !tensor.is_a?(Tensor)
-          tensor
-        else
-          tensor.op
-        end
+                eval_operation(tensor, child_context)
+              elsif !tensor.is_a?(Tensor)
+                tensor
+              else
+                tensor.op
+              end
         execution_context.deep_merge!(returns: child_context[:returns])
         res
       end
@@ -77,11 +84,23 @@ module TensorStream
           break unless tensor.is_a?(Tensor)
         end
 
-        tensor.is_a?(OutputGroup) ? tensor.outputs[0] : tensor
+        tensor.is_a?(OutputGroup) ? tensor.outputs : tensor
       end
 
       protected
 
+      def var_read_value(tensor)
+        @storage_manager ||= TensorStream::RubyStorageManager.current_storage_manager
+        @storage_manager.read_value(tensor.graph, tensor.options[:var_name])
+      end
+
+      def var_assign_value(tensor, value)
+        @storage_manager ||= TensorStream::RubyStorageManager.current_storage_manager
+        @storage_manager.assign_value(tensor.graph, tensor.options[:var_name] || tensor.name, value)
+
+        value
+      end
+
       def prepare_input(tensor, context, options = {})
         return nil unless tensor
 
@@ -154,37 +173,10 @@ module TensorStream
         end
       end
 
-      register_op :variable_v2, no_eval: true do |_context, tensor, _inputs|
-        value = tensor.options[:container].read_value
-        raise "variable #{tensor.options[:container].name} not initalized" if value.nil?
-
-        value
-      end
-
       register_op :stop_gradient, no_eval: true do |_context, _tensor, inputs|
         inputs[0]
       end
 
-      register_op :assign, noop: true do |context, tensor, _inputs|
-        assign = tensor.inputs[0] || tensor
-        assign.container = global_eval(tensor, tensor.inputs[1], context)
-        assign.container
-      end
-
-      register_op :assign_add, noop: true do |context, tensor, _inputs|
-        assign = tensor.inputs[0] || tensor
-
-        assign.container = process_vector_math_op(tensor, tensor.inputs[0], tensor.inputs[1], context) { |t, u| t + u }
-        assign.container
-      end
-
-      register_op :assign_sub, noop: true do |context, tensor, _inputs|
-        assign = tensor.inputs[0] || tensor
-
-        assign.container = process_vector_math_op(tensor, tensor.inputs[0], tensor.inputs[1], context) { |t, u| t - u }
-        assign.container
-      end
-
       register_op :less do |context, tensor, inputs|
         a, b = inputs
         call_vector_op(tensor, :less, a, b, context) { |t, u| t < u }
@@ -236,44 +228,6 @@ module TensorStream
         softmax(inputs[0])
       end
 
-      register_op :save_ts do |_context, tensor, inputs|
-        outputfile = inputs[0]
-        inputs = tensor.inputs.dup
-
-        inputs.shift
-        variables = {}
-        inputs.each do |savable|
-          val = savable.container
-          packed_data = Zlib::Deflate.deflate(TensorStream::Packer.pack(val, savable.data_type))
-          variables[savable.name] = {
-            "shape" => shape_eval(val),
-            "data" => Base64.strict_encode64(packed_data),
-          }
-        end
-
-        File.write(outputfile, {"variables" => variables}.to_yaml)
-        nil
-      end
-
-      register_op :restore_ts do |_context, tensor, inputs|
-        inputs = inputs.dup
-        filename = inputs.shift
-        tensor_names = inputs
-
-        input_dump = YAML.safe_load(File.read(filename), [Symbol])
-        vars = tensor.graph.get_collection(GraphKeys::GLOBAL_VARIABLES)
-
-        vars.select! { |v| input_dump["variables"].key?(v.name) && tensor_names.include?(v.name) }
-        vars.each do |variable|
-          data = TensorStream::Packer.unpack(Zlib::Inflate.inflate(Base64.decode64(input_dump["variables"][variable.name]["data"])), variable.data_type)
-          shape = input_dump["variables"][variable.name]["shape"]
-          variable.buffer = nil
-          variable.value = TensorShape.reshape(data, shape)
-        end
-
-        nil
-      end
-
       register_op :check_numerics do |context, tensor, inputs|
         message = tensor.options[:message]
         call_op(inputs[0], context) do |t, _b|
@@ -286,7 +240,7 @@ module TensorStream
       def eval_operation(tensor, child_context)
         return @context[tensor.name] if @context.key?(tensor.name)
 
-        # puts "ruby eval #{object_id}: #{tensor.name}"
+        # puts "ruby eval #{tensor.operation} -> #{object_id}: #{tensor.name}"
         invoke(tensor, child_context).tap do |result|
           # puts "result done ruby #{object_id}: #{tensor.name}"
           # assertions to make sure inferred shapes == actual evaluated shapes
@@ -314,10 +268,10 @@ module TensorStream
           @context[tensor.name] = result
         end
       rescue EvaluatorExcecutionException => e
-        raise e, "error #{e.message} while evaluating #{tensor.name}  defined at #{tensor.source}"
+        raise e, "error #{e.message} while evaluating #{tensor.name} defined at #{tensor.source}"
       rescue TensorStreamError => e
-        raise e, "error #{e.message} while evaluating #{tensor.name}  defined at #{tensor.source}"
-      rescue => e
+        raise e, "error #{e.message} while evaluating #{tensor.name} defined at #{tensor.source}"
+      rescue StandardError => e
         puts e.message
         puts e.backtrace.join("\n")
         raise EvaluatorExcecutionException.new(e, tensor), "error #{e.message} while evaluating #{tensor.name} : #{tensor.to_math(true, 1)} defined at #{tensor.source}"
@@ -379,7 +333,7 @@ module TensorStream
         elem = args[0]
         if elem.is_a?(Array)
           elem.each_with_index.collect do |_item, index|
-            indexed_args = args.collect { |a| a[index] }
+            indexed_args = args.collect { |a| a = a.is_a?(Array) ? a : [a]; a[index] }
             multi_array_op(func, *indexed_args)
           end
         else

data/lib/tensor_stream/generated_stub/ops.rb

@@ -9,12 +9,12 @@ module TensorStream
     #
     # This operation supports broadcasting
     #
-    # Params:
-    # +input_a+:: tensor X
-    # +input_b+:: tensor Y
+    # @param input_a tensor X
+    # @param input_b tensor Y
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def add(input_a, input_b, name: nil)
       input_a, input_b = apply_data_type_coercion(input_a, input_b)
       _op(:add, input_a, input_b, name: name)
@@ -25,14 +25,14 @@ module TensorStream
     # Returns the index with the largest value across axes of a tensor.
     #
     #
-    # Params:
-    # +input_a+:: tensor X (of type NUMERIC_TYPES)
-    # +axis+:: Describes which axis of the input tensor to reduce across. For vectors, use axis = 0 (of type INTEGER_TYPES)
+    # @param input_a tensor X (of type NUMERIC_TYPES)
+    # @param axis Describes which axis of the input tensor to reduce across. For vectors, use axis = 0 (of type INTEGER_TYPES)
     #
     # Options:
-    # +:name+:: Optional name
-    # +:dimension+:: Same as axis
-    # +:output_type+:: Output data type defaults to int32 default (:int32)
+    # @option name Optional name
+    # @option dimension Same as axis
+    # @option output_type Output data type defaults to int32 default (:int32)
+    # @return Tensor
     def argmax(input_a, axis = nil, name: nil, dimension: nil, output_type: :int32)
       check_allowed_types(input_a, TensorStream::Ops::NUMERIC_TYPES)
       check_allowed_types(axis, TensorStream::Ops::INTEGER_TYPES)
@@ -44,14 +44,14 @@ module TensorStream
     # Returns the index with the smallest value across axes of a tensor.
     #
     #
-    # Params:
-    # +input_a+:: tensor X (of type NUMERIC_TYPES)
-    # +axis+:: Describes which axis of the input tensor to reduce across. For vectors, use axis = 0 (of type INTEGER_TYPES)
+    # @param input_a tensor X (of type NUMERIC_TYPES)
+    # @param axis Describes which axis of the input tensor to reduce across. For vectors, use axis = 0 (of type INTEGER_TYPES)
     #
     # Options:
-    # +:name+:: Optional name
-    # +:dimension+:: Same as axis
-    # +:output_type+:: Output data type defaults to int32 default (:int32)
+    # @option name Optional name
+    # @option dimension Same as axis
+    # @option output_type Output data type defaults to int32 default (:int32)
+    # @return Tensor
     def argmin(input_a, axis = nil, name: nil, dimension: nil, output_type: :int32)
       check_allowed_types(input_a, TensorStream::Ops::NUMERIC_TYPES)
       check_allowed_types(axis, TensorStream::Ops::INTEGER_TYPES)
@@ -63,11 +63,11 @@ module TensorStream
     # Returns element-wise smallest integer in not less than x
     #
     #
-    # Params:
-    # +input_a+:: tensor X (of type FLOATING_POINT_TYPES)
+    # @param input_a tensor X (of type FLOATING_POINT_TYPES)
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def ceil(input_a, name: nil)
       check_allowed_types(input_a, TensorStream::Ops::FLOATING_POINT_TYPES)
       _op(:ceil, input_a, name: name)
@@ -78,11 +78,11 @@ module TensorStream
     # Computes cos of input element-wise.
     #
     #
-    # Params:
-    # +input_a+:: tensor X (of type FLOATING_POINT_TYPES)
+    # @param input_a tensor X (of type FLOATING_POINT_TYPES)
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def cos(input_a, name: nil)
       check_allowed_types(input_a, TensorStream::Ops::FLOATING_POINT_TYPES)
       _op(:cos, input_a, name: name)
@@ -94,12 +94,12 @@ module TensorStream
     #
     # This operation supports broadcasting
     #
-    # Params:
-    # +input_a+:: tensor X
-    # +input_b+:: tensor Y
+    # @param input_a tensor X
+    # @param input_b tensor Y
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def div(input_a, input_b, name: nil)
       input_a, input_b = apply_data_type_coercion(input_a, input_b)
       _op(:div, input_a, input_b, name: name)
@@ -111,12 +111,12 @@ module TensorStream
     #
     # This operation supports broadcasting
     #
-    # Params:
-    # +input_a+:: tensor X
-    # +input_b+:: tensor Y
+    # @param input_a tensor X
+    # @param input_b tensor Y
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def equal(input_a, input_b, name: nil)
       input_a, input_b = apply_data_type_coercion(input_a, input_b)
       _op(:equal, input_a, input_b, name: name)
@@ -129,12 +129,12 @@ module TensorStream
     # dimension index axis starts at zero; if you specify a negative number for axis it is counted backward from the end.
     #
     #
-    # Params:
-    # +input+:: A tensor
-    # +axis+:: Specifies the dimension index at which to expand the shape of input. Must be in the range [-rank(input) - 1, rank(input)].
+    # @param input A tensor
+    # @param axis Specifies the dimension index at which to expand the shape of input. Must be in the range [-rank(input) - 1, rank(input)].
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def expand_dims(input, axis, name: nil)
       _op(:expand_dims, input, axis, name: name)
     end
@@ -144,12 +144,12 @@ module TensorStream
     # This operation creates a tensor of shape dims and fills it with value.
     #
     #
-    # Params:
-    # +dims+:: tensor shape
-    # +value+:: scalar value to fill with
+    # @param dims tensor shape
+    # @param value scalar value to fill with
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def fill(dims, value, name: nil)
       _op(:fill, dims, value, name: name)
     end
@@ -159,11 +159,11 @@ module TensorStream
     # Returns element-wise largest integer not greater than x.
     #
     #
-    # Params:
-    # +input_a+:: tensor X (of type FLOATING_POINT_TYPES)
+    # @param input_a tensor X (of type FLOATING_POINT_TYPES)
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def floor(input_a, name: nil)
       check_allowed_types(input_a, TensorStream::Ops::FLOATING_POINT_TYPES)
       _op(:floor, input_a, name: name)
@@ -175,12 +175,12 @@ module TensorStream
     #
     # This operation supports broadcasting
     #
-    # Params:
-    # +input_a+:: tensor X
-    # +input_b+:: tensor Y
+    # @param input_a tensor X
+    # @param input_b tensor Y
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def floor_div(input_a, input_b, name: nil)
       input_a, input_b = apply_data_type_coercion(input_a, input_b)
       _op(:floor_div, input_a, input_b, name: name)
@@ -192,12 +192,12 @@ module TensorStream
     #
     # This operation supports broadcasting
     #
-    # Params:
-    # +input_a+:: tensor X
-    # +input_b+:: tensor Y
+    # @param input_a tensor X
+    # @param input_b tensor Y
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def greater(input_a, input_b, name: nil)
       input_a, input_b = apply_data_type_coercion(input_a, input_b)
       _op(:greater, input_a, input_b, name: name)
@@ -209,29 +209,46 @@ module TensorStream
     #
     # This operation supports broadcasting
     #
-    # Params:
-    # +input_a+:: tensor X
-    # +input_b+:: tensor Y
+    # @param input_a tensor X
+    # @param input_b tensor Y
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def greater_equal(input_a, input_b, name: nil)
       input_a, input_b = apply_data_type_coercion(input_a, input_b)
       _op(:greater_equal, input_a, input_b, name: name)
     end
 
 
+    ##
+    # Returns the truth value of (x < y) element-wise.
+    #
+    # This operation supports broadcasting
+    #
+    # @param input_a tensor X
+    # @param input_b tensor Y
+    #
+    # Options:
+    # @option name Optional name
+    # @return Tensor
+    def less(input_a, input_b, name: nil)
+      input_a, input_b = apply_data_type_coercion(input_a, input_b)
+      _op(:less, input_a, input_b, name: name)
+    end
+
+
     ##
     # Returns the truth value of (x <= y) element-wise.
     #
     # This operation supports broadcasting
     #
-    # Params:
-    # +input_a+:: tensor X
-    # +input_b+:: tensor Y
+    # @param input_a tensor X
+    # @param input_b tensor Y
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def less_equal(input_a, input_b, name: nil)
       input_a, input_b = apply_data_type_coercion(input_a, input_b)
       _op(:less_equal, input_a, input_b, name: name)
@@ -242,11 +259,11 @@ module TensorStream
     # Computes natural logarithm of x element-wise.
     #
     #
-    # Params:
-    # +input+:: tensor X
+    # @param input tensor X
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def log(input, name: nil)
       _op(:log, input, name: name)
     end
@@ -257,14 +274,14 @@ module TensorStream
     #
     # This operation supports broadcasting
     #
-    # Params:
-    # +input_a+:: tensor X
-    # +input_b+:: tensor Y
+    # @param input_a tensor X
+    # @param input_b tensor Y
     #
     # Options:
-    # +:transpose_a+:: Transpose matrix A first default (false)
-    # +:transpose_b+:: Transpose matrix B first default (false)
-    # +:name+:: Optional name
+    # @option transpose_a Transpose matrix A first default (false)
+    # @option transpose_b Transpose matrix B first default (false)
+    # @option name Optional name
+    # @return Tensor
     def mat_mul(input_a, input_b, transpose_a: false, transpose_b: false, name: nil)
       input_a, input_b = apply_data_type_coercion(input_a, input_b)
       _op(:mat_mul, input_a, input_b, transpose_a: transpose_a, transpose_b: transpose_b, name: name)
@@ -277,12 +294,12 @@ module TensorStream
     #
     # This operation supports broadcasting
     #
-    # Params:
-    # +input_a+:: tensor X (of type NUMERIC_TYPES)
-    # +input_b+:: tensor Y (of type NUMERIC_TYPES)
+    # @param input_a tensor X (of type NUMERIC_TYPES)
+    # @param input_b tensor Y (of type NUMERIC_TYPES)
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def max(input_a, input_b, name: nil)
       check_allowed_types(input_a, TensorStream::Ops::NUMERIC_TYPES)
       check_allowed_types(input_b, TensorStream::Ops::NUMERIC_TYPES)
@@ -296,12 +313,12 @@ module TensorStream
     #
     # This operation supports broadcasting
     #
-    # Params:
-    # +input_a+:: tensor X (of type NUMERIC_TYPES)
-    # +input_b+:: tensor Y (of type NUMERIC_TYPES)
+    # @param input_a tensor X (of type NUMERIC_TYPES)
+    # @param input_b tensor Y (of type NUMERIC_TYPES)
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def min(input_a, input_b, name: nil)
       check_allowed_types(input_a, TensorStream::Ops::NUMERIC_TYPES)
       check_allowed_types(input_b, TensorStream::Ops::NUMERIC_TYPES)
@@ -315,12 +332,12 @@ module TensorStream
     #
     # This operation supports broadcasting
     #
-    # Params:
-    # +input_a+:: tensor X
-    # +input_b+:: tensor Y
+    # @param input_a tensor X
+    # @param input_b tensor Y
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def mod(input_a, input_b, name: nil)
       input_a, input_b = apply_data_type_coercion(input_a, input_b)
       _op(:mod, input_a, input_b, name: name)
@@ -332,12 +349,12 @@ module TensorStream
     #
     # This operation supports broadcasting
     #
-    # Params:
-    # +input_a+:: tensor X
-    # +input_b+:: tensor Y
+    # @param input_a tensor X
+    # @param input_b tensor Y
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def mul(input_a, input_b, name: nil)
       input_a, input_b = apply_data_type_coercion(input_a, input_b)
       _op(:mul, input_a, input_b, name: name)
@@ -348,16 +365,33 @@ module TensorStream
     # Computes numerical negative value element-wise.
     #
     #
-    # Params:
-    # +input+:: tensor X
+    # @param input tensor X
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def negate(input, name: nil)
       _op(:negate, input, name: name)
     end
 
 
+    ##
+    # Returns the truth value of (x != y) element-wise.
+    #
+    # This operation supports broadcasting
+    #
+    # @param input_a tensor X
+    # @param input_b tensor Y
+    #
+    # Options:
+    # @option name Optional name
+    # @return Tensor
+    def not_equal(input_a, input_b, name: nil)
+      input_a, input_b = apply_data_type_coercion(input_a, input_b)
+      _op(:not_equal, input_a, input_b, name: name)
+    end
+
+
     ##
     # Creates a tensor with all elements set to 1.
     # Given a single tensor (tensor), this operation returns a
@@ -365,12 +399,12 @@ module TensorStream
     # Optionally, you can specify a new type (dtype) for the returned tensor.
     #
     #
-    # Params:
-    # +input+:: A tensor
+    # @param input A tensor
     #
     # Options:
-    # +:dtype+:: Optional new data type to cast into
-    # +:name+:: Optional name
+    # @option dtype Optional new data type to cast into
+    # @option name Optional name
+    # @return Tensor
     def ones_like(input, dtype: nil, name: nil)
       _op(:ones_like, input, data_type: dtype, name: name)
     end
@@ -381,12 +415,12 @@ module TensorStream
     #
     # This operation supports broadcasting
     #
-    # Params:
-    # +input_a+:: tensor X
-    # +input_b+:: tensor Y
+    # @param input_a tensor X
+    # @param input_b tensor Y
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def pow(input_a, input_b, name: nil)
       input_a, input_b = apply_data_type_coercion(input_a, input_b)
       _op(:pow, input_a, input_b, name: name)
@@ -401,13 +435,13 @@ module TensorStream
     # If axis has no entries, all dimensions are reduced, and a tensor with a single element is returned.
     #
     #
-    # Params:
-    # +input_a+:: tensor X
-    # +axis+:: tensor X (of type INTEGER_TYPES)
+    # @param input_a tensor X
+    # @param axis tensor X (of type INTEGER_TYPES)
     #
     # Options:
-    # +:name+:: Optional name
-    # +:keepdims+:: If true, retains reduced dimensions with length 1. default (false)
+    # @option name Optional name
+    # @option keepdims If true, retains reduced dimensions with length 1. default (false)
+    # @return Tensor
     def prod(input_a, axis = nil, name: nil, keepdims: false)
       check_allowed_types(axis, TensorStream::Ops::INTEGER_TYPES)
       input_a = TensorStream.convert_to_tensor(input_a)
@@ -422,15 +456,15 @@ module TensorStream
     # Outputs random values from a uniform distribution.
     #
     #
-    # Params:
-    # +shape+:: A 1-D integer Tensor or array. The shape of the output tensor.
+    # @param shape A 1-D integer Tensor or array. The shape of the output tensor.
     #
     # Options:
-    # +:name+:: Optional name
-    # +:dtype+:: The type of the output: float16, float32, float64, int32, or int64 default (:float32)
-    # +:minval+:: A 0-D Tensor or ruby value of type dtype. The lower bound on the range of random values to generate. Defaults to 0. default (0)
-    # +:maxval+:: A 0-D Tensor or ruby value of type dtype. The upper bound on the range of random values to generate. Defaults to 1 if dtype is floating point. default (1)
-    # +:seed+::  A ruby integer. Used to create a random seed for the distribution. See set_random_seed for behavior.
+    # @option name Optional name
+    # @option dtype The type of the output: float16, float32, float64, int32, or int64 default (:float32)
+    # @option minval A 0-D Tensor or ruby value of type dtype. The lower bound on the range of random values to generate. Defaults to 0. default (0)
+    # @option maxval A 0-D Tensor or ruby value of type dtype. The upper bound on the range of random values to generate. Defaults to 1 if dtype is floating point. default (1)
+    # @option seed  A ruby integer. Used to create a random seed for the distribution. See set_random_seed for behavior.
+    # @return Tensor
     def random_uniform(shape, name: nil, dtype: :float32, minval: 0, maxval: 1, seed: nil)
       _op(:random_uniform, shape, name: name, dtype: dtype, minval: minval, maxval: maxval, seed: seed)
     end
@@ -441,15 +475,15 @@ module TensorStream
     # Creates a sequence of numbers that begins at start and extends by increments of delta up to but not including limit.
     #
     #
-    # Params:
-    # +start+:: Acts as first entry in the range if limit is not nil; otherwise, acts as range limit and first entry defaults to 0.
-    # +limit+:: Upper limit of sequence, exclusive. If nil, defaults to the value of start while the first entry of the range defaults to 0.
-    # +delta+:: Number that increments start. Defaults to 1.
+    # @param start Acts as first entry in the range if limit is not nil; otherwise, acts as range limit and first entry defaults to 0.
+    # @param limit Upper limit of sequence, exclusive. If nil, defaults to the value of start while the first entry of the range defaults to 0.
+    # @param delta Number that increments start. Defaults to 1.
     #
     # Options:
-    # +:name+::  A name for the operation. Defaults to "range". default ("range")
-    # +:dtype+:: The type of the elements of the resulting tensor.
-    # +:output_type+:: Output data type defaults to int32 default (:int32)
+    # @option name  A name for the operation. Defaults to "range". default ("range")
+    # @option dtype The type of the elements of the resulting tensor.
+    # @option output_type Output data type defaults to int32 default (:int32)
+    # @return Tensor
     def range(start = 0, limit = 0, delta = 1, name: "range", dtype: nil, output_type: :int32)
       _op(:range, start, limit, delta, name: name, dtype: dtype, output_type: output_type)
     end
@@ -459,11 +493,11 @@ module TensorStream
     # Returns the rank of a tensor
     #
     #
-    # Params:
-    # +input+:: A tensor
+    # @param input A tensor
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def rank(input, name: nil)
       input = convert_to_tensor(input)
       return cons(input.shape.ndims) if input.shape.known?
@@ -476,12 +510,12 @@ module TensorStream
     # Given tensor, this operation returns a tensor that has the same values as tensor with shape shape.
     #
     #
-    # Params:
-    # +input+:: A tensor
-    # +shape+:: A new tensor shape
+    # @param input A tensor
+    # @param shape A new tensor shape
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def reshape(input, shape, name: nil)
       _op(:reshape, input, shape, name: name)
     end
@@ -491,27 +525,42 @@ module TensorStream
     # Rounds the values of a tensor to the nearest integer, element-wise
     #
     #
-    # Params:
-    # +input_a+:: tensor X (of type FLOATING_POINT_TYPES)
+    # @param input_a tensor X (of type FLOATING_POINT_TYPES)
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def round(input_a, name: nil)
       check_allowed_types(input_a, TensorStream::Ops::FLOATING_POINT_TYPES)
       _op(:round, input_a, name: name)
     end
 
 
+    ##
+    # Computes reciprocal of square root of x element-wise.
+    #
+    #
+    # @param input_a tensor X (of type FLOATING_POINT_TYPES)
+    #
+    # Options:
+    # @option name Optional name
+    # @return Tensor
+    def rsqrt(input_a, name: nil)
+      check_allowed_types(input_a, TensorStream::Ops::FLOATING_POINT_TYPES)
+      _op(:rsqrt, input_a, name: name)
+    end
+
+
     ##
     # This operation returns a 1-D integer tensor representing the shape of input
     #
     #
-    # Params:
-    # +input+:: A tensor
+    # @param input A tensor
     #
     # Options:
-    # +:name+:: Optional name
-    # +:out_type+:: Optional output type default (:int32)
+    # @option name Optional name
+    # @option out_type Optional output type default (:int32)
+    # @return Tensor
     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)
@@ -523,11 +572,11 @@ module TensorStream
     # Computes sigmoid of x element-wise.
     #
     #
-    # Params:
-    # +input_a+:: tensor X (of type FLOATING_POINT_TYPES)
+    # @param input_a tensor X (of type FLOATING_POINT_TYPES)
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def sigmoid(input_a, name: nil)
       check_allowed_types(input_a, TensorStream::Ops::FLOATING_POINT_TYPES)
       _op(:sigmoid, input_a, name: name)
@@ -540,11 +589,11 @@ module TensorStream
     # Zero is returned for NaN inputs.
     #
     #
-    # Params:
-    # +input_a+:: tensor X
+    # @param input_a tensor X
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def sign(input_a, name: nil)
       _op(:sign, input_a, name: name)
     end
@@ -554,11 +603,11 @@ module TensorStream
     # Computes sin of input element-wise.
     #
     #
-    # Params:
-    # +input_a+:: tensor X (of type FLOATING_POINT_TYPES)
+    # @param input_a tensor X (of type FLOATING_POINT_TYPES)
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def sin(input_a, name: nil)
       check_allowed_types(input_a, TensorStream::Ops::FLOATING_POINT_TYPES)
       _op(:sin, input_a, name: name)
@@ -570,28 +619,50 @@ module TensorStream
     # Returns a 0-D Tensor representing the number of elements in input of type out_type. Defaults to :int32.
     #
     #
-    # Params:
-    # +input+:: A tensor
+    # @param input A tensor
     #
     # Options:
-    # +:name+:: Optional name
-    # +:out_type+:: Optional output type default (:int32)
+    # @option name Optional name
+    # @option out_type Optional output type default (:int32)
+    # @return Tensor
     def size(input, name: nil, out_type: :int32)
       _op(:size, input, name: name, out_type: out_type)
     end
 
 
+    ##
+    # Extracts a strided slice of a tensor 
+    # this op extracts a slice of size `(end-begin)/stride`
+    #   from the given `input_` tensor. Starting at the location specified by `begin`
+    #   the slice continues by adding `stride` to the index until all dimensions are
+    #   not less than `end`.
+    #   Note that a stride can be negative, which causes a reverse slice.
+    #
+    #
+    # @param input A tensor
+    # @param _begin start index
+    # @param _end end index
+    # @param strides end index
+    #
+    # Options:
+    # @option name Optional name
+    # @return Tensor
+    def strided_slice(input, _begin, _end, strides = nil, name: nil)
+      _op(:strided_slice, input, _begin, _end, strides, name: name)
+    end
+
+
     ##
     # Returns x - y element-wise.
     #
     # This operation supports broadcasting
     #
-    # Params:
-    # +input_a+:: tensor X
-    # +input_b+:: tensor Y
+    # @param input_a tensor X
+    # @param input_b tensor Y
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def sub(input_a, input_b, name: nil)
       input_a, input_b = apply_data_type_coercion(input_a, input_b)
       _op(:sub, input_a, input_b, name: name)
@@ -607,19 +678,21 @@ module TensorStream
     # If axis has no entries, all dimensions are reduced, and a tensor with a single element is returned.
     #
     #
-    # Params:
-    # +input_a+:: tensor X
-    # +axis+:: tensor X (of type INTEGER_TYPES)
+    # @param input_a tensor X
+    # @param axis_p tensor X (of type INTEGER_TYPES)
     #
     # Options:
-    # +:name+:: Optional name
-    # +:keepdims+:: If true, retains reduced dimensions with length 1. default (false)
-    def sum(input_a, axis = nil, name: nil, keepdims: false)
-      check_allowed_types(axis, TensorStream::Ops::INTEGER_TYPES)
+    # @option axis axis
+    # @option name Optional name
+    # @option keepdims If true, retains reduced dimensions with length 1. default (false)
+    # @return Tensor
+    def sum(input_a, axis_p = nil, axis: nil, name: nil, keepdims: false)
+      check_allowed_types(axis_p, TensorStream::Ops::INTEGER_TYPES)
       input_a = TensorStream.convert_to_tensor(input_a)
       return input_a if input_a.shape.scalar?
-      axis = cast_axis(input_a, axis)
-      _op(:sum, input_a, axis, name: name, keepdims: keepdims)
+      axis_p = axis_p || axis
+      axis_p = cast_axis(input_a, axis_p)
+      _op(:sum, input_a, axis_p, name: name, keepdims: keepdims)
     end
 
     alias_method :reduce_sum, :sum
@@ -628,11 +701,11 @@ module TensorStream
     # Computes tan of input element-wise.
     #
     #
-    # Params:
-    # +input_a+:: tensor X (of type FLOATING_POINT_TYPES)
+    # @param input_a tensor X (of type FLOATING_POINT_TYPES)
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def tan(input_a, name: nil)
       check_allowed_types(input_a, TensorStream::Ops::FLOATING_POINT_TYPES)
       _op(:tan, input_a, name: name)
@@ -643,11 +716,11 @@ module TensorStream
     # Computes tanh of input element-wise.
     #
     #
-    # Params:
-    # +input_a+:: tensor X (of type FLOATING_POINT_TYPES)
+    # @param input_a tensor X (of type FLOATING_POINT_TYPES)
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def tanh(input_a, name: nil)
       check_allowed_types(input_a, TensorStream::Ops::FLOATING_POINT_TYPES)
       _op(:tanh, input_a, name: name)
@@ -661,27 +734,44 @@ module TensorStream
     # 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].
     #
     #
-    # Params:
-    # +input+:: A tensor
-    # +multiples+:: Must be one of the following types: int32, int64. 1-D. Length must be the same as the number of dimensions in input
+    # @param input A tensor
+    # @param multiples Must be one of the following types: int32, int64. 1-D. Length must be the same as the number of dimensions in input
     #
     # Options:
-    # +:name+:: Optional name
+    # @option name Optional name
+    # @return Tensor
     def tile(input, multiples, name: nil)
       _op(:tile, input, multiples, name: name)
     end
 
 
+    ##
+    # Finds values and indices of the `k` largest entries for the last dimension.
+    #
+    #
+    # @param input 1-D or higher `Tensor` with last dimension at least `k`.
+    # @param k 0-D `int32` `Tensor`.  Number of top elements to look for along the last dimension (along each row for matrices)
+    #
+    # Options:
+    # @option sorted If true the resulting `k` elements will be sorted by the values in descending order. default (true)
+    # @option name Optional name
+    # @return Tensor
+    def top_k(input, k = 1, sorted: true, name: nil)
+      result = _op(:top_k, input, k, sorted: sorted, name: name)
+      [result[0], result[1]]
+    end
+
+
     ##
     # Creates a tensor with all elements set to zero
     #
     #
-    # Params:
-    # +shape+:: A 1-D integer Tensor or ruby array. The shape of the output tensor.
+    # @param shape A 1-D integer Tensor or ruby array. The shape of the output tensor.
     #
     # Options:
-    # +:dtype+:: Optional name default (:float32)
-    # +:name+:: Optional name
+    # @option dtype Optional name default (:float32)
+    # @option name Optional name
+    # @return Tensor
     def zeros(shape, dtype: :float32, name: nil)
       _op(:zeros, shape, dtype: dtype, name: name)
     end