neulab/docprompting-conala huggingface dataset:
tf.raw_ops.ApplyAdagradDA Update '*var' according to the proximal adagrad scheme.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.ApplyAdagradDA  
tf.raw_ops.ApplyAdagradDA(
    var, gradient_accumulator, gradient_squared_accumulator, grad, lr, l1, l2,
    global_step, use_locking=False, name=None
)

 


 Args
  var   A mutable Tensor. Must be one of the following types: float32, float64, int32, uint8, int16, int8, complex64, int64, qint8, quint8, qint32, bfloat16, uint16, complex128, half, uint32, uint64. Should be from a Variable().  
  gradient_accumulator   A mutable Tensor. Must have the same type as var. Should be from a Variable().  
  gradient_squared_accumulator   A mutable Tensor. Must have the same type as var. Should be from a Variable().  
  grad   A Tensor. Must have the same type as var. The gradient.  
  lr   A Tensor. Must have the same type as var. Scaling factor. Must be a scalar.  
  l1   A Tensor. Must have the same type as var. L1 regularization. Must be a scalar.  
  l2   A Tensor. Must have the same type as var. L2 regularization. Must be a scalar.  
  global_step   A Tensor of type int64. Training step number. Must be a scalar.  
  use_locking   An optional bool. Defaults to False. If True, updating of the var and accum tensors will be protected by a lock; otherwise the behavior is undefined, but may exhibit less contention.  
  name   A name for the operation (optional).   
 


 Returns   A mutable Tensor. Has the same type as var.
tf.raw_ops.ApplyAdagradV2 Update '*var' according to the adagrad scheme.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.ApplyAdagradV2  
tf.raw_ops.ApplyAdagradV2(
    var, accum, lr, epsilon, grad, use_locking=False, update_slots=True, name=None
)
 accum += grad * grad var -= lr * grad * (1 / sqrt(accum))
 


 Args
  var   A mutable Tensor. Must be one of the following types: float32, float64, int32, uint8, int16, int8, complex64, int64, qint8, quint8, qint32, bfloat16, uint16, complex128, half, uint32, uint64. Should be from a Variable().  
  accum   A mutable Tensor. Must have the same type as var. Should be from a Variable().  
  lr   A Tensor. Must have the same type as var. Scaling factor. Must be a scalar.  
  epsilon   A Tensor. Must have the same type as var. Constant factor. Must be a scalar.  
  grad   A Tensor. Must have the same type as var. The gradient.  
  use_locking   An optional bool. Defaults to False. If True, updating of the var and accum tensors will be protected by a lock; otherwise the behavior is undefined, but may exhibit less contention.  
  update_slots   An optional bool. Defaults to True.  
  name   A name for the operation (optional).   
 


 Returns   A mutable Tensor. Has the same type as var.
tf.raw_ops.ApplyAdam   Update '*var' according to the Adam algorithm.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.ApplyAdam  
tf.raw_ops.ApplyAdam(
    var, m, v, beta1_power, beta2_power, lr, beta1, beta2, epsilon, grad,
    use_locking=False, use_nesterov=False, name=None
)
  $$lr_t := \text{learning\_rate} * \sqrt{1 - beta_2^t} / (1 - beta_1^t)$$   $$m_t := beta_1 * m_{t-1} + (1 - beta_1) * g$$   $$v_t := beta_2 * v_{t-1} + (1 - beta_2) * g * g$$   $$variable := variable - lr_t * m_t / (\sqrt{v_t} + \epsilon)$$ 
 


 Args
  var   A mutable Tensor. Must be one of the following types: float32, float64, int32, uint8, int16, int8, complex64, int64, qint8, quint8, qint32, bfloat16, uint16, complex128, half, uint32, uint64. Should be from a Variable().  
  m   A mutable Tensor. Must have the same type as var. Should be from a Variable().  
  v   A mutable Tensor. Must have the same type as var. Should be from a Variable().  
  beta1_power   A Tensor. Must have the same type as var. Must be a scalar.  
  beta2_power   A Tensor. Must have the same type as var. Must be a scalar.  
  lr   A Tensor. Must have the same type as var. Scaling factor. Must be a scalar.  
  beta1   A Tensor. Must have the same type as var. Momentum factor. Must be a scalar.  
  beta2   A Tensor. Must have the same type as var. Momentum factor. Must be a scalar.  
  epsilon   A Tensor. Must have the same type as var. Ridge term. Must be a scalar.  
  grad   A Tensor. Must have the same type as var. The gradient.  
  use_locking   An optional bool. Defaults to False. If True, updating of the var, m, and v tensors will be protected by a lock; otherwise the behavior is undefined, but may exhibit less contention.  
  use_nesterov   An optional bool. Defaults to False. If True, uses the nesterov update.  
  name   A name for the operation (optional).   
 


 Returns   A mutable Tensor. Has the same type as var.
