parameters: (predictions,
                                              labels,
                                              k,
                                              weights=None,
                                              metrics_collections=None,
                                              updates_collections=None,
                                              name=None)
docstring: Computes average precision@k of predictions with respect to sparse labels.
  
    See `sparse_average_precision_at_k` for details on formula. `weights` are
    applied to the result of `sparse_average_precision_at_k`
  
    `streaming_sparse_average_precision_at_k` creates two local variables,
    `average_precision_at_<k>/count` and `average_precision_at_<k>/total`, that
    are used to compute the frequency. This frequency is ultimately returned as
    `precision_at_<k>`: an idempotent operation that simply divides
    `true_positive_at_<k>` by total (`true_positive_at_<k>` +
    `false_positive_at_<k>`).
  
    For estimation of the metric over a stream of data, the function creates an
    `update_op` operation that updates these variables and returns the
    `precision_at_<k>`. Internally, a `top_k` operation computes a `Tensor`
    indicating the top `k` `predictions`. Set operations applied to `top_k` and
    `labels` calculate the true positives and false positives weighted by
    `weights`. Then `update_op` increments `true_positive_at_<k>` and
    `false_positive_at_<k>` using these values.
  
    If `weights` is `None`, weights default to 1. Use weights of 0 to mask values.
  
    Args:
      predictions: Float `Tensor` with shape [D1, ... DN, num_classes] where
        N >= 1. Commonly, N=1 and `predictions` has shape
        [batch size, num_classes]. The final dimension contains the logit values
        for each class. [D1, ... DN] must match `labels`.
      labels: `int64` `Tensor` or `SparseTensor` with shape
        [D1, ... DN, num_labels], where N >= 1 and num_labels is the number of
        target classes for the associated prediction. Commonly, N=1 and `labels`
        has shape [batch_size, num_labels]. [D1, ... DN] must match
        `predictions_idx`. Values should be in range [0, num_classes], where
        num_classes is the last dimension of `predictions`.
      k: Integer, k for @k metric. This will calculate an average precision for
        range `[1,k]`, as documented above.
      weights: An optional `Tensor` whose shape is broadcastable to the the first
        [D1, ... DN] dimensions of `predictions` and `labels`.
      metrics_collections: An optional list of collections that values should
        be added to.
      updates_collections: An optional list of collections that updates should
        be added to.
      name: Name of new update operation, and namespace for other dependent ops.
  
    Returns:
      mean_average_precision: Scalar `float64` `Tensor` with the mean average
        precision values.
      update: `Operation` that increments  variables appropriately, and whose
        value matches `metric`.
