def _delete_fields(cls, paths, error_level=0):
        """Deletes the field(s) from the documents in this collection.

        Args:
            paths: an iterable of field names or ``embedded.field.names``
            error_level (0): the error level to use. Valid values are:

            -   0: raise error if a field cannot be deleted
            -   1: log warning if a field cannot be deleted
            -   2: ignore fields that cannot be deleted
        """
        dataset = cls._dataset
        dataset_doc = dataset._doc
        media_type = dataset.media_type
        is_frame_field = cls._is_frames_doc

        paths = _remove_nested_paths(paths)

        del_paths = []
        del_schema_paths = []

        for path in paths:
            field, is_default = cls._get_field(
                path, allow_missing=True, check_default=True
            )

            if field is None:
                if "." in path:
                    # Allow for dynamic embedded fields
                    del_paths.append(path)
                else:
                    fou.handle_error(
                        AttributeError(
                            "%s field '%s' does not exist"
                            % (cls._doc_name(), path)
                        ),
                        error_level,
                    )

                continue

            if is_default:
                fou.handle_error(
                    ValueError(
                        "Cannot delete default %s field '%s'"
                        % (cls._doc_name().lower(), path)
                    ),
                    error_level,
                )
                continue

            if field is not None and getattr(field, "read_only", False):
                raise ValueError(
                    "Cannot delete read-only %s field '%s'"
                    % (cls._doc_name().lower(), path)
                )

            if (
                media_type == fom.GROUP
                and not is_frame_field
                and path == dataset.group_field
            ):
                media_types = list(set(dataset_doc.group_media_types.values()))
                if len(media_types) > 1:
                    fou.handle_error(
                        ValueError(
                            "Cannot delete group field '%s' of a grouped "
                            "dataset that contains multiple media types" % path
                        ),
                        error_level,
                    )
                    continue

                dataset._group_slice = None
                dataset_doc.group_field = None
                dataset_doc.default_group_slice = None
                dataset_doc.group_media_types = {}
                dataset_doc.media_type = media_types[0]

            del_paths.append(path)
            del_schema_paths.append(path)

        if not del_paths:
            return

        cls._delete_fields_simple(del_paths)

        # This fixes https://github.com/voxel51/fiftyone/issues/3185
        # @todo improve list field updates in general so this isn't necessary
        if del_schema_paths:
            cls._reload_fields()

        for del_path in del_schema_paths:
            cls._delete_field_schema(del_path)

        if is_frame_field:
            del_paths = [dataset._FRAMES_PREFIX + p for p in del_paths]

        dataset_doc.app_config._delete_paths(del_paths)
        dataset_doc.save()

        if del_paths:
            cls._delete_indexes(del_paths)
Deletes the field(s) from the documents in this collection.

        Args:
            paths: an iterable of field names or ``embedded.field.names``
            error_level (0): the error level to use. Valid values are:

            -   0: raise error if a field cannot be deleted
            -   1: log warning if a field cannot be deleted
            -   2: ignore fields that cannot be deleted
        
fiftyone/core/odm/mixins.py