tf.raw_ops.ApplyAdaMax Update '*var' according to the AdaMax algorithm.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.ApplyAdaMax  
tf.raw_ops.ApplyAdaMax(
    var, m, v, beta1_power, lr, beta1, beta2, epsilon, grad, use_locking=False,
    name=None
)
 mt <- beta1 * m{t-1} + (1 - beta1) * g vt <- max(beta2 * v{t-1}, abs(g)) variable <- variable - learning_rate / (1 - beta1^t) * m_t / (v_t + epsilon)
 


 Args
  var   A mutable Tensor. Must be one of the following types: float32, float64, int32, uint8, int16, int8, complex64, int64, qint8, quint8, qint32, bfloat16, uint16, complex128, half, uint32, uint64. Should be from a Variable().  
  m   A mutable Tensor. Must have the same type as var. Should be from a Variable().  
  v   A mutable Tensor. Must have the same type as var. Should be from a Variable().  
  beta1_power   A Tensor. Must have the same type as var. Must be a scalar.  
  lr   A Tensor. Must have the same type as var. Scaling factor. Must be a scalar.  
  beta1   A Tensor. Must have the same type as var. Momentum factor. Must be a scalar.  
  beta2   A Tensor. Must have the same type as var. Momentum factor. Must be a scalar.  
  epsilon   A Tensor. Must have the same type as var. Ridge term. Must be a scalar.  
  grad   A Tensor. Must have the same type as var. The gradient.  
  use_locking   An optional bool. Defaults to False. If True, updating of the var, m, and v tensors will be protected by a lock; otherwise the behavior is undefined, but may exhibit less contention.  
  name   A name for the operation (optional).   
 


 Returns   A mutable Tensor. Has the same type as var.
tf.raw_ops.ApplyAddSign Update '*var' according to the AddSign update.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.ApplyAddSign  
tf.raw_ops.ApplyAddSign(
    var, m, lr, alpha, sign_decay, beta, grad, use_locking=False, name=None
)
 mt <- beta1 * m{t-1} + (1 - beta1) * g update <- (alpha + sign_decay * sign(g) *sign(m)) * g variable <- variable - lr_t * update
 


 Args
  var   A mutable Tensor. Must be one of the following types: float32, float64, int32, uint8, int16, int8, complex64, int64, qint8, quint8, qint32, bfloat16, uint16, complex128, half, uint32, uint64. Should be from a Variable().  
  m   A mutable Tensor. Must have the same type as var. Should be from a Variable().  
  lr   A Tensor. Must have the same type as var. Scaling factor. Must be a scalar.  
  alpha   A Tensor. Must have the same type as var. Must be a scalar.  
  sign_decay   A Tensor. Must have the same type as var. Must be a scalar.  
  beta   A Tensor. Must have the same type as var. Must be a scalar.  
  grad   A Tensor. Must have the same type as var. The gradient.  
  use_locking   An optional bool. Defaults to False. If True, updating of the var and m tensors is protected by a lock; otherwise the behavior is undefined, but may exhibit less contention.  
  name   A name for the operation (optional).   
 


 Returns   A mutable Tensor. Has the same type as var.
