scale-nucleus 0.1.22__py3-none-any.whl → 0.6.4__py3-none-any.whl

nucleus/metrics/polygon_utils.py

@@ -0,0 +1,299 @@
+import sys
+from functools import wraps
+from typing import Dict, List, Tuple, TypeVar
+
+import numpy as np
+from scipy.optimize import linear_sum_assignment
+
+from nucleus.annotation import BoxAnnotation, PolygonAnnotation
+from nucleus.prediction import BoxPrediction, PolygonPrediction
+
+from .base import ScalarResult
+from .errors import PolygonAnnotationTypeError
+from .geometry import GeometryPolygon, polygon_intersection_area
+
+BoxOrPolygonPrediction = TypeVar(
+    "BoxOrPolygonPrediction", BoxPrediction, PolygonPrediction
+)
+BoxOrPolygonAnnotation = TypeVar(
+    "BoxOrPolygonAnnotation", BoxAnnotation, PolygonAnnotation
+)
+BoxOrPolygonAnnoOrPred = TypeVar(
+    "BoxOrPolygonAnnoOrPred",
+    BoxAnnotation,
+    PolygonAnnotation,
+    BoxPrediction,
+    PolygonPrediction,
+)
+
+
+def polygon_annotation_to_geometry(
+    annotation: BoxOrPolygonAnnotation,
+) -> GeometryPolygon:
+    if isinstance(annotation, BoxAnnotation):
+        xmin = annotation.x - annotation.width / 2
+        xmax = annotation.x + annotation.width / 2
+        ymin = annotation.y - annotation.height / 2
+        ymax = annotation.y + annotation.height / 2
+        points = [(xmin, ymin), (xmax, ymin), (xmax, ymax), (xmin, ymax)]
+        return GeometryPolygon(points=points, is_rectangle=True)
+    elif isinstance(annotation, PolygonAnnotation):
+        return GeometryPolygon(
+            points=[(point.x, point.y) for point in annotation.vertices],
+            is_rectangle=False,
+        )
+    else:
+        raise PolygonAnnotationTypeError()
+
+
+def _iou(annotation: GeometryPolygon, prediction: GeometryPolygon) -> float:
+    intersection = polygon_intersection_area(annotation, prediction)
+    union = annotation.area + prediction.area - intersection
+    return intersection / max(union, sys.float_info.epsilon)
+
+
+def _iou_matrix(
+    annotations: List[GeometryPolygon], predictions: List[GeometryPolygon]
+) -> np.ndarray:
+    iou_matrix = np.empty((len(predictions), len(annotations)))
+    for i, prediction in enumerate(predictions):
+        for j, annotation in enumerate(annotations):
+            iou_matrix[i, j] = _iou(annotation, prediction)
+    return iou_matrix
+
+
+def _iou_assignments_for_same_reference_id(
+    annotations: List[BoxOrPolygonAnnotation],
+    predictions: List[BoxOrPolygonPrediction],
+    iou_threshold: float,
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
+    # Matches annotations and precitions of the same reference ID.
+    # Returns a tuple of the list of all IoU values of valid assignments, a
+    # list of the indices of predictions matched to annotations (-1 if
+    # unmatched), and a list of all indices of annotations matched to
+    # predictions.
+
+    # Check that all annotations and predictions have same reference ID.
+    reference_ids = set(annotation.reference_id for annotation in annotations)
+    reference_ids |= set(prediction.reference_id for prediction in predictions)
+    assert (
+        len(reference_ids) <= 1
+    ), "Expected annotations and predictions to have same reference ID."
+
+    # Convert annotation and predictions to GeometryPolygon objects
+    polygon_annotations = list(
+        map(polygon_annotation_to_geometry, annotations)
+    )
+    polygon_predictions = list(
+        map(polygon_annotation_to_geometry, predictions)
+    )
+
+    # Compute IoU matrix and set IoU values below the threshold to 0.
+    iou_matrix = _iou_matrix(polygon_annotations, polygon_predictions)
+    iou_matrix[iou_matrix < iou_threshold] = 0
+
+    # Match annotations and predictions using linear sum assignment and filter out
+    # values below the threshold.
+    matched_0, matched_1 = linear_sum_assignment(-iou_matrix)
+    iou_assigns = iou_matrix[matched_0, matched_1]
+    valid_idxes = iou_assigns >= iou_threshold
+    iou_assigns = iou_assigns[valid_idxes]
+
+    matched_0 = matched_0[valid_idxes]
+    matched_1 = matched_1[valid_idxes]
+    anno_to_pred = -np.ones(len(annotations))
+    pred_to_anno = -np.ones(len(predictions))
+    anno_to_pred[matched_1] = matched_0
+    pred_to_anno[matched_0] = matched_1
+
+    return iou_assigns, anno_to_pred, pred_to_anno
+
+
+def group_boxes_or_polygons_by_reference_id(
+    annotations: List[BoxOrPolygonAnnotation],
+    predictions: List[BoxOrPolygonPrediction],
+) -> Dict[
+    str, Tuple[List[BoxOrPolygonAnnotation], List[BoxOrPolygonPrediction]]
+]:
+    """Groups input annotations and predictions by reference_id.
+
+    Args:
+        annotations: list of input annotations
+        predictions: list of input predictions
+
+    Returns:
+        Mapping from each reference_id to (annotations, predictions) tuple.
+    """
+    reference_ids = set(annotation.reference_id for annotation in annotations)
+    reference_ids |= set(prediction.reference_id for prediction in predictions)
+    grouped: Dict[
+        str, Tuple[List[BoxOrPolygonAnnotation], List[BoxOrPolygonPrediction]]
+    ] = {reference_id: ([], []) for reference_id in reference_ids}
+    for annotation in annotations:
+        grouped[annotation.reference_id][0].append(annotation)
+    for prediction in predictions:
+        grouped[prediction.reference_id][1].append(prediction)
+    return grouped
+
+
+def group_boxes_or_polygons_by_label(
+    annotations: List[BoxOrPolygonAnnotation],
+    predictions: List[BoxOrPolygonPrediction],
+) -> Dict[
+    str, Tuple[List[BoxOrPolygonAnnotation], List[BoxOrPolygonPrediction]]
+]:
+    """Groups input annotations and predictions by label.
+
+    Args:
+        annotations: list of input box or polygon annotations
+        predictions: list of input box or polygon predictions
+
+    Returns:
+        Mapping from each label to (annotations, predictions) tuple
+    """
+    labels = set(annotation.label for annotation in annotations)
+    labels |= set(prediction.label for prediction in predictions)
+    grouped: Dict[
+        str, Tuple[List[BoxOrPolygonAnnotation], List[BoxOrPolygonPrediction]]
+    ] = {label: ([], []) for label in labels}
+    for annotation in annotations:
+        grouped[annotation.label][0].append(annotation)
+    for prediction in predictions:
+        grouped[prediction.label][1].append(prediction)
+    return grouped
+
+
+def iou_assignments(
+    annotations: List[BoxOrPolygonAnnotation],
+    predictions: List[BoxOrPolygonPrediction],
+    iou_threshold: float,
+) -> np.ndarray:
+    """Matches annotations and predictions based on linear sum cost and returns the
+    intersection-over-union values of the matched annotation-prediction pairs, subject
+    to the specified IoU threshold. Note that annotations and predictions from
+    different reference_ids will not be matched with one another.
+    See https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.linear_sum_assignment.html
+
+    Args:
+        annotations: list of box or polygon annotations
+        predictions: list of box or polygon predictions
+        iou_threshold: the intersection-over-union threshold for an
+            annotation-prediction pair to be considered a match.
+
+    Returns:
+        1D numpy array that contains the IoU values of the matched pairs.
+    """
+    grouped_inputs = group_boxes_or_polygons_by_reference_id(
+        annotations, predictions
+    )
+    iou_assigns = []
+    for grouped_annotations, grouped_predictions in grouped_inputs.values():
+        result_per_reference_id, _, _ = _iou_assignments_for_same_reference_id(
+            grouped_annotations, grouped_predictions, iou_threshold
+        )
+        iou_assigns.append(result_per_reference_id)
+    return np.concatenate(iou_assigns)
+
+
+def get_true_false_positives_confidences(
+    annotations: List[BoxOrPolygonAnnotation],
+    predictions: List[BoxOrPolygonPrediction],
+    iou_threshold: float,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """Matches annotations and predictions based on linear sum cost and returns the
+    intersection-over-union values of the matched annotation-prediction pairs, subject
+    to the specified IoU threshold. Note that annotations and predictions from
+    different reference_ids will not be matched with one another.
+    See https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.linear_sum_assignment.html
+
+    Args:
+        annotations: list of box or polygon annotations
+        predictions: list of box or polygon predictions
+        iou_threshold: the intersection-over-union threshold for an
+            annotation-prediction pair to be considered a match.
+
+    Returns:
+        1D numpy array that contains the 1 if true positive and 0 if false positive
+            for each prediction.
+        1D numpy array of confidence values.
+    """
+    grouped_inputs = group_boxes_or_polygons_by_reference_id(
+        annotations, predictions
+    )
+    true_false_positives = []
+    confidences = []
+    for grouped_annotations, grouped_predictions in grouped_inputs.values():
+        _, _, pred_to_anno = _iou_assignments_for_same_reference_id(
+            grouped_annotations, grouped_predictions, iou_threshold
+        )
+        true_false_positives.append(pred_to_anno > -1)
+        confidences.extend([pred.confidence for pred in grouped_predictions])
+    return np.concatenate(true_false_positives), np.array(confidences)
+
+
+def num_true_positives(
+    annotations: List[BoxOrPolygonAnnotation],
+    predictions: List[BoxOrPolygonPrediction],
+    iou_threshold: float,
+) -> int:
+    """Counts the number of annotations with a matching prediction.
+
+    A prediction is considered a match for an annotation if it has not yet been
+    matched to another annotation, its reference_id is the same as the
+    annotation, and its IoU with the annotation is at least the iou_threshold.
+
+    Args:
+        annotations: list of box or polygon annotations
+        predictions: list of box or polygon predictions
+        iou_threshold: the intersection-over-union threshold for an
+            annotation-prediction pair to be considered a match.
+
+    Returns:
+        The number of true positives (predictions that are matched to annotations).
+    """
+    iou_assigns = iou_assignments(annotations, predictions, iou_threshold)
+    true_positives = len(iou_assigns)
+    return true_positives
+
+
+def label_match_wrapper(metric_fn):
+    """Decorator to add the ability to only apply metric to annotations and
+    predictions with matching labels.
+
+    Args:
+        metric_fn: Metric function that takes a list of annotations, a list
+            of predictions, and optional args and kwargs.
+
+    Returns:
+        Metric function which can optionally enforce matching labels.
+    """
+
+    @wraps(metric_fn)
+    def wrapper(
+        annotations: List[BoxOrPolygonAnnotation],
+        predictions: List[BoxOrPolygonPrediction],
+        *args,
+        enforce_label_match: bool = False,
+        **kwargs,
+    ) -> ScalarResult:
+        # Simply return the metric if we are not enforcing label matches.
+        if not enforce_label_match:
+            return metric_fn(annotations, predictions, *args, **kwargs)
+
+        # For each bin of annotations/predictions, compute the metric applied
+        # only to that bin. Then aggregate results across all bins.
+        grouped_inputs = group_boxes_or_polygons_by_label(
+            annotations, predictions
+        )
+        metric_results = []
+        for binned_annotations, binned_predictions in grouped_inputs.values():
+            metric_result = metric_fn(
+                binned_annotations, binned_predictions, *args, **kwargs
+            )
+            metric_results.append(metric_result)
+        assert all(
+            isinstance(r, ScalarResult) for r in metric_results
+        ), "Expected every result to be a ScalarResult"
+        return ScalarResult.aggregate(metric_results)
+
+    return wrapper

nucleus/model.py

@@ -1,28 +1,98 @@
-from typing import List, Optional, Dict, Union
+from typing import Dict, List, Optional, Union
+
+import requests
+
+from .constants import METADATA_KEY, NAME_KEY, REFERENCE_ID_KEY
 from .dataset import Dataset
+from .job import AsyncJob
+from .model_run import ModelRun
 from .prediction import (
     BoxPrediction,
     CuboidPrediction,
     PolygonPrediction,
     SegmentationPrediction,
 )
-from .model_run import ModelRun
-from .constants import (
-    NAME_KEY,
-    REFERENCE_ID_KEY,
-    METADATA_KEY,
-)
 
 
 class Model:
-    def __init__(
-        self,
-        model_id: str,
-        name: str,
-        reference_id: str,
-        metadata: Optional[Dict],
-        client,
-    ):
+    """A model that can be used to upload predictions to a dataset.
+
+    By uploading model predictions to Nucleus, you can compare your predictions
+    to ground truth annotations and discover problems with your Models or
+    :class:`Dataset`.
+
+    You can also upload predictions for unannotated images, letting you query
+    them based on model predictions. This can help you prioritize which
+    unlabeled data to label next.
+
+    Within Nucleus, Models work in the following way:
+
+    1. You first :meth:`create a Model<NucleusClient.add_model>`. You can do this
+       just once and reuse the model on multiple datasets.
+    2. You then :meth:`upload predictions <Dataset.upload_predictions>` to a dataset.
+    3. Trigger :meth:`calculation of metrics <Dataset.calculate_evaluation_metrics>`
+       in order to view model debugging insights.
+
+    The above steps above will allow you to visualize model performance within
+    Nucleus, or compare multiple models that have been run on the same Dataset.
+
+    Note that you can always add more predictions to a dataset, but then you
+    will need to re-run the calculation of metrics in order to have them be
+    correct.
+
+    ::
+
+        import nucleus
+
+        client = nucleus.NucleusClient(YOUR_SCALE_API_KEY)
+        dataset = client.get_dataset(YOUR_DATASET_ID)
+
+        prediction_1 = nucleus.BoxPrediction(
+            label="label",
+            x=0,
+            y=0,
+            width=10,
+            height=10,
+            reference_id="1",
+            confidence=0.9,
+            class_pdf={"label": 0.9, "other_label": 0.1},
+        )
+        prediction_2 = nucleus.BoxPrediction(
+            label="label",
+            x=0,
+            y=0,
+            width=10,
+            height=10,
+            reference_id="2",
+            confidence=0.2,
+            class_pdf={"label": 0.2, "other_label": 0.8},
+        )
+
+        model = client.add_model(
+            name="My Model", reference_id="My-CNN", metadata={"timestamp": "121012401"}
+        )
+
+        # For small ingestions, we recommend synchronous ingestion
+        response = dataset.upload_predictions(model, [prediction_1, prediction_2])
+
+        # For large ingestions, we recommend asynchronous ingestion
+        job = dataset.upload_predictions(
+            [prediction_1, prediction_2], asynchronous=True
+        )
+        # Check current status
+        job.status()
+        # Sleep until ingestion is done
+        job.sleep_until_complete()
+        # Check errors
+        job.errors()
+
+        dataset.calculate_evaluation_metrics(model)
+
+    Models cannot be instantiated directly and instead must be created via API
+    endpoint, using :meth:`NucleusClient.add_model`.
+    """
+
+    def __init__(self, model_id, name, reference_id, metadata, client):
         self.id = model_id
         self.name = name
         self.reference_id = reference_id
@@ -45,6 +115,7 @@ class Model:
 
     @classmethod
     def from_json(cls, payload: dict, client):
+        """Instantiates model object from schematized JSON dict payload."""
         return cls(
             model_id=payload["id"],
             name=payload["name"],
@@ -68,6 +139,16 @@ class Model:
         metadata: Optional[Dict] = None,
         asynchronous: bool = False,
     ) -> ModelRun:
+        # This method, as well as model runs in general are now deprecated.
+
+        # Instead models will automatically generate a model run when applied to
+        # a dataset using dataset.upload_predictions(model, predictions). Therefore
+        # there is no longer any need to create a model run, since you can upload
+        # predictions without needing to explicitly create a model run.
+
+        # When uploading to a dataset twice using the same model, the same model
+        # run will be reused by Nucleus.
+
         payload: dict = {
             NAME_KEY: name,
             REFERENCE_ID_KEY: self.reference_id,
@@ -81,3 +162,28 @@ class Model:
         model_run.predict(predictions, asynchronous=asynchronous)
 
         return model_run
+
+    def evaluate(self, scenario_test_names: List[str]) -> AsyncJob:
+        """Evaluates this on the specified Unit Tests. ::
+
+            import nucleus
+            client = nucleus.NucleusClient("YOUR_SCALE_API_KEY")
+            model = client.list_models()[0]
+            scenario_test = client.validate.create_scenario_test(
+                "sample_scenario_test", "YOUR_SLICE_ID"
+            )
+
+            model.evaluate(["sample_scenario_test"])
+
+        Args:
+            scenario_test_names: list of unit tests to evaluate
+
+        Returns:
+            AsyncJob object of evaluation job
+        """
+        response = self._client.make_request(
+            {"test_names": scenario_test_names},
+            f"validate/{self.id}/evaluate",
+            requests_command=requests.post,
+        )
+        return AsyncJob.from_json(response, self._client)

nucleus/model_run.py

@@ -1,17 +1,33 @@
-from typing import Dict, List, Optional, Type, Union
+"""
+Model Runs are deprecated and will be removed in a future version of the python client.
+It is now possible to upload model predictions without a need for creating a model run
+
+For example::
+
+    import nucleus
+    client = nucleus.NucleusClient(YOUR_SCALE_API_KEY)
+    prediction_1 = nucleus.BoxPrediction(label="label", x=0, y=0, width=10, height=10, reference_id="1", confidence=0.9, class_pdf={'label': 0.9, 'other_label': 0.1})
+    prediction_2 = nucleus.BoxPrediction(label="label", x=0, y=0, width=10, height=10, reference_id="2", confidence=0.2, class_pdf={'label': 0.2, 'other_label': 0.8})
+    model = client.add_model(name="My Model", reference_id="My-CNN", metadata={"timestamp": "121012401"})
+    response = dataset.upload_predictions(model, [prediction_1, prediction_2])
+"""
+
+
+from typing import List, Optional, Union
+
 import requests
+
 from nucleus.annotation import check_all_mask_paths_remote
 from nucleus.job import AsyncJob
-from nucleus.utils import serialize_and_write_to_presigned_url
+from nucleus.utils import (
+    format_prediction_response,
+    serialize_and_write_to_presigned_url,
+)
 
 from .constants import (
     ANNOTATIONS_KEY,
-    BOX_TYPE,
-    CUBOID_TYPE,
     DEFAULT_ANNOTATION_UPDATE_MODE,
-    POLYGON_TYPE,
     REQUEST_ID_KEY,
-    SEGMENTATION_TYPE,
     UPDATE_KEY,
 )
 from .prediction import (
@@ -25,8 +41,7 @@ from .prediction import (
 
 class ModelRun:
     """
-    Model runs represent detections of a specific model on your dataset.
-    Having an open model run is a prerequisite for uploading predictions to your dataset.
+    This class is deprecated and will be removed from the python client.
     """
 
     def __init__(self, model_run_id: str, dataset_id: str, client):
@@ -124,7 +139,11 @@ class ModelRun:
             )
             return AsyncJob.from_json(response, self._client)
         else:
-            return self._client.predict(self.model_run_id, annotations, update)
+            return self._client.predict(
+                model_run_id=self.model_run_id,
+                annotations=annotations,
+                update=update,
+            )
 
     def iloc(self, i: int):
         """
@@ -134,7 +153,7 @@ class ModelRun:
         }
         """
         response = self._client.predictions_iloc(self.model_run_id, i)
-        return self._format_prediction_response(response)
+        return format_prediction_response(response)
 
     def refloc(self, reference_id: str):
         """
@@ -142,10 +161,10 @@ class ModelRun:
         :param reference_id: reference_id of a dataset item.
         :return: List[Union[BoxPrediction, PolygonPrediction, CuboidPrediction, SegmentationPrediction]],
         """
-        response = self._client.predictions_ref_id(
-            self.model_run_id, reference_id
+        response = self._client.get(
+            f"modelRun/{self.model_run_id}/refloc/{reference_id}"
         )
-        return self._format_prediction_response(response)
+        return format_prediction_response(response)
 
     def loc(self, dataset_item_id: str):
         """
@@ -159,7 +178,7 @@ class ModelRun:
         response = self._client.predictions_loc(
             self.model_run_id, dataset_item_id
         )
-        return self._format_prediction_response(response)
+        return format_prediction_response(response)
 
     def prediction_loc(self, reference_id: str, annotation_id: str):
         """
@@ -184,46 +203,4 @@ class ModelRun:
             route=f"modelRun/{self.model_run_id}/ungrouped",
             requests_command=requests.get,
         )
-        return self._format_prediction_response(
-            {ANNOTATIONS_KEY: json_response}
-        )
-
-    def _format_prediction_response(
-        self, response: dict
-    ) -> Union[
-        dict,
-        List[
-            Union[
-                BoxPrediction,
-                PolygonPrediction,
-                CuboidPrediction,
-                SegmentationPrediction,
-            ]
-        ],
-    ]:
-        annotation_payload = response.get(ANNOTATIONS_KEY, None)
-        if not annotation_payload:
-            # An error occurred
-            return response
-        annotation_response = {}
-        type_key_to_class: Dict[
-            str,
-            Union[
-                Type[BoxPrediction],
-                Type[PolygonPrediction],
-                Type[CuboidPrediction],
-                Type[SegmentationPrediction],
-            ],
-        ] = {
-            BOX_TYPE: BoxPrediction,
-            POLYGON_TYPE: PolygonPrediction,
-            CUBOID_TYPE: CuboidPrediction,
-            SEGMENTATION_TYPE: SegmentationPrediction,
-        }
-        for type_key in annotation_payload:
-            type_class = type_key_to_class[type_key]
-            annotation_response[type_key] = [
-                type_class.from_json(annotation)
-                for annotation in annotation_payload[type_key]
-            ]
-        return annotation_response
+        return format_prediction_response({ANNOTATIONS_KEY: json_response})

nucleus/payload_constructor.py

@@ -1,34 +1,38 @@
-from typing import List, Optional, Dict, Union
-from .dataset_item import DatasetItem
-from .scene import LidarScene
+from typing import Dict, List, Optional, Union
+
 from .annotation import (
     BoxAnnotation,
+    CategoryAnnotation,
     CuboidAnnotation,
+    MultiCategoryAnnotation,
     PolygonAnnotation,
     SegmentationAnnotation,
 )
-from .prediction import (
-    BoxPrediction,
-    CuboidPrediction,
-    PolygonPrediction,
-    SegmentationPrediction,
-)
 from .constants import (
+    ANNOTATION_METADATA_SCHEMA_KEY,
     ANNOTATION_UPDATE_KEY,
-    NAME_KEY,
-    METADATA_KEY,
-    REFERENCE_ID_KEY,
     ANNOTATIONS_KEY,
     ITEMS_KEY,
-    SCENES_KEY,
-    UPDATE_KEY,
+    LABELS_KEY,
+    METADATA_KEY,
     MODEL_ID_KEY,
-    ANNOTATION_METADATA_SCHEMA_KEY,
+    NAME_KEY,
+    REFERENCE_ID_KEY,
+    SCENES_KEY,
     SEGMENTATIONS_KEY,
     TAXONOMY_NAME_KEY,
     TYPE_KEY,
-    LABELS_KEY,
+    UPDATE_KEY,
+)
+from .dataset_item import DatasetItem
+from .prediction import (
+    BoxPrediction,
+    CategoryPrediction,
+    CuboidPrediction,
+    PolygonPrediction,
+    SegmentationPrediction,
 )
+from .scene import LidarScene
 
 
 def construct_append_payload(
@@ -60,6 +64,8 @@ def construct_annotation_payload(
             BoxAnnotation,
             PolygonAnnotation,
             CuboidAnnotation,
+            CategoryAnnotation,
+            MultiCategoryAnnotation,
             SegmentationAnnotation,
         ]
     ],
@@ -87,7 +93,12 @@ def construct_segmentation_payload(
 
 def construct_box_predictions_payload(
     box_predictions: List[
-        Union[BoxPrediction, PolygonPrediction, CuboidPrediction]
+        Union[
+            BoxPrediction,
+            PolygonPrediction,
+            CuboidPrediction,
+            CategoryPrediction,
+        ]
     ],
     update: bool,
 ) -> dict:
@@ -132,10 +143,11 @@ def construct_model_run_creation_payload(
 
 
 def construct_taxonomy_payload(
-    taxonomy_name: str, taxonomy_type: str, labels: List[str]
+    taxonomy_name: str, taxonomy_type: str, labels: List[str], update: bool
 ) -> dict:
     return {
         TAXONOMY_NAME_KEY: taxonomy_name,
         TYPE_KEY: taxonomy_type,
         LABELS_KEY: labels,
+        UPDATE_KEY: update,
     }