fiftyone.core.aggregations.Distinct

class documentation

class Distinct(Aggregation): (source)

Constructor: Distinct(field_or_expr, expr, safe)

Computes the distinct values of a field in a collection.

None-valued fields are ignored.

This aggregation is typically applied to countable field types (or lists of such types):

Examples:

import fiftyone as fo
from fiftyone import ViewField as F

dataset = fo.Dataset()
dataset.add_samples(
    [
        fo.Sample(
            filepath="/path/to/image1.png",
            tags=["sunny"],
            predictions=fo.Detections(
                detections=[
                    fo.Detection(label="cat"),
                    fo.Detection(label="dog"),
                ]
            ),
        ),
        fo.Sample(
            filepath="/path/to/image2.png",
            tags=["sunny", "cloudy"],
            predictions=fo.Detections(
                detections=[
                    fo.Detection(label="cat"),
                    fo.Detection(label="rabbit"),
                ]
            ),
        ),
        fo.Sample(
            filepath="/path/to/image3.png",
            predictions=None,
        ),
    ]
)

#
# Get the distinct tags in a dataset
#

aggregation = fo.Distinct("tags")
values = dataset.aggregate(aggregation)
print(values)  # list of distinct values

#
# Get the distinct predicted labels in a dataset
#

aggregation = fo.Distinct("predictions.detections.label")
values = dataset.aggregate(aggregation)
print(values)  # list of distinct values

#
# Get the distinct predicted labels after some normalization
#

aggregation = fo.Distinct(
    F("predictions.detections.label").map_values(
        {"cat": "pet", "dog": "pet"}
    ).upper()
)
values = dataset.aggregate(aggregation)
print(values)  # list of distinct values

Parameters
field_or_expr	a field name, `embedded.field.name`, `fiftyone.core.expressions.ViewExpression`, or MongoDB expression defining the field or expression to aggregate
expr	a `fiftyone.core.expressions.ViewExpression` or MongoDB expression to apply to `field_or_expr` (which must be a field) before aggregating
safe	whether to ignore nan/inf values when dealing with floating point values

Method	`__init__`	Undocumented
Method	`default_result`	Returns the default result for this aggregation.
Method	`parse_result`	Parses the output of `to_mongo`.
Method	`to_mongo`	Returns the MongoDB aggregation pipeline for this aggregation.
Instance Variable	`_field_type`	Undocumented

Inherited from Aggregation:

Method	`__eq__`	Undocumented
Method	`__repr__`	Undocumented
Method	`__str__`	Undocumented
Property	`field_name`	The name of the field being computed on, if any.
Class Method	`_from_dict`	Creates an `Aggregation` instance from a serialized JSON dict representation of it.
Method	`_kwargs`	Returns a list of `[name, value]` lists describing the parameters of this aggregation instance.
Method	`_needs_frames`	Whether the aggregation requires frame labels of video samples to be attached.
Method	`_needs_group_slices`	Whether the aggregation requires group slice(s) to be attached.
Method	`_serialize`	Returns a JSON dict representation of the `Aggregation`.
Instance Variable	`_expr`	Undocumented
Instance Variable	`_field_name`	Undocumented
Instance Variable	`_safe`	Undocumented
Instance Variable	`_uuid`	Undocumented
Property	`_has_big_result`	Whether the aggregation's result is returned across multiple documents.
Property	`_is_big_batchable`	Whether the aggregation has big results and its pipeline is defined by a single `$project` stage and thus can be combined with other such aggregations.

def __init__(self, field_or_expr, expr=None, safe=False): (source) ¶

overrides fiftyone.core.aggregations.Aggregation.__init__

Undocumented

def default_result(self): (source) ¶

overrides fiftyone.core.aggregations.Aggregation.default_result

Returns the default result for this aggregation.

Returns
`[]`

def parse_result(self, d): (source) ¶

overrides fiftyone.core.aggregations.Aggregation.parse_result

Parses the output of to_mongo.

Parameters
d	the result dict
Returns
a sorted list of distinct values

def to_mongo(self, sample_collection, context=None): (source) ¶

overrides fiftyone.core.aggregations.Aggregation.to_mongo

Returns the MongoDB aggregation pipeline for this aggregation.

Parameters
sample_collection	the `fiftyone.core.collections.SampleCollection` to which the aggregation is being applied
context:`None`	a path context from which to resolve
Returns
a MongoDB aggregation pipeline (list of dicts)

_field_type = (source) ¶

Undocumented