fiftyone.core.expressions.ViewExpression

Computes the absolute value of this expression, which must resolve to a numeric value.

Examples:

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Only contains samples with `uniqueness` in [0.25, 0.75]
view = dataset.match(abs(F("uniqueness") - 0.5) < 0.25)

print(view.bounds("uniqueness"))

Adds the given value to this expression, which must resolve to a numeric value, self + other.

Examples:

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Bboxes are in [top-left-x, top-left-y, width, height] format
manhattan_dist = F("bounding_box")[0] + F("bounding_box")[1]

# Only contains predictions whose bounding boxes' upper left corner
# is a Manhattan distance of at least 1 from the origin
dataset.filter_labels("predictions, manhattan_dist > 1)

print(dataset.count("predictions.detections"))
print(view.count("predictions.detections"))

Computes the logical AND of this expression and the given value or expression, self & other.

Examples:

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Only contains predictions with label "cat" and confidence > 0.9
view = dataset.filter_labels(
    "predictions",
    (F("label") == "cat") & (F("confidence") > 0.9)
)

print(view.count_values("predictions.detections.label"))
print(view.bounds("predictions.detections.confidence"))

Retrieves the specified field or embedded field of this expression, which must resolve to a document.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Sort samples alphabetically by the label of their first ground
# truth object
view = dataset.sort_by(F("ground_truth.detections")[0]("label"))

print(view.values(F("ground_truth.detections")[0]("label")))

Computes the ceiling of this expression, which must resolve to a numeric value.

Examples:

import math

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Only contains samples with `uniqueness` in [0.5, 1]
view = dataset.match(math.ceil(F("uniqueness") + 0.5) == 2)

print(view.bounds("uniqueness"))

Undocumented

Determines whether this expression is equal to the given value or expression, self == other.

Examples:

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset(
    "cifar10", split="test", max_samples=500, shuffle=True
)

# Get samples whose ground truth `label` is "airplane"
view = dataset.match(F("ground_truth.label") == "airplane")

print(view.distinct("ground_truth.label"))

Computes the floor of this expression, which must resolve to a numeric value.

Examples:

import math

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Only contains samples with `uniqueness` in [0.5, 1]
view = dataset.match(math.floor(F("uniqueness") + 0.5) == 1)

print(view.bounds("uniqueness"))

Determines whether this expression is greater than or equal to the given value or expression, self >= other.

Examples:

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Get samples whose `uniqueness` value is >= 0.5
view = dataset.match(F("uniqueness") >= 0.5)

print(view.bounds("uniqueness"))

Returns the element or slice of this expression, which must resolve to an array.

All of the typical slicing operations are supported, except for specifying a non-unit step:

expr[3]      # the fourth element
expr[-1]     # the last element
expr[:10]    # the first (up to) 10 elements
expr[-3:]    # the last (up to) 3 elements
expr[3:10]   # the fourth through tenth elements

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Bboxes are in [top-left-x, top-left-y, width, height] format
bbox_area = F("bounding_box")[2] * F("bounding_box")[3]

# Only contains objects in the `predictions` field with area > 0.2
view = dataset.filter_labels("predictions", bbox_area > 0.2)

print(dataset.count("predictions.detections"))
print(view.count("predictions.detections"))

Determines whether this expression is greater than the given value or expression, self >= other.

Examples:

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Get samples whose `uniqueness` value is > 0.5
view = dataset.match(F("uniqueness") > 0.5)

print(view.bounds("uniqueness"))

Undocumented

Undocumented

Inverts this expression, ~self.

Examples:

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Add a new field to one sample
sample = dataset.first()
sample["new_field"] = ["hello", "there"]
sample.save()

# Get samples that do NOT have a value for `new_field`
view = dataset.match(~F("new_field").exists())

print(len(view))

Determines whether this expression is less than or equal to the given value or expression, self <= other.

Examples:

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Get samples whose `uniqueness` value is <= 0.5
view = dataset.match(F("uniqueness") <= 0.5)

print(view.bounds("uniqueness"))

Undocumented

Determines whether this expression is less than the given value or expression, self <= other.

Examples:

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Get samples whose `uniqueness` value is < 0.5
view = dataset.match(F("uniqueness") < 0.5)

print(view.bounds("uniqueness"))

Computes the modulus of this expression, which must resolve to a numeric value, self % other.

Examples:

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Only contains samples with an even number of predictions
view = dataset.match(
    (F("predictions.detections").length() % 2) == 0
)

print(dataset.count("predictions.detections"))
print(view.count("predictions.detections"))

Computes the product of the given value and this expression, which must resolve to a numeric value, self * other.

Examples:

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Bboxes are in [top-left-x, top-left-y, width, height] format
bbox_area = F("bounding_box")[2] * F("bounding_box")[3]

# Only contains predictions whose bounding box area is > 0.2
view = dataset.filter_labels("predictions", bbox_area > 0.2)

Determines whether this expression is not equal to the given value or expression, self != other.

Examples:

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset(
    "cifar10", split="test", max_samples=500, shuffle=True
)

# Get samples whose ground truth `label` is NOT "airplane"
view = dataset.match(F("ground_truth.label") != "airplane")

print("airplane" in view.distinct("ground_truth.label"))

Computes the logical OR of this expression and the given value or expression, self | other.

Examples:

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Only contains predictions with label "cat" or confidence > 0.9
view = dataset.filter_labels(
    "predictions",
    (F("label") == "cat") | (F("confidence") > 0.9)
)

print(view.count_values("predictions.detections.label"))
print(view.bounds("predictions.detections.confidence"))

Raises this expression, which must resolve to a numeric value, to the given power, self ** power.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Bboxes are in [top-left-x, top-left-y, width, height] format
center_dist = (
    (F("bounding_box")[0] + 0.5 * F("bounding_box")[2] - 0.5) ** 2 +
    (F("bounding_box")[1] + 0.5 * F("bounding_box")[3] - 0.5) ** 2
).sqrt()

# Only contains predictions whose bounding box center is a distance
# of at most 0.02 from the center of the image
view = dataset.select_fields("predictions").filter_labels(
    "predictions", center_dist < 0.02
)

session = fo.launch_app(view=view)

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Undocumented

Rounds this expression, which must resolve to a numeric value, at the given decimal place.

Positive values of place will round to place decimal places:

place=2: 1234.5678 --> 1234.57

Negative values of place will round digits left of the decimal:

place=-2: 1234.5678 --> 1200

Examples:

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Only contains samples with `uniqueness` in [0.25, 0.75]
view = dataset.match(round(2 * F("uniqueness")) == 1)

print(view.bounds("uniqueness"))

Undocumented

Undocumented

Undocumented

Subtracts the given value from this expression, which must resolve to a numeric value, self - other.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")
dataset.compute_metadata()

# Bboxes are in [top-left-x, top-left-y, width, height] format
rectangleness = abs(
    F("$metadata.width") * F("bounding_box")[2] -
    F("$metadata.height") * F("bounding_box")[3]
)

# Only contains predictions whose bounding boxes are within 1 pixel
# of being square
view = (
    dataset
    .select_fields("predictions")
    .filter_labels("predictions", rectangleness <= 1)
)

session = fo.launch_app(view=view)

Divides this expression, which must resolve to a numeric value, by the given value, self / other.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")
dataset.compute_metadata()

# Bboxes are in [top-left-x, top-left-y, width, height] format
aspect_ratio = (
    (F("$metadata.width") * F("bounding_box")[2]) /
    (F("$metadata.height") * F("bounding_box")[3])
)

# Only contains predictions whose aspect ratio is > 2
view = (
    dataset
    .select_fields("predictions")
    .filter_labels("predictions", aspect_ratio > 2)
)

session = fo.launch_app(view=view)

Computes the absolute value of this expression, which must resolve to a numeric value.

Examples:

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Only contains samples with `uniqueness` in [0.25, 0.75]
view = dataset.match((F("uniqueness") - 0.5).abs() < 0.25)

print(view.bounds("uniqueness"))

Appends the given value to this expression, which must resolve to an array.

Examples:

import fiftyone as fo
from fiftyone import ViewField as F

dataset = fo.Dataset()
dataset.add_samples(
    [
        fo.Sample(filepath="image1.jpg", tags=["a", "b"]),
        fo.Sample(filepath="image2.jpg", tags=["a", "b"]),
    ]
)

# Appends the "c" tag to each sample
view = dataset.set_field("tags", F("tags").append("c"))

print(view.first().tags)

Applies the given expression to this expression.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Get samples with `uniqueness` in [0.25, 0.75]
view = dataset.match(
    F("uniqueness").apply((F() > 0.25) & (F() < 0.75))
)

print(view.bounds("uniqueness"))

Computes the inverse cosine of this expression, which must resolve to a numeric value, in radians.

Examples:

import numpy as np

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Get samples whose `uniqueness` value is >= 0.5 using `arccos()`
view = dataset.match(F("uniqueness").arccos() <= np.arccos(0.5))

print(view.bounds("uniqueness"))

Computes the inverse hyperbolic cosine of this expression, which must resolve to a numeric value, in radians.

Examples:

import numpy as np

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Get samples whose `uniqueness` value is >= 0.5 using `arccosh()`
view = dataset.match((1 + F("uniqueness")).arccosh() >= np.arccosh(1.5))

print(view.bounds("uniqueness"))

Computes the inverse sine of this expression, which must resolve to a numeric value, in radians.

Examples:

import numpy as np

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Get samples whose `uniqueness` value is >= 0.5 using `arcsin()`
view = dataset.match(F("uniqueness").arcsin() >= np.arcsin(0.5))

print(view.bounds("uniqueness"))

Computes the inverse hyperbolic sine of this expression, which must resolve to a numeric value, in radians.

Examples:

import numpy as np

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Get samples whose `uniqueness` value is >= 0.5 using `arcsinh()`
view = dataset.match(F("uniqueness").arcsinh() >= np.arcsinh(0.5))

print(view.bounds("uniqueness"))

Computes the inverse tangent of this expression, which must resolve to a numeric value, in radians.

Examples:

import numpy as np

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Get samples whose `uniqueness` value is >= 0.5 using `arctan()`
view = dataset.match(F("uniqueness").arctan() >= np.arctan(0.5))

print(view.bounds("uniqueness"))

Computes the inverse hyperbolic tangent of this expression, which must resolve to a numeric value, in radians.

Examples:

import numpy as np

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Get samples whose `uniqueness` value is >= 0.5 using `arctanh()`
view = dataset.match(F("uniqueness").arctanh() >= np.arctanh(0.5))

print(view.bounds("uniqueness"))

Applies a case statement to this expression, which effectively computes the following pseudocode:

for key, value in mapping.items():
    if self == key:
        return value

if default is not None:
    return default

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Set `uniqueness` values below 0.75 to None
view = dataset.set_field(
    "uniqueness",
    (F("uniqueness") > 0.75).if_else(F("uniqueness"), None)
)

# Map numeric `uniqueness` values to 1 and null values to 0
cases_view = view.set_field(
    "uniqueness",
    F("uniqueness").type().cases({"double": 1, "null": 0}),
)

print(cases_view.count_values("uniqueness"))

Computes the ceiling of this expression, which must resolve to a numeric value.

Examples:

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Only contains samples with `uniqueness` in [0.5, 1]
view = dataset.match((F("uniqueness") + 0.5).ceil() == 2)

print(view.bounds("uniqueness"))

Concatenates the given string(s) to this expression, which must resolve to a string.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Appends "-tag" to all tags
transform_tag = F().concat("-tag")
view = dataset.set_field("tags", F("tags").map(transform_tag))

print(dataset.distinct("tags"))
print(view.distinct("tags"))

Checks whether this expression, which must resolve to an array, contains any of the given values.

Pass all=True to require that this expression contains all of the given values.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")
print(dataset.count())

# Only contains samples with a "cat" prediction
view = dataset.match(
    F("predictions.detections.label").contains("cat")
)
print(view.count())

# Only contains samples with "cat" or "dog" predictions
view = dataset.match(
    F("predictions.detections.label").contains(["cat", "dog"])
)
print(view.count())

# Only contains samples with "cat" and "dog" predictions
view = dataset.match(
    F("predictions.detections.label").contains(["cat", "dog"], all=True)
)
print(view.count())

Determines whether this expression, which must resolve to a string, contains the given string or string(s).

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Only contains predictions whose `label` contains "be"
view = dataset.filter_labels(
    "predictions", F("label").contains_str("be")
)

print(view.distinct("predictions.detections.label"))

Computes the cosine of this expression, which must resolve to a numeric value, in radians.

Examples:

import numpy as np

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Get samples whose `uniqueness` value is >= 0.5 using `cos()`
view = dataset.match(F("uniqueness").cos() <= np.cos(0.5))

print(view.bounds("uniqueness"))

Computes the hyperbolic cosine of this expression, which must resolve to a numeric value, in radians.

Examples:

import numpy as np

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Get samples whose `uniqueness` value is >= 0.5 using `cosh()`
view = dataset.match(F("uniqueness").cosh() >= np.cosh(0.5))

print(view.bounds("uniqueness"))

Returns the day of the month of this date expression (in UTC) as a number between 1 and 31.

Examples:

from datetime import datetime

import fiftyone as fo
from fiftyone import ViewField as F

samples = [
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 1),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 2),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 3),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 4),
    ),
]