docstring_summary: Computes average precision@k of predictions with respect to sparse labels.
docstring_tokens: Computes average precision@k of predictions with respect to sparse labels .
function: def streaming_sparse_average_precision_at_k(predictions,
                                              labels,
                                              k,
                                              weights=None,
                                              metrics_collections=None,
                                              updates_collections=None,
                                              name=None):
    """Computes average precision@k of predictions with respect to sparse labels.
  
    See `sparse_average_precision_at_k` for details on formula. `weights` are
    applied to the result of `sparse_average_precision_at_k`
  
    `streaming_sparse_average_precision_at_k` creates two local variables,
    `average_precision_at_<k>/count` and `average_precision_at_<k>/total`, that
    are used to compute the frequency. This frequency is ultimately returned as
    `precision_at_<k>`: an idempotent operation that simply divides
    `true_positive_at_<k>` by total (`true_positive_at_<k>` +
    `false_positive_at_<k>`).
  
    For estimation of the metric over a stream of data, the function creates an
    `update_op` operation that updates these variables and returns the
    `precision_at_<k>`. Internally, a `top_k` operation computes a `Tensor`
    indicating the top `k` `predictions`. Set operations applied to `top_k` and
    `labels` calculate the true positives and false positives weighted by
    `weights`. Then `update_op` increments `true_positive_at_<k>` and
    `false_positive_at_<k>` using these values.
  
    If `weights` is `None`, weights default to 1. Use weights of 0 to mask values.
  
    Args:
      predictions: Float `Tensor` with shape [D1, ... DN, num_classes] where
        N >= 1. Commonly, N=1 and `predictions` has shape
        [batch size, num_classes]. The final dimension contains the logit values
        for each class. [D1, ... DN] must match `labels`.
      labels: `int64` `Tensor` or `SparseTensor` with shape
        [D1, ... DN, num_labels], where N >= 1 and num_labels is the number of
        target classes for the associated prediction. Commonly, N=1 and `labels`
        has shape [batch_size, num_labels]. [D1, ... DN] must match
        `predictions_idx`. Values should be in range [0, num_classes], where
        num_classes is the last dimension of `predictions`.
      k: Integer, k for @k metric. This will calculate an average precision for
        range `[1,k]`, as documented above.
      weights: An optional `Tensor` whose shape is broadcastable to the the first
        [D1, ... DN] dimensions of `predictions` and `labels`.
      metrics_collections: An optional list of collections that values should
        be added to.
      updates_collections: An optional list of collections that updates should
        be added to.
      name: Name of new update operation, and namespace for other dependent ops.
  
    Returns:
      mean_average_precision: Scalar `float64` `Tensor` with the mean average
        precision values.
      update: `Operation` that increments  variables appropriately, and whose
        value matches `metric`.
    """
    default_name = _at_k_name('average_precision', k)
    with ops.name_scope(name, default_name, (predictions, labels)) as scope:
      # Calculate per-example average precision, and apply weights.
      average_precision = sparse_average_precision_at_k(
          predictions=predictions, labels=labels, k=k)
      if weights is not None:
        weights = math_ops.to_double(weights)
        average_precision = math_ops.mul(average_precision, weights)
  
      # Create accumulation variables and update ops for max average precision and
      # total average precision.
      with ops.name_scope(None, 'max', (average_precision,)) as max_scope:
        # `max` is the max possible precision. Since max for any row is 1.0:
        # - For the unweighted case, this is just the number of rows.
        # - For the weighted case, it's the sum of the weights broadcast across
        #   `average_precision` rows.
        max_var = contrib_variables.local_variable(
            array_ops.zeros([], dtype=dtypes.float64), name=max_scope)
        if weights is None:
          batch_max = math_ops.to_double(
              array_ops.size(average_precision, name='batch_max'))
        else:
          # TODO(ptucker): More efficient way to broadcast?
          broadcast_weights = math_ops.mul(
              weights, array_ops.ones_like(average_precision),
              name='broadcast_weights')
          batch_max = math_ops.reduce_sum(broadcast_weights, name='batch_max')
        max_update = state_ops.assign_add(max_var, batch_max, name='update')
      with ops.name_scope(None, 'total', (average_precision,)) as total_scope:
        total_var = contrib_variables.local_variable(
            array_ops.zeros([], dtype=dtypes.float64), name=total_scope)
        batch_total = math_ops.reduce_sum(average_precision, name='batch_total')
        total_update = state_ops.assign_add(total_var, batch_total, name='update')
  
      # Divide total by max to get mean, for both vars and the update ops.
      mean_average_precision = _safe_scalar_div(total_var, max_var, name='mean')
      update = _safe_scalar_div(total_update, max_update, name=scope)
  
      if metrics_collections:
        ops.add_to_collections(metrics_collections, mean_average_precision)
      if updates_collections:
        ops.add_to_collections(updates_collections, update)
  
      return mean_average_precision, update
function_tokens: def streaming_sparse_average_precision_at_k ( predictions , labels , k , weights = None , metrics_collections = None , updates_collections = None , name = None ) : default_name = _at_k_name ( 'average_precision' , k ) with ops . name_scope ( name , default_name , ( predictions , labels ) ) as scope : # Calculate per-example average precision, and apply weights. average_precision = sparse_average_precision_at_k ( predictions = predictions , labels = labels , k = k ) if weights is not None : weights = math_ops . to_double ( weights ) average_precision = math_ops . mul ( average_precision , weights ) # Create accumulation variables and update ops for max average precision and # total average precision. with ops . name_scope ( None , 'max' , ( average_precision , ) ) as max_scope : # `max` is the max possible precision. Since max for any row is 1.0: # - For the unweighted case, this is just the number of rows. # - For the weighted case, it's the sum of the weights broadcast across #   `average_precision` rows. max_var = contrib_variables . local_variable ( array_ops . zeros ( [ ] , dtype = dtypes . float64 ) , name = max_scope ) if weights is None : batch_max = math_ops . to_double ( array_ops . size ( average_precision , name = 'batch_max' ) ) else : # TODO(ptucker): More efficient way to broadcast? broadcast_weights = math_ops . mul ( weights , array_ops . ones_like ( average_precision ) , name = 'broadcast_weights' ) batch_max = math_ops . reduce_sum ( broadcast_weights , name = 'batch_max' ) max_update = state_ops . assign_add ( max_var , batch_max , name = 'update' ) with ops . name_scope ( None , 'total' , ( average_precision , ) ) as total_scope : total_var = contrib_variables . local_variable ( array_ops . zeros ( [ ] , dtype = dtypes . float64 ) , name = total_scope ) batch_total = math_ops . reduce_sum ( average_precision , name = 'batch_total' ) total_update = state_ops . assign_add ( total_var , batch_total , name = 'update' ) # Divide total by max to get mean, for both vars and the update ops. mean_average_precision = _safe_scalar_div ( total_var , max_var , name = 'mean' ) update = _safe_scalar_div ( total_update , max_update , name = scope ) if metrics_collections : ops . add_to_collections ( metrics_collections , mean_average_precision ) if updates_collections : ops . add_to_collections ( updates_collections , update ) return mean_average_precision , update