tf.raw_ops.ApplyCenteredRMSProp Update '*var' according to the centered RMSProp algorithm.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.ApplyCenteredRMSProp  
tf.raw_ops.ApplyCenteredRMSProp(
    var, mg, ms, mom, lr, rho, momentum, epsilon, grad, use_locking=False, name=None
)
 The centered RMSProp algorithm uses an estimate of the centered second moment (i.e., the variance) for normalization, as opposed to regular RMSProp, which uses the (uncentered) second moment. This often helps with training, but is slightly more expensive in terms of computation and memory. Note that in dense implementation of this algorithm, mg, ms, and mom will update even if the grad is zero, but in this sparse implementation, mg, ms, and mom will not update in iterations during which the grad is zero. mean_square = decay * mean_square + (1-decay) * gradient ** 2 mean_grad = decay * mean_grad + (1-decay) * gradient Delta = learning_rate * gradient / sqrt(mean_square + epsilon - mean_grad ** 2) mg <- rho * mg{t-1} + (1-rho) * grad ms <- rho * ms{t-1} + (1-rho) * grad * grad mom <- momentum * mom_{t-1} + lr * grad / sqrt(ms - mg * mg + epsilon) var <- var - mom
 


 Args
  var   A mutable Tensor. Must be one of the following types: float32, float64, int32, uint8, int16, int8, complex64, int64, qint8, quint8, qint32, bfloat16, uint16, complex128, half, uint32, uint64. Should be from a Variable().  
  mg   A mutable Tensor. Must have the same type as var. Should be from a Variable().  
  ms   A mutable Tensor. Must have the same type as var. Should be from a Variable().  
  mom   A mutable Tensor. Must have the same type as var. Should be from a Variable().  
  lr   A Tensor. Must have the same type as var. Scaling factor. Must be a scalar.  
  rho   A Tensor. Must have the same type as var. Decay rate. Must be a scalar.  
  momentum   A Tensor. Must have the same type as var. Momentum Scale. Must be a scalar.  
  epsilon   A Tensor. Must have the same type as var. Ridge term. Must be a scalar.  
  grad   A Tensor. Must have the same type as var. The gradient.  
  use_locking   An optional bool. Defaults to False. If True, updating of the var, mg, ms, and mom tensors is protected by a lock; otherwise the behavior is undefined, but may exhibit less contention.  
  name   A name for the operation (optional).   
 


 Returns   A mutable Tensor. Has the same type as var.
tf.raw_ops.ApplyFtrl Update '*var' according to the Ftrl-proximal scheme.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.ApplyFtrl  
tf.raw_ops.ApplyFtrl(
    var, accum, linear, grad, lr, l1, l2, lr_power, use_locking=False,
    multiply_linear_by_lr=False, name=None
)
 accum_new = accum + grad * grad linear += grad - (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2 var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0 accum = accum_new
 


 Args
  var   A mutable Tensor. Must be one of the following types: float32, float64, int32, uint8, int16, int8, complex64, int64, qint8, quint8, qint32, bfloat16, uint16, complex128, half, uint32, uint64. Should be from a Variable().  
  accum   A mutable Tensor. Must have the same type as var. Should be from a Variable().  
  linear   A mutable Tensor. Must have the same type as var. Should be from a Variable().  
  grad   A Tensor. Must have the same type as var. The gradient.  
  lr   A Tensor. Must have the same type as var. Scaling factor. Must be a scalar.  
  l1   A Tensor. Must have the same type as var. L1 regularization. Must be a scalar.  
  l2   A Tensor. Must have the same type as var. L2 regularization. Must be a scalar.  
  lr_power   A Tensor. Must have the same type as var. Scaling factor. Must be a scalar.  
  use_locking   An optional bool. Defaults to False. If True, updating of the var and accum tensors will be protected by a lock; otherwise the behavior is undefined, but may exhibit less contention.  
  multiply_linear_by_lr   An optional bool. Defaults to False.  
  name   A name for the operation (optional).   
 


 Returns   A mutable Tensor. Has the same type as var.
tf.raw_ops.ApplyFtrlV2 Update '*var' according to the Ftrl-proximal scheme.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.ApplyFtrlV2  
tf.raw_ops.ApplyFtrlV2(
    var, accum, linear, grad, lr, l1, l2, l2_shrinkage, lr_power, use_locking=False,
    multiply_linear_by_lr=False, name=None
)
 grad_with_shrinkage = grad + 2 * l2_shrinkage * var accum_new = accum + grad * grad linear += grad_with_shrinkage - (accum_new^(-lr_power) - accum^(-lr_power)) / lr * var quadratic = 1.0 / (accum_new^(lr_power) * lr) + 2 * l2 var = (sign(linear) * l1 - linear) / quadratic if |linear| > l1 else 0.0 accum = accum_new
 


 Args
  var   A mutable Tensor. Must be one of the following types: float32, float64, int32, uint8, int16, int8, complex64, int64, qint8, quint8, qint32, bfloat16, uint16, complex128, half, uint32, uint64. Should be from a Variable().  
  accum   A mutable Tensor. Must have the same type as var. Should be from a Variable().  
  linear   A mutable Tensor. Must have the same type as var. Should be from a Variable().  
  grad   A Tensor. Must have the same type as var. The gradient.  
  lr   A Tensor. Must have the same type as var. Scaling factor. Must be a scalar.  
  l1   A Tensor. Must have the same type as var. L1 regularization. Must be a scalar.  
  l2   A Tensor. Must have the same type as var. L2 shrinkage regularization. Must be a scalar.  
  l2_shrinkage   A Tensor. Must have the same type as var.  
  lr_power   A Tensor. Must have the same type as var. Scaling factor. Must be a scalar.  
  use_locking   An optional bool. Defaults to False. If True, updating of the var and accum tensors will be protected by a lock; otherwise the behavior is undefined, but may exhibit less contention.  
  multiply_linear_by_lr   An optional bool. Defaults to False.  
  name   A name for the operation (optional).   
 


 Returns   A mutable Tensor. Has the same type as var.
tf.raw_ops.ApplyGradientDescent Update '*var' by subtracting 'alpha' * 'delta' from it.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.ApplyGradientDescent  
tf.raw_ops.ApplyGradientDescent(
    var, alpha, delta, use_locking=False, name=None
)

 


 Args
  var   A mutable Tensor. Must be one of the following types: float32, float64, int32, uint8, int16, int8, complex64, int64, qint8, quint8, qint32, bfloat16, uint16, complex128, half, uint32, uint64. Should be from a Variable().  
  alpha   A Tensor. Must have the same type as var. Scaling factor. Must be a scalar.  
  delta   A Tensor. Must have the same type as var. The change.  
  use_locking   An optional bool. Defaults to False. If True, the subtraction will be protected by a lock; otherwise the behavior is undefined, but may exhibit less contention.  
  name   A name for the operation (optional).   
 


 Returns   A mutable Tensor. Has the same type as var.
tf.raw_ops.ApplyMomentum Update '*var' according to the momentum scheme.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.ApplyMomentum  
tf.raw_ops.ApplyMomentum(
    var, accum, lr, grad, momentum, use_locking=False, use_nesterov=False, name=None
)
 Set use_nesterov = True if you want to use Nesterov momentum. accum = accum * momentum + grad var -= lr * accum
 


 Args
  var   A mutable Tensor. Must be one of the following types: float32, float64, int32, uint8, int16, int8, complex64, int64, qint8, quint8, qint32, bfloat16, uint16, complex128, half, uint32, uint64. Should be from a Variable().  
  accum   A mutable Tensor. Must have the same type as var. Should be from a Variable().  
  lr   A Tensor. Must have the same type as var. Scaling factor. Must be a scalar.  
  grad   A Tensor. Must have the same type as var. The gradient.  
  momentum   A Tensor. Must have the same type as var. Momentum. Must be a scalar.  
  use_locking   An optional bool. Defaults to False. If True, updating of the var and accum tensors will be protected by a lock; otherwise the behavior is undefined, but may exhibit less contention.  
  use_nesterov   An optional bool. Defaults to False. If True, the tensor passed to compute grad will be var - lr * momentum * accum, so in the end, the var you get is actually var - lr * momentum * accum.  
  name   A name for the operation (optional).   
 


 Returns   A mutable Tensor. Has the same type as var.
tf.raw_ops.ApplyPowerSign Update '*var' according to the AddSign update.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.ApplyPowerSign  
tf.raw_ops.ApplyPowerSign(
    var, m, lr, logbase, sign_decay, beta, grad, use_locking=False, name=None
)
 mt <- beta1 * m{t-1} + (1 - beta1) * g update <- exp(logbase * sign_decay * sign(g) * sign(m_t)) * g variable <- variable - lr_t * update
 


 Args
  var   A mutable Tensor. Must be one of the following types: float32, float64, int32, uint8, int16, int8, complex64, int64, qint8, quint8, qint32, bfloat16, uint16, complex128, half, uint32, uint64. Should be from a Variable().  
  m   A mutable Tensor. Must have the same type as var. Should be from a Variable().  
  lr   A Tensor. Must have the same type as var. Scaling factor. Must be a scalar.  
  logbase   A Tensor. Must have the same type as var. Must be a scalar.  
  sign_decay   A Tensor. Must have the same type as var. Must be a scalar.  
  beta   A Tensor. Must have the same type as var. Must be a scalar.  
  grad   A Tensor. Must have the same type as var. The gradient.  
  use_locking   An optional bool. Defaults to False. If True, updating of the var and m tensors is protected by a lock; otherwise the behavior is undefined, but may exhibit less contention.  
  name   A name for the operation (optional).   
 


 Returns   A mutable Tensor. Has the same type as var.
tf.raw_ops.ApplyProximalAdagrad Update 'var' and 'accum' according to FOBOS with Adagrad learning rate.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.ApplyProximalAdagrad  
tf.raw_ops.ApplyProximalAdagrad(
    var, accum, lr, l1, l2, grad, use_locking=False, name=None
)
 accum += grad * grad prox_v = var - lr * grad * (1 / sqrt(accum)) var = sign(prox_v)/(1+lr*l2) * max{|prox_v|-lr*l1,0}
 


 Args
  var   A mutable Tensor. Must be one of the following types: float32, float64, int32, uint8, int16, int8, complex64, int64, qint8, quint8, qint32, bfloat16, uint16, complex128, half, uint32, uint64. Should be from a Variable().  
  accum   A mutable Tensor. Must have the same type as var. Should be from a Variable().  
  lr   A Tensor. Must have the same type as var. Scaling factor. Must be a scalar.  
  l1   A Tensor. Must have the same type as var. L1 regularization. Must be a scalar.  
  l2   A Tensor. Must have the same type as var. L2 regularization. Must be a scalar.  
  grad   A Tensor. Must have the same type as var. The gradient.  
  use_locking   An optional bool. Defaults to False. If True, updating of the var and accum tensors will be protected by a lock; otherwise the behavior is undefined, but may exhibit less contention.  
  name   A name for the operation (optional).   
 


 Returns   A mutable Tensor. Has the same type as var.
tf.raw_ops.ApplyProximalGradientDescent Update '*var' as FOBOS algorithm with fixed learning rate.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.ApplyProximalGradientDescent  
tf.raw_ops.ApplyProximalGradientDescent(
    var, alpha, l1, l2, delta, use_locking=False, name=None
)
 prox_v = var - alpha * delta var = sign(prox_v)/(1+alpha*l2) * max{|prox_v|-alpha*l1,0}
 


 Args
  var   A mutable Tensor. Must be one of the following types: float32, float64, int32, uint8, int16, int8, complex64, int64, qint8, quint8, qint32, bfloat16, uint16, complex128, half, uint32, uint64. Should be from a Variable().  
  alpha   A Tensor. Must have the same type as var. Scaling factor. Must be a scalar.  
  l1   A Tensor. Must have the same type as var. L1 regularization. Must be a scalar.  
  l2   A Tensor. Must have the same type as var. L2 regularization. Must be a scalar.  
  delta   A Tensor. Must have the same type as var. The change.  
  use_locking   An optional bool. Defaults to False. If True, the subtraction will be protected by a lock; otherwise the behavior is undefined, but may exhibit less contention.  
  name   A name for the operation (optional).   
 


 Returns   A mutable Tensor. Has the same type as var.
tf.raw_ops.ApplyRMSProp Update '*var' according to the RMSProp algorithm.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.ApplyRMSProp  
tf.raw_ops.ApplyRMSProp(
    var, ms, mom, lr, rho, momentum, epsilon, grad, use_locking=False, name=None
)
 Note that in dense implementation of this algorithm, ms and mom will update even if the grad is zero, but in this sparse implementation, ms and mom will not update in iterations during which the grad is zero. mean_square = decay * mean_square + (1-decay) * gradient ** 2 Delta = learning_rate * gradient / sqrt(mean_square + epsilon) ms <- rho * ms{t-1} + (1-rho) * grad * grad mom <- momentum * mom{t-1} + lr * grad / sqrt(ms + epsilon) var <- var - mom
 


 Args
  var   A mutable Tensor. Must be one of the following types: float32, float64, int32, uint8, int16, int8, complex64, int64, qint8, quint8, qint32, bfloat16, uint16, complex128, half, uint32, uint64. Should be from a Variable().  
  ms   A mutable Tensor. Must have the same type as var. Should be from a Variable().  
  mom   A mutable Tensor. Must have the same type as var. Should be from a Variable().  
  lr   A Tensor. Must have the same type as var. Scaling factor. Must be a scalar.  
  rho   A Tensor. Must have the same type as var. Decay rate. Must be a scalar.  
  momentum   A Tensor. Must have the same type as var.  
  epsilon   A Tensor. Must have the same type as var. Ridge term. Must be a scalar.  
  grad   A Tensor. Must have the same type as var. The gradient.  
  use_locking   An optional bool. Defaults to False. If True, updating of the var, ms, and mom tensors is protected by a lock; otherwise the behavior is undefined, but may exhibit less contention.  
  name   A name for the operation (optional).   
 


 Returns   A mutable Tensor. Has the same type as var.
tf.raw_ops.ApproximateEqual Returns the truth value of abs(x-y) < tolerance element-wise.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.ApproximateEqual  
tf.raw_ops.ApproximateEqual(
    x, y, tolerance=1e-05, name=None
)

 


 Args
  x   A Tensor. Must be one of the following types: float32, float64, int32, uint8, int16, int8, complex64, int64, qint8, quint8, qint32, bfloat16, uint16, complex128, half, uint32, uint64.  
  y   A Tensor. Must have the same type as x.  
  tolerance   An optional float. Defaults to 1e-05.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor of type bool.
tf.raw_ops.ArgMax Returns the index with the largest value across dimensions of a tensor.  View aliases  Compat aliases for migration 
See Migration guide for more details. tf.compat.v1.raw_ops.ArgMax  
tf.raw_ops.ArgMax(
    input, dimension, output_type=tf.dtypes.int64, name=None
)
 Note that in case of ties the identity of the return value is not guaranteed. Usage: import tensorflow as tf
a = [1, 10, 26.9, 2.8, 166.32, 62.3]
b = tf.math.argmax(input = a)
c = tf.keras.backend.eval(b)
# c = 4
# here a[4] = 166.32 which is the largest element of a across axis 0

 


 Args
  input   A Tensor. Must be one of the following types: float32, float64, int32, uint8, int16, int8, complex64, int64, qint8, quint8, qint32, bfloat16, uint16, complex128, half, uint32, uint64, bool.  
  dimension   A Tensor. Must be one of the following types: int32, int64. int32 or int64, must be in the range [-rank(input), rank(input)). Describes which dimension of the input Tensor to reduce across. For vectors, use dimension = 0.  
  output_type   An optional tf.DType from: tf.int32, tf.int64. Defaults to tf.int64.  
  name   A name for the operation (optional).   
 


 Returns   A Tensor of type output_type.