dataset = fo.Dataset()
dataset.add_samples(samples)

# Get the days of the month for the dataset
print(dataset.values(F("created_at").day_of_month()))

# Samples with even days of the month
view = dataset.match(F("created_at").day_of_month() % 2 == 0)
print(len(view))

Returns the day of the week of this date expression (in UTC) as a number between 1 (Sunday) and 7 (Saturday).

Examples:

from datetime import datetime

import fiftyone as fo
from fiftyone import ViewField as F

samples = [
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 4),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 5),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 6),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 7),
    ),
]

dataset = fo.Dataset()
dataset.add_samples(samples)

# Get the days of the week for the dataset
print(dataset.values(F("created_at").day_of_week()))

# Samples with even days of the week
view = dataset.match(F("created_at").day_of_week() % 2 == 0)
print(len(view))

Returns the day of the year of this date expression (in UTC) as a number between 1 and 366.

Examples:

from datetime import datetime

import fiftyone as fo
from fiftyone import ViewField as F

samples = [
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 1),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 2),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 3),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 4),
    ),
]

dataset = fo.Dataset()
dataset.add_samples(samples)

# Get the days of the year for the dataset
print(dataset.values(F("created_at").day_of_year()))

# Samples with even days of the year
view = dataset.match(F("created_at").day_of_year() % 2 == 0)
print(len(view))

Computes the set difference of this expression, which must resolve to an array, and the given array or array expression.

The arrays are treated as sets, so all duplicates are removed.

Examples:

import fiftyone as fo
from fiftyone import ViewField as F

dataset = fo.Dataset()
dataset.add_samples(
    [
        fo.Sample(
            filepath="image1.jpg",
            tags=["a", "b"],
            other_tags=["a", "c"]
        )
    ]
)

print(dataset.values(F("tags").difference(F("other_tags"))))
# [['b']]

Determines whether this expression, which must resolve to a string, ends with the given string or string(s).

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Get samples whose images are JPEGs or PNGs
view = dataset.match(F("filepath").ends_with((".jpg", ".png")))

print(view.count())
print(view.first().filepath)

Determines whether this expression, which must resolve to a field, exists and is not None.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset(
    "quickstart", dataset_name=fo.get_default_dataset_name()
)

# Add a new field to one sample
sample = dataset.first()
sample["new_field"] = ["hello", "there"]
sample.save()

# Get samples that have a value for `new_field`
view = dataset.match(F("new_field").exists())

print(len(view))

Raises Euler's number to this expression, which must resolve to a numeric value.

Concatenates the given array(s) or array expression(s) to this expression, which must resolve to an array.

Examples:

import fiftyone as fo
from fiftyone import ViewField as F

dataset = fo.Dataset()
dataset.add_samples(
    [
        fo.Sample(filepath="image1.jpg", tags=["a", "b"]),
        fo.Sample(filepath="image2.jpg", tags=["a", "b"]),
    ]
)

# Adds the "c" and "d" tags to each sample
view = dataset.set_field("tags", F("tags").extend(["c", "d"]))

print(view.first().tags)

Applies the given filter to the elements of this expression, which must resolve to an array.

The output array will only contain elements of the input array for which expr returns True.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Only include predictions with `confidence` of at least 0.9
view = dataset.set_field(
    "predictions.detections",
    F("detections").filter(F("confidence") > 0.9)
)

print(view.bounds("predictions.detections.confidence"))

Computes the floor of this expression, which must resolve to a numeric value.

Examples:

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Only contains samples with `uniqueness` in [0.5, 1]
view = dataset.match((F("uniqueness") + 0.5).floor() == 1)

print(view.bounds("uniqueness"))

Returns the hour portion of this date expression (in UTC) as a number between 0 and 23.

Examples:

from datetime import datetime

import fiftyone as fo
from fiftyone import ViewField as F

samples = [
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 1, 1),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 1, 2),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 1, 3),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 1, 4),
    ),
]

dataset = fo.Dataset()
dataset.add_samples(samples)

# Get the hour portion of the dates in the dataset
print(dataset.values(F("created_at").hour()))

# Samples with even hours
view = dataset.match(F("created_at").hour() % 2 == 0)
print(len(view))

Returns either true_expr or false_expr depending on the value of this expression, which must resolve to a boolean.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Set `uniqueness` values below 0.75 to None
view = dataset.set_field(
    "uniqueness",
    (F("uniqueness") > 0.75).if_else(F("uniqueness"), None)
)

print(view.bounds("uniqueness"))

Inserts the value before the given index in this expression, which must resolve to an array.

If index <= 0, the value is prepended to this array. If index >= self.length(), the value is appended to this array.

Examples:

import fiftyone as fo
from fiftyone import ViewField as F

dataset = fo.Dataset()
dataset.add_samples(
    [
        fo.Sample(filepath="image1.jpg", tags=["a", "c"]),
        fo.Sample(filepath="image2.jpg", tags=["a", "c"]),
    ]
)

# Adds the "ready" tag to each sample
view = dataset.set_field("tags", F("tags").insert(1, "b"))

print(view.first().tags)

Computes the set intersection of this expression, which must resolve to an array, and the given array(s) or array expression(s).

The arrays are treated as sets, so all duplicates are removed.

Examples:

import fiftyone as fo
from fiftyone import ViewField as F

dataset = fo.Dataset()
dataset.add_samples(
    [
        fo.Sample(
            filepath="image1.jpg",
            tags=["a", "b"],
            other_tags=["a", "c"]
        )
    ]
)

print(dataset.values(F("tags").intersection(F("other_tags"))))
# [['a']]

Determines whether this expression is an array.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Verify that tags are arrays
view = dataset.match(F("tags").is_array())

print(len(view))

Creates an expression that returns a boolean indicating whether self in values.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

ANIMALS = [
    "bear", "bird", "cat", "cow", "dog", "elephant", "giraffe",
    "horse", "sheep", "zebra"
]

dataset = foz.load_zoo_dataset("quickstart")

# Create a view that only contains animal predictions
view = dataset.filter_labels(
    "predictions", F("label").is_in(ANIMALS)
)

print(view.count_values("predictions.detections.label"))

Determines whether this expression refers to a missing field.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Verify that `foobar` is a non-existent field on all samples
view = dataset.match(F("foobar").is_missing())

print(len(view) == len(dataset))

Determines whether this expression is null.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Set `uniqueness` values below 0.25 to None
view = dataset.set_field(
    "uniqueness",
    (F("uniqueness") >= 0.25).if_else(F("uniqueness"), None)
)

# Create view that only contains samples with uniqueness = None
not_unique_view = view.match(F("uniqueness").is_null())

print(len(not_unique_view))

Determines whether this expression is a number.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Set `uniqueness` values below 0.25 to None
view = dataset.set_field(
    "uniqueness",
    (F("uniqueness") >= 0.25).if_else(F("uniqueness"), None)
)

# Create view that only contains samples with uniqueness values
has_unique_view = view.match(F("uniqueness").is_number())

print(len(has_unique_view))

Determines whether this expression is a string.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Verify that filepaths are strings
view = dataset.match(F("filepath").is_string())

print(len(view))

Checks whether this expression's contents, which must resolve to an array, are a subset of the given array or array expression's contents.

The arrays are treated as sets, so duplicate values are ignored.

Examples:

import fiftyone as fo
from fiftyone import ViewField as F

dataset = fo.Dataset()
dataset.add_samples(
    [
        fo.Sample(
            filepath="image1.jpg",
            tags=["a", "b", "a", "b"],
            other_tags=["a", "b", "c"],
        )
    ]
)

print(dataset.values(F("tags").is_subset(F("other_tags"))))
# [True]

Joins the elements of this expression, which must resolve to a string array, by the given delimiter.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Generate a `list,of,labels` for the `predictions` of each sample
view = dataset.set_field(
    "predictions.labels",
    F("detections").map(F("label")).join(",")
)

print(view.first().predictions.labels)

Computes the length of this expression, which must resolve to an array.

If this expression's value is null or missing, zero is returned.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Only contains samples with at least 15 predicted objects
view = dataset.match(F("predictions.detections").length() >= 15)

print(dataset.count())
print(view.count())

Returns an equivalent expression where this expression is defined as a variable that is used wherever necessary in the given expression.

This method is useful when expr contains multiple instances of this expression, since it avoids duplicate computation of this expression in the final pipeline.

If expr is a simple expression such as a ViewField, no variable is defined and expr is directly returned.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Bboxes are in [top-left-x, top-left-y, width, height] format
bbox_area = F("bounding_box")[2] * F("bounding_box")[3]

good_bboxes = (bbox_area > 0.25) & (bbox_area < 0.75)

# Optimize the expression
good_bboxes_opt = bbox_area.let_in(good_bboxes)

# Contains predictions whose bounding box areas are in [0.25, 0.75]
view = dataset.filter_labels("predictions", good_bboxes_opt)

print(good_bboxes)
print(good_bboxes_opt)
print(dataset.count("predictions.detections"))
print(view.count("predictions.detections"))

Computes the natural logarithm of this expression, which must resolve to a numeric value.

Examples:

import math

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Get samples whose `uniqueness` value is >= 0.5
view = dataset.match(F("uniqueness").ln() >= math.log(0.5))

print(view.bounds("uniqueness"))

Computes the logarithm base base of this expression, which must resolve to a numeric value.

Examples:

import math

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Get samples whose `uniqueness` value is >= 0.5
view = dataset.match(F("uniqueness").log(2) >= math.log2(0.5))

print(view.bounds("uniqueness"))

Computes the logarithm base 10 of this expression, which must resolve to a numeric value.

Examples:

import math

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Get samples whose `uniqueness` value is >= 0.5
view = dataset.match(F("uniqueness").log10() >= math.log10(0.5))

print(view.bounds("uniqueness"))

Converts this expression, which must resolve to a string, to lowercase.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Converts all tags to lowercase
transform_tag = F().lower()
view = dataset.set_field("tags", F("tags").map(transform_tag))

print(dataset.distinct("tags"))
print(view.distinct("tags"))

Removes whitespace characters from the beginning of this expression, which must resolve to a string.

If chars is provided, those characters are removed instead of whitespace.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewExpression as E
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Adds and then strips whitespace from the beginning of each tag
transform_tag = E(" ").concat(F()).lstrip()
view = dataset.set_field("tags", F("tags").map(transform_tag))

print(dataset.distinct("tags"))
print(view.distinct("tags"))

Applies the given expression to the elements of this expression, which must resolve to an array.

The output will be an array with the applied results.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Bboxes are in [top-left-x, top-left-y, width, height] format
bbox_area = F("bounding_box")[2] * F("bounding_box")[3]

# Only include predictions with `confidence` of at least 0.9
view = dataset.set_field(
    "predictions.detections",
    F("detections").map(F().set_field("area", bbox_area))
)

print(view.bounds("predictions.detections.area"))

Replaces this expression with the corresponding value in the provided mapping dict, if it is present as a key.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

ANIMALS = [
    "bear", "bird", "cat", "cow", "dog", "elephant", "giraffe",
    "horse", "sheep", "zebra"
]

dataset = foz.load_zoo_dataset("quickstart")

#
# Replace the `label` of all animal objects in the `predictions`
# field with "animal"
#
mapping = {a: "animal" for a in ANIMALS}
view = dataset.set_field(
    "predictions.detections",
    F("detections").map(
        F().set_field("label", F("label").map_values(mapping))
    )
)

print(view.count_values("predictions.detections.label"))

Determines whether this expression, which must resolve to a string, exactly matches the given string or string(s).

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Only contains predictions whose `label` is "cat" or "dog", case
# insensitive
view = dataset.map_labels(
    "predictions", {"cat": "CAT", "dog": "DOG"}
).filter_labels(
    "predictions",
    F("label").matches_str(("cat", "dog"), case_sensitive=False)
)

print(view.distinct("predictions.detections.label"))

Returns the maximum value of either this expression, which must resolve to an array, or the maximum of this expression and the given value.

Missing or None values are ignored.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Bboxes are in [top-left-x, top-left-y, width, height] format
bbox_area = F("bounding_box")[2] * F("bounding_box")[3]

# Adds a `max_area` property to the `predictions` field that
# records the maximum prediction area in that sample
view = dataset.set_field(
    "predictions.max_area",
    F("detections").map(bbox_area).max()
)

print(view.bounds("predictions.max_area"))

Returns the average value in this expression, which must resolve to a numeric array.

Missing or None-valued elements are ignored.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Add a field to each `predictions` object that records the average
# confidence of the predictions
view = dataset.set_field(
    "predictions.conf_mean",
    F("detections").map(F("confidence")).mean()
)

print(view.bounds("predictions.conf_mean"))

Returns the millisecond portion of this date expression (in UTC) as an integer between 0 and 999.

Examples:

from datetime import datetime

import fiftyone as fo
from fiftyone import ViewField as F

samples = [
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 1, 0, 0, 0, 1000),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 1, 0, 0, 0, 2000),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 1, 0, 0, 0, 3000),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 1, 0, 0, 0, 4000),
    ),
]

dataset = fo.Dataset()
dataset.add_samples(samples)

# Get the millisecond portion of the dates in the dataset
print(dataset.values(F("created_at").millisecond()))

# Samples with even milliseconds
view = dataset.match(F("created_at").millisecond() % 2 == 0)
print(len(view))

Returns the minimum value of either this expression, which must resolve to an array, or the minimum of this expression and the given value.

Missing or None values are ignored.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Bboxes are in [top-left-x, top-left-y, width, height] format
bbox_area = F("bounding_box")[2] * F("bounding_box")[3]

# Adds a `min_area` property to the `predictions` field that
# records the minimum prediction area in that sample
view = dataset.set_field(
    "predictions.min_area",
    F("detections").map(bbox_area).min()
)

print(view.bounds("predictions.min_area"))

Returns the minute portion of this date expression (in UTC) as a number between 0 and 59.

Examples:

from datetime import datetime

import fiftyone as fo
from fiftyone import ViewField as F

samples = [
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 1, 0, 1),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 1, 0, 2),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 1, 0, 3),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 1, 0, 4),
    ),
]

dataset = fo.Dataset()
dataset.add_samples(samples)

# Get the minute portion of the dates in the dataset
print(dataset.values(F("created_at").minute()))

# Samples with even minutes
view = dataset.match(F("created_at").minute() % 2 == 0)
print(len(view))

Returns the month of this date expression (in UTC) as a number between 1 and 12.

Examples:

from datetime import datetime

import fiftyone as fo
from fiftyone import ViewField as F

samples = [
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 1),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 2, 1),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 3, 1),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 4, 1),
    ),
]

dataset = fo.Dataset()
dataset.add_samples(samples)

# Get the months of the year for the dataset
print(dataset.values(F("created_at").month()))

# Samples from even months of the year
view = dataset.match(F("created_at").month() % 2 == 0)
print(len(view))

Raises this expression, which must resolve to a numeric value, to the given power, self ** power.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Bboxes are in [top-left-x, top-left-y, width, height] format
center_dist = (
    (F("bounding_box")[0] + 0.5 * F("bounding_box")[2] - 0.5).pow(2) +
    (F("bounding_box")[1] + 0.5 * F("bounding_box")[3] - 0.5).pow(2)
).sqrt()

# Only contains predictions whose bounding box center is a distance
# of at most 0.02 from the center of the image
view = dataset.select_fields("predictions").filter_labels(
    "predictions", center_dist < 0.02
)

session = fo.launch_app(view=view)

Prepends the given value to this expression, which must resolve to an array.

Examples:

import fiftyone as fo
from fiftyone import ViewField as F

dataset = fo.Dataset()
dataset.add_samples(
    [
        fo.Sample(filepath="image1.jpg", tags=["b", "c"]),
        fo.Sample(filepath="image2.jpg", tags=["b", "c"]),
    ]
)

# Adds the "a" tag to each sample
view = dataset.set_field("tags", F("tags").prepend("a"))

print(view.first().tags)

Performs a regular expression pattern match on this expression, which must resolve to a string.

The output of the expression will be True if the pattern matches and False otherwise.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

#
# Get samples whose images are JPEGs
#

view = dataset.match(F("filepath").re_match("\.jpg$"))

print(view.count())
print(view.first().filepath)

#
# Get samples whose images are in the "/Users" directory
#

view = dataset.match(F("filepath").re_match("^/Users/"))

print(view.count())
print(view.first().filepath)

Applies the given reduction to this expression, which must resolve to an array, and returns the single value computed.

The provided expr must include the VALUE expression to properly define the reduction.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F
from fiftyone.core.expressions import VALUE

#
# Compute the number of keypoints in each sample of a dataset
#

dataset = fo.Dataset()
dataset.add_sample(
    fo.Sample(
        filepath="image.jpg",
        keypoints=fo.Keypoints(
            keypoints=[
                fo.Keypoint(points=[(0, 0), (1, 1)]),
                fo.Keypoint(points=[(0, 0), (1, 0), (1, 1), (0, 1)]),
            ]
        )
    )
)

view = dataset.set_field(
    "keypoints.count",
    F("$keypoints.keypoints").reduce(VALUE + F("points").length()),
)

print(view.first().keypoints.count)

#
# Generate a `list,of,labels` for the `predictions` of each sample
#

dataset = foz.load_zoo_dataset("quickstart")

join_labels = F("detections").reduce(
    VALUE.concat(",", F("label")), init_val=""
).lstrip(",")

view = dataset.set_field("predictions.labels", join_labels)

print(view.first().predictions.labels)

Replaces all occurrences of old with new in this expression, which must resolve to a string.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Replaces "val" with "VAL" in each tag
transform_tag = F().replace("val", "VAL")
view = dataset.set_field("tags", F("tags").map(transform_tag))

print(dataset.distinct("tags"))
print(view.distinct("tags"))

Reverses the order of the elements in the expression, which must resolve to an array.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

first_obj = F("predictions.detections")[0]
last_obj = F("predictions.detections").reverse()[0]

# Only contains samples whose first and last prediction have the
# same label
view = dataset.match(
    first_obj.apply(F("label")) == last_obj.apply(F("label"))
)

print(dataset.count())
print(view.count())

Rounds this expression, which must resolve to a numeric value, at the given decimal place.

Positive values of place will round to place decimal places:

place=2: 1234.5678 --> 1234.57

Negative values of place will round place digits left of the decimal:

place=-1: 1234.5678 --> 1230

Examples:

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Only contains samples with `uniqueness` in [0.25, 0.75]
view = dataset.match((2 * F("uniqueness")).round() == 1)

print(view.bounds("uniqueness"))

Splits this expression, which must resolve to a string, by the given delimiter.

If the number of chunks exceeds maxsplit, splits are only performed on the last maxsplit occurrences of the delimiter.

The result is a string array that contains the chunks with the delimiter removed. If the delimiter is not found, this full string is returned as a single element array.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Add "-ok-go" to the first tag and then split once on "-" from the
# right to create two tags for each sample
view = dataset.set_field(
    "tags", F("tags")[0].concat("-ok-go").rsplit("-", 1)
)

print(view.first().tags)

Removes whitespace characters from the end of this expression, which must resolve to a string.

If chars is provided, those characters are removed instead of whitespace.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Adds and then strips whitespace from the end of each tag
transform_tag = F().concat(" ").rstrip()
view = dataset.set_field("tags", F("tags").map(transform_tag))

print(dataset.distinct("tags"))
print(view.distinct("tags"))

Returns the second portion of this date expression (in UTC) as a number between 0 and 59.

Examples:

from datetime import datetime

import fiftyone as fo
from fiftyone import ViewField as F

samples = [
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 1, 0, 0, 1),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 1, 0, 0, 2),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 1, 0, 0, 3),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 1, 0, 0, 4),
    ),
]

dataset = fo.Dataset()
dataset.add_samples(samples)

# Get the second portion of the dates in the dataset
print(dataset.values(F("created_at").second()))

# Samples with even seconds
view = dataset.match(F("created_at").second() % 2 == 0)
print(len(view))

Checks whether this expression, which must resolve to an array, contains the same distinct values as each of the given array(s) or array expression(s).

The arrays are treated as sets, so all duplicates are ignored.

Examples:

import fiftyone as fo
from fiftyone import ViewField as F

dataset = fo.Dataset()
dataset.add_samples(
    [
        fo.Sample(
            filepath="image1.jpg",
            tags=["a", "b", "a", "b"],
            other_tags=["a", "b", "b"],
        )
    ]
)

print(dataset.values(F("tags").set_equals(F("other_tags"))))
# [True]

Sets the specified field or embedded field of this expression, which must resolve to a document, to the given value or expression.

By default, the provided expression is computed by applying it to this expression via self.apply(value_or_expr).

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

#
# Replaces the `label` attributes of the objects in the
# `predictions` field according to the following rule:
#
#   If the `label` starts with `b`, replace it with `b`. Otherwise,
#   replace it with "other"
#
view = dataset.set_field(
    "predictions.detections",
    F("detections").map(
        F().set_field(
            "label",
            F("label").re_match("^b").if_else("b", "other"),
        )
    )
)

print(view.count_values("predictions.detections.label"))

Computes the sine of this expression, which must resolve to a numeric value, in radians.

Examples:

import numpy as np

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Get samples whose `uniqueness` value is >= 0.5 using `sin()`
view = dataset.match(F("uniqueness").sin() >= np.sin(0.5))

print(view.bounds("uniqueness"))

Computes the hyperbolic sine of this expression, which must resolve to a numeric value, in radians.

Examples:

import numpy as np

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Get samples whose `uniqueness` value is >= 0.5 using `sinh()`
view = dataset.match(F("uniqueness").sinh() >= np.sinh(0.5))

print(view.bounds("uniqueness"))

Sorts this expression, which must resolve to an array.

If no key is provided, this array must contain elements whose BSON representation can be sorted by JavaScript's .sort() method.

If a key is provided, the array must contain documents, which are sorted by key, which must be a field or embedded field.

Examples:

#
# Sort the tags of each sample in a dataset
#

import fiftyone as fo
from fiftyone import ViewField as F

dataset = fo.Dataset()
dataset.add_samples(
    [
        fo.Sample(filepath="im1.jpg", tags=["z", "f", "p", "a"]),
        fo.Sample(filepath="im2.jpg", tags=["y", "q", "h", "d"]),
        fo.Sample(filepath="im3.jpg", tags=["w", "c", "v", "l"]),
    ]
)

# Sort the `tags` of each sample
view = dataset.set_field("tags", F("tags").sort())

print(view.first().tags)

#
# Sort the predictions in each sample of a dataset by `confidence`
#

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

view = dataset.set_field(
    "predictions.detections",
    F("detections").sort(key="confidence", numeric=True, reverse=True)
)

sample = view.first()
print(sample.predictions.detections[0].confidence)
print(sample.predictions.detections[-1].confidence)

Splits this expression, which must resolve to a string, by the given delimiter.

The result is a string array that contains the chunks with the delimiter removed. If the delimiter is not found, this full string is returned as a single element array.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Add "-good" to the first tag and then split on "-" to create two
# tags for each sample
view = dataset.set_field(
    "tags", F("tags")[0].concat("-good").split("-")
)

print(view.first().tags)

Computes the square root of this expression, which must resolve to a numeric value.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Bboxes are in [top-left-x, top-left-y, width, height] format
center_dist = (
    (F("bounding_box")[0] + 0.5 * F("bounding_box")[2] - 0.5) ** 2 +
    (F("bounding_box")[1] + 0.5 * F("bounding_box")[3] - 0.5) ** 2
).sqrt()

# Only contains predictions whose bounding box center is a distance
# of at most 0.02 from the center of the image
view = dataset.select_fields("predictions").filter_labels(
    "predictions", center_dist < 0.02
)

session = fo.launch_app(view=view)

Determines whether this expression, which must resolve to a string, starts with the given string or string(s).

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Get samples whose images are in "/Users" or "/home" directories
view = dataset.match(F("filepath").starts_with(("/Users", "/home"))

print(view.count())
print(view.first().filepath)

Returns the standard deviation of the values in this expression, which must resolve to a numeric array.

Missing or None-valued elements are ignored.

By default, the population standard deviation is returned. If you wish to compute the sample standard deviation instead, set sample=True.

See https://en.wikipedia.org/wiki/Standard_deviation#Estimation for more information on population (biased) vs sample (unbiased) standard deviation.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Add a field to each `predictions` object that records the
# standard deviation of the confidences
view = dataset.set_field(
    "predictions.conf_std",
    F("detections").map(F("confidence")).std()
)

print(view.bounds("predictions.conf_std"))

Removes whitespace characters from the beginning and end of this expression, which must resolve to a string.

If chars is provided, those characters are removed instead of whitespace.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewExpression as E
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Adds and then strips whitespace from each tag
transform_tag = E(" ").concat(F(), " ").rstrip()
view = dataset.set_field("tags", F("tags").map(transform_tag))

print(dataset.distinct("tags"))
print(view.distinct("tags"))

Computes the length of this expression, which must resolve to a string.

If this expression's value is null or missing, zero is returned.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Records the length of each predicted object's `label`
label_len = F().set_field("label_len", F("label").strlen())
view = dataset.set_field(
    "predictions.detections",
    F("detections").map(label_len),
)

print(view.bounds("predictions.detections.label_len"))

Extracts the specified substring from this expression, which must resolve to a string.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Truncate the `label` of each prediction to 3 characters
truncate_label = F().set_field("label", F("label").substr(count=3))
view = dataset.set_field(
    "predictions.detections",
    F("detections").map(truncate_label),
)

print(view.distinct("predictions.detections.label"))

Returns the sum of the values in this expression, which must resolve to a numeric array.

Missing, non-numeric, or None-valued elements are ignored.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Add a field to each `predictions` object that records the total
# confidence of the predictions
view = dataset.set_field(
    "predictions.total_conf",
    F("detections").map(F("confidence")).sum()
)

print(view.bounds("predictions.total_conf"))

Applies a switch statement to this expression, which effectively computes the given pseudocode:

for key, value in mapping.items():
    if self.apply(key):
        return value

if default is not None:
    return default

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Round `uniqueness` values to either 0.25 or 0.75
view = dataset.set_field(
    "uniqueness",
    F("uniqueness").switch(
        {
            (0.0 < F()) & (F() <= 0.5): 0.25,
            (0.5 < F()) & (F() <= 1.0): 0.75,
        },
    )
)

print(view.count_values("uniqueness"))

Computes the tangent of this expression, which must resolve to a numeric value, in radians.

Examples:

import numpy as np

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Get samples whose `uniqueness` value is >= 0.5 using `tan()`
view = dataset.match(F("uniqueness").tan() >= np.tan(0.5))

print(view.bounds("uniqueness"))

Computes the hyperbolic tangent of this expression, which must resolve to a numeric value, in radians.

Examples:

import numpy as np

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Get samples whose `uniqueness` value is >= 0.5 using `tanh()`
view = dataset.match(F("uniqueness").tanh() >= np.tanh(0.5))

print(view.bounds("uniqueness"))

Converts the expression to a boolean value.

See this page for conversion rules.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart").clone()

# Adds a `uniqueness_bool` field that is False when
# `uniqueness < 0.5` and True when `uniqueness >= 0.5`
dataset.add_sample_field("uniqueness_bool", fo.BooleanField)
view = dataset.set_field(
    "uniqueness_bool", (2.0 * F("uniqueness")).floor().to_bool()
)

print(view.count_values("uniqueness_bool"))

Converts the expression to a date value.

See this page for conversion rules.

Examples:

from datetime import datetime
import pytz

import fiftyone as fo
from fiftyone import ViewField as F

now = datetime.utcnow().replace(tzinfo=pytz.utc)

sample = fo.Sample(
    filepath="image.png",
    date_ms=1000 * now.timestamp(),
    date_str=now.isoformat(),
)

dataset = fo.Dataset()
dataset.add_sample(sample)

# Convert string/millisecond representations into datetimes
dataset.add_sample_field("date1", fo.DateTimeField)
dataset.add_sample_field("date2", fo.DateTimeField)
(
    dataset
    .set_field("date1", F("date_ms").to_date())
    .set_field("date2", F("date_str").to_date())
    .save()
)

print(dataset.first())

Converts the expression to a double precision value.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart").clone()

# Adds a `uniqueness_float` field that is 0.0 when
# `uniqueness < 0.5` and 1.0 when `uniqueness >= 0.5`
dataset.add_sample_field("uniqueness_float", fo.FloatField)
view = dataset.set_field(
    "uniqueness_float", (F("uniqueness") >= 0.5).to_double()
)

print(view.count_values("uniqueness_float"))

See this page for conversion rules.

Converts the expression to an integer value.

See this page for conversion rules.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart").clone()

# Adds a `uniqueness_int` field that contains the value of the
# first decimal point of the `uniqueness` field
dataset.add_sample_field("uniqueness_int", fo.IntField)
view = dataset.set_field(
    "uniqueness_int", (10.0 * F("uniqueness")).floor().to_int()
)

print(view.count_values("uniqueness_int"))

Returns a MongoDB representation of the expression.

Converts the expression to a string value.

See this page for conversion rules.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart").clone()

# Adds a `uniqueness_str` field that is "true" when
# `uniqueness >= 0.5` and "false" when `uniqueness < 0.5`
dataset.add_sample_field("uniqueness_str", fo.StringField)
view = dataset.set_field(
    "uniqueness_str", (F("uniqueness") >= 0.5).to_string()
)

print(view.count_values("uniqueness_str"))

Truncates this expression, which must resolve to a numeric value, at the specified decimal place.

Positive values of place will truncate to place decimal places:

place=2: 1234.5678 --> 1234.56

Negative values of place will replace place digits left of the decimal with zero:

place=-1: 1234.5678 --> 1230

Examples:

import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")
dataset.compute_metadata()

# Only contains samples whose height is in [500, 600) pixels
view = dataset.match(F("metadata.height").trunc(-2) == 500)

print(view.bounds("metadata.height"))

Returns the type string of this expression.

See this page for more details.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Set `uniqueness` values below 0.75 to None
view = dataset.set_field(
    "uniqueness",
    (F("uniqueness") > 0.75).if_else(F("uniqueness"), None)
)

# Create a view that only contains samples with non-None uniqueness
unique_only_view = view.match(F("uniqueness").type() != "null")

print(len(unique_only_view))

Computes the set union of this expression, which must resolve to an array, and the given array(s) or array expression(s).

The arrays are treated as sets, so all duplicates are removed.

Examples:

import fiftyone as fo
from fiftyone import ViewField as F

dataset = fo.Dataset()
dataset.add_samples(
    [
        fo.Sample(
            filepath="image1.jpg",
            tags=["a", "b"],
            other_tags=["a", "c"]
        )
    ]
)

print(dataset.values(F("tags").union(F("other_tags"))))
# [['a', 'b', 'c']]

Returns an array containing the unique values in this expression, which must resolve to an array.

Examples:

import fiftyone as fo
from fiftyone import ViewField as F

dataset = fo.Dataset()
dataset.add_samples(
    [
        fo.Sample(
            filepath="image1.jpg",
            tags=["a", "b", "a", "b"],
        )
    ]
)

print(dataset.values(F("tags").unique()))
# [['a', 'b']]

Converts this expression, which must resolve to a string, to uppercase.

Examples:

import fiftyone as fo
import fiftyone.zoo as foz
from fiftyone import ViewField as F

dataset = foz.load_zoo_dataset("quickstart")

# Converts all tags to uppercase
transform_tag = F().upper()
view = dataset.set_field("tags", F("tags").map(transform_tag))

print(dataset.distinct("tags"))
print(view.distinct("tags"))

Returns the week of the year of this date expression (in UTC) as a number between 0 and 53.

Examples:

from datetime import datetime

import fiftyone as fo
from fiftyone import ViewField as F

samples = [
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 1),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 2, 1),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 3, 1),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 4, 1),
    ),
]

dataset = fo.Dataset()
dataset.add_samples(samples)

# Get the weeks of the year for the dataset
print(dataset.values(F("created_at").week()))

# Samples with even months of the week
view = dataset.match(F("created_at").week() % 2 == 0)
print(len(view))

Returns the year of this date expression (in UTC).

Examples:

from datetime import datetime

import fiftyone as fo
from fiftyone import ViewField as F

samples = [
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1970, 1, 1),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1971, 1, 1),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1972, 1, 1),
    ),
    fo.Sample(
        filepath="image1.jpg",
        created_at=datetime(1973, 1, 1),
    ),
]

dataset = fo.Dataset()
dataset.add_samples(samples)

# Get the years for the dataset
print(dataset.values(F("created_at").year()))

# Samples from even years
view = dataset.match(F("created_at").year() % 2 == 0)
print(len(view))