orca-sdk 0.0.78__py3-none-any.whl

orca_sdk/memoryset_test.py

@@ -0,0 +1,287 @@
+from uuid import uuid4
+
+import pytest
+from datasets.arrow_dataset import Dataset
+
+from .datasource import Datasource
+from .embedding_model import PretrainedEmbeddingModel
+from .memoryset import LabeledMemoryset, TaskStatus
+
+
+def test_create_memoryset(memoryset: LabeledMemoryset, hf_dataset: Dataset, label_names: list[str]):
+    assert memoryset is not None
+    assert memoryset.name == "test_memoryset"
+    assert memoryset.embedding_model == PretrainedEmbeddingModel.GTE_BASE
+    assert memoryset.label_names == label_names
+    assert memoryset.insertion_status == TaskStatus.COMPLETED
+    assert isinstance(memoryset.length, int)
+    assert memoryset.length == len(hf_dataset)
+
+
+def test_create_memoryset_unauthenticated(unauthenticated, datasource):
+    with pytest.raises(ValueError, match="Invalid API key"):
+        LabeledMemoryset.create("test_memoryset", datasource)
+
+
+def test_create_memoryset_invalid_input(datasource):
+    # invalid name
+    with pytest.raises(ValueError, match=r"Invalid input:.*"):
+        LabeledMemoryset.create("test memoryset", datasource)
+    # invalid datasource
+    datasource.id = str(uuid4())
+    with pytest.raises(ValueError, match=r"Invalid input:.*"):
+        LabeledMemoryset.create("test_memoryset_invalid_datasource", datasource)
+
+
+def test_create_memoryset_already_exists_error(hf_dataset, label_names, memoryset):
+    with pytest.raises(ValueError):
+        LabeledMemoryset.from_hf_dataset("test_memoryset", hf_dataset, label_names=label_names, value_column="text")
+    with pytest.raises(ValueError):
+        LabeledMemoryset.from_hf_dataset(
+            "test_memoryset", hf_dataset, label_names=label_names, value_column="text", if_exists="error"
+        )
+
+
+def test_create_memoryset_already_exists_open(hf_dataset, label_names, memoryset):
+    # invalid label names
+    with pytest.raises(ValueError):
+        LabeledMemoryset.from_hf_dataset(
+            memoryset.name,
+            hf_dataset,
+            label_names=["turtles", "frogs"],
+            value_column="text",
+            if_exists="open",
+        )
+    # different embedding model
+    with pytest.raises(ValueError):
+        LabeledMemoryset.from_hf_dataset(
+            memoryset.name,
+            hf_dataset,
+            label_names=label_names,
+            embedding_model=PretrainedEmbeddingModel.DISTILBERT,
+            if_exists="open",
+        )
+    opened_memoryset = LabeledMemoryset.from_hf_dataset(
+        memoryset.name,
+        hf_dataset,
+        embedding_model=PretrainedEmbeddingModel.GTE_BASE,
+        if_exists="open",
+    )
+    assert opened_memoryset is not None
+    assert opened_memoryset.name == memoryset.name
+    assert opened_memoryset.length == len(hf_dataset)
+
+
+def test_open_memoryset(memoryset, hf_dataset):
+    fetched_memoryset = LabeledMemoryset.open(memoryset.name)
+    assert fetched_memoryset is not None
+    assert fetched_memoryset.name == memoryset.name
+    assert fetched_memoryset.length == len(hf_dataset)
+
+
+def test_open_memoryset_unauthenticated(unauthenticated, memoryset):
+    with pytest.raises(ValueError, match="Invalid API key"):
+        LabeledMemoryset.open(memoryset.name)
+
+
+def test_open_memoryset_not_found():
+    with pytest.raises(LookupError):
+        LabeledMemoryset.open(str(uuid4()))
+
+
+def test_open_memoryset_invalid_input():
+    with pytest.raises(ValueError, match=r"Invalid input:.*"):
+        LabeledMemoryset.open("not valid id")
+
+
+def test_open_memoryset_unauthorized(unauthorized, memoryset):
+    with pytest.raises(LookupError):
+        LabeledMemoryset.open(memoryset.name)
+
+
+def test_all_memorysets(memoryset):
+    memorysets = LabeledMemoryset.all()
+    assert len(memorysets) > 0
+    assert any(memoryset.name == memoryset.name for memoryset in memorysets)
+
+
+def test_all_memorysets_unauthenticated(unauthenticated):
+    with pytest.raises(ValueError, match="Invalid API key"):
+        LabeledMemoryset.all()
+
+
+def test_all_memorysets_unauthorized(unauthorized, memoryset):
+    assert memoryset not in LabeledMemoryset.all()
+
+
+def test_drop_memoryset(hf_dataset):
+    memoryset = LabeledMemoryset.from_hf_dataset(
+        "test_memoryset_delete",
+        hf_dataset.select(range(1)),
+        value_column="text",
+    )
+    assert LabeledMemoryset.exists(memoryset.name)
+    LabeledMemoryset.drop(memoryset.name)
+    assert not LabeledMemoryset.exists(memoryset.name)
+
+
+def test_drop_memoryset_unauthenticated(unauthenticated, memoryset):
+    with pytest.raises(ValueError, match="Invalid API key"):
+        LabeledMemoryset.drop(memoryset.name)
+
+
+def test_drop_memoryset_not_found(memoryset):
+    with pytest.raises(LookupError):
+        LabeledMemoryset.drop(str(uuid4()))
+    # ignores error if specified
+    LabeledMemoryset.drop(str(uuid4()), if_not_exists="ignore")
+
+
+def test_drop_memoryset_unauthorized(unauthorized, memoryset):
+    with pytest.raises(LookupError):
+        LabeledMemoryset.drop(memoryset.name)
+
+
+def test_search(memoryset: LabeledMemoryset):
+    memory_lookups = memoryset.search(["i love soup", "cats are cute"])
+    assert len(memory_lookups) == 2
+    assert len(memory_lookups[0]) == 1
+    assert len(memory_lookups[1]) == 1
+    assert memory_lookups[0][0].label == 0
+    assert memory_lookups[1][0].label == 1
+
+
+def test_search_count(memoryset: LabeledMemoryset):
+    memory_lookups = memoryset.search("i love soup", count=3)
+    assert len(memory_lookups) == 3
+    assert memory_lookups[0].label == 0
+    assert memory_lookups[1].label == 0
+    assert memory_lookups[2].label == 0
+
+
+def test_get_memory_at_index(memoryset: LabeledMemoryset, hf_dataset: Dataset, label_names: list[str]):
+    memory = memoryset[0]
+    assert memory.value == hf_dataset[0]["text"]
+    assert memory.label == hf_dataset[0]["label"]
+    assert memory.label_name == label_names[hf_dataset[0]["label"]]
+    assert memory.source_id == hf_dataset[0]["source_id"]
+    assert memory.score == hf_dataset[0]["score"]
+    assert memory.key == hf_dataset[0]["key"]
+    last_memory = memoryset[-1]
+    assert last_memory.value == hf_dataset[-1]["text"]
+    assert last_memory.label == hf_dataset[-1]["label"]
+
+
+def test_get_range_of_memories(memoryset: LabeledMemoryset, hf_dataset: Dataset):
+    memories = memoryset[1:3]
+    assert len(memories) == 2
+    assert memories[0].value == hf_dataset["text"][1]
+    assert memories[1].value == hf_dataset["text"][2]
+
+
+def test_get_memory_by_id(memoryset: LabeledMemoryset, hf_dataset: Dataset):
+    memory = memoryset.get(memoryset[0].memory_id)
+    assert memory.value == hf_dataset[0]["text"]
+    assert memory == memoryset[memory.memory_id]
+
+
+def test_get_memories_by_id(memoryset: LabeledMemoryset, hf_dataset: Dataset):
+    memories = memoryset.get([memoryset[0].memory_id, memoryset[1].memory_id])
+    assert len(memories) == 2
+    assert memories[0].value == hf_dataset[0]["text"]
+    assert memories[1].value == hf_dataset[1]["text"]
+
+
+def test_query_memoryset(memoryset: LabeledMemoryset):
+    memories = memoryset.query(filters=[("label", "==", 1)])
+    assert len(memories) == 3
+    assert all(memory.label == 1 for memory in memories)
+    assert len(memoryset.query(limit=2)) == 2
+    assert len(memoryset.query(filters=[("metadata.key", "==", "val1")])) == 1
+
+
+def test_insert_memories(memoryset: LabeledMemoryset):
+    prev_length = memoryset.length
+    memoryset.insert(
+        [
+            dict(value="tomato soup is my favorite", label=0),
+            dict(value="cats are fun to play with", label=1),
+        ]
+    )
+    assert memoryset.length == prev_length + 2
+    memoryset.insert(dict(value="tomato soup is my favorite", label=0, key="test", source_id="test"))
+    assert memoryset.length == prev_length + 3
+    last_memory = memoryset[-1]
+    assert last_memory.value == "tomato soup is my favorite"
+    assert last_memory.label == 0
+    assert last_memory.metadata
+    assert last_memory.metadata["key"] == "test"
+    assert last_memory.source_id == "test"
+
+
+def test_update_memory(memoryset: LabeledMemoryset, hf_dataset: Dataset):
+    memory_id = memoryset[0].memory_id
+    updated_memory = memoryset.update(dict(memory_id=memory_id, value="i love soup so much"))
+    assert updated_memory.value == "i love soup so much"
+    assert updated_memory.label == hf_dataset[0]["label"]
+    assert memoryset.get(memory_id).value == "i love soup so much"
+
+
+def test_update_memory_instance(memoryset: LabeledMemoryset, hf_dataset: Dataset):
+    memory = memoryset[0]
+    updated_memory = memory.update(value="i love soup even more")
+    assert updated_memory is memory
+    assert memory.value == "i love soup even more"
+    assert memory.label == hf_dataset[0]["label"]
+
+
+def test_update_memories(memoryset: LabeledMemoryset):
+    memory_ids = [memory.memory_id for memory in memoryset[:2]]
+    updated_memories = memoryset.update(
+        [
+            dict(memory_id=memory_ids[0], value="i love soup so much"),
+            dict(memory_id=memory_ids[1], value="cats are so cute"),
+        ]
+    )
+    assert updated_memories[0].value == "i love soup so much"
+    assert updated_memories[1].value == "cats are so cute"
+
+
+def test_delete_memory(memoryset: LabeledMemoryset):
+    prev_length = memoryset.length
+    memory_id = memoryset[0].memory_id
+    memoryset.delete(memory_id)
+    with pytest.raises(LookupError):
+        memoryset.get(memory_id)
+    assert memoryset.length == prev_length - 1
+
+
+def test_delete_memories(memoryset: LabeledMemoryset):
+    prev_length = memoryset.length
+    memoryset.delete([memoryset[0].memory_id, memoryset[1].memory_id])
+    assert memoryset.length == prev_length - 2
+
+
+def test_clone_memoryset(memoryset: LabeledMemoryset):
+    cloned_memoryset = memoryset.clone("test_cloned_memoryset", embedding_model=PretrainedEmbeddingModel.DISTILBERT)
+    assert cloned_memoryset is not None
+    assert cloned_memoryset.name == "test_cloned_memoryset"
+    assert cloned_memoryset.length == memoryset.length
+    assert cloned_memoryset.embedding_model == PretrainedEmbeddingModel.DISTILBERT
+    assert cloned_memoryset.insertion_status == TaskStatus.COMPLETED
+
+
+def test_embedding_evaluation(hf_dataset):
+    datasource = Datasource.from_hf_dataset("eval_datasource", hf_dataset, if_exists="open")
+    response = LabeledMemoryset.run_embedding_evaluation(
+        datasource, embedding_models=["CDE_SMALL"], neighbor_count=2, value_column="text"
+    )
+    assert response is not None
+    assert isinstance(response, dict)
+    assert response is not None
+    assert isinstance(response["evaluation_results"], list)
+    assert len(response["evaluation_results"]) == 1
+    assert response["evaluation_results"][0] is not None
+    assert response["evaluation_results"][0]["embedding_model_name"] == "CDE_SMALL"
+    assert response["evaluation_results"][0]["embedding_model_path"] == "OrcaDB/cde-small-v1"
+    Datasource.drop("eval_datasource")

orca_sdk/telemetry.py

@@ -0,0 +1,398 @@
+from __future__ import annotations
+
+import logging
+from datetime import datetime
+from typing import TYPE_CHECKING, Any, Iterable, overload
+from uuid import UUID
+
+from orca_sdk._utils.common import UNSET
+
+from ._generated_api_client.api import (
+    drop_feedback_category_with_data,
+    get_prediction,
+    list_feedback_categories,
+    list_predictions,
+    record_prediction_feedback,
+    update_prediction,
+)
+from ._generated_api_client.models import (
+    FeedbackType,
+    LabelPredictionWithMemoriesAndFeedback,
+    ListPredictionsRequest,
+    PredictionFeedbackCategory,
+    PredictionFeedbackRequest,
+    UpdatePredictionRequest,
+)
+from ._generated_api_client.types import UNSET as CLIENT_UNSET
+from ._utils.prediction_result_ui import inspect_prediction_result
+from .memoryset import LabeledMemoryLookup, LabeledMemoryset
+
+if TYPE_CHECKING:
+    from .classification_model import ClassificationModel
+
+
+def _parse_feedback(feedback: dict[str, Any]) -> PredictionFeedbackRequest:
+    category = feedback.get("category", None)
+    if category is None:
+        raise ValueError("`category` must be specified")
+    prediction_id = feedback.get("prediction_id", None)
+    if prediction_id is None:
+        raise ValueError("`prediction_id` must be specified")
+    return PredictionFeedbackRequest(
+        prediction_id=prediction_id,
+        category_name=category,
+        value=feedback.get("value", CLIENT_UNSET),
+        comment=feedback.get("comment", CLIENT_UNSET),
+    )
+
+
+class FeedbackCategory:
+    """
+    A category of feedback for predictions.
+
+    Categories are created automatically, the first time feedback with a new name is recorded.
+    The value type of the category is inferred from the first recorded value. Subsequent feedback
+    for the same category must be of the same type. Categories are not model specific.
+
+    Attributes:
+        id: Unique identifier for the category.
+        name: Name of the category.
+        value_type: Type that values for this category must have.
+        created_at: When the category was created.
+    """
+
+    id: str
+    name: str
+    value_type: type[bool] | type[float]
+    created_at: datetime
+
+    def __init__(self, category: PredictionFeedbackCategory):
+        # for internal use only, do not document
+        self.id = category.id
+        self.name = category.name
+        self.value_type = bool if category.type == FeedbackType.BINARY else float
+        self.created_at = category.created_at
+
+    @classmethod
+    def all(cls) -> list[FeedbackCategory]:
+        """
+        Get a list of all existing feedback categories.
+
+        Returns:
+            List with information about all existing feedback categories.
+        """
+        return [FeedbackCategory(category) for category in list_feedback_categories()]
+
+    @classmethod
+    def drop(cls, name: str) -> None:
+        """
+        Drop all feedback for this category and drop the category itself, allowing it to be
+        recreated with a different value type.
+
+        Warning:
+            This will delete all feedback in this category across all models.
+
+        Params:
+            name: Name of the category to drop.
+
+        Raises:
+            LookupError: If the category is not found.
+        """
+        drop_feedback_category_with_data(name)
+        logging.info(f"Deleted feedback category {name} with all associated feedback")
+
+    def __repr__(self):
+        return "FeedbackCategory({" + f"name: {self.name}, " + f"value_type: {self.value_type}" + "})"
+
+
+class LabelPrediction:
+    """
+    A prediction made by a model
+
+    Attributes:
+        prediction_id: Unique identifier for the prediction
+        label: Predicted label for the input value
+        label_name: Name of the predicted label
+        confidence: Confidence of the prediction
+        anomaly_score: The score for how anomalous the input is relative to the memories
+        memory_lookups: List of memories used to ground the prediction
+        input_value: Input value that this prediction was for
+        model: Model that was used to make the prediction
+        memoryset: Memoryset that was used to lookup memories to ground the prediction
+        expected_label: Optional expected label that was set for the prediction
+        tags: tags that were set for the prediction
+        feedback: Feedback recorded, mapping from category name to value
+    """
+
+    prediction_id: str
+    label: int
+    label_name: str | None
+    confidence: float
+    anomaly_score: float | None
+    memoryset: LabeledMemoryset
+    model: ClassificationModel
+
+    def __init__(
+        self,
+        prediction_id: str,
+        *,
+        label: int,
+        label_name: str | None,
+        confidence: float,
+        anomaly_score: float | None,
+        memoryset: LabeledMemoryset | str,
+        model: ClassificationModel | str,
+        telemetry: LabelPredictionWithMemoriesAndFeedback | None = None,
+    ):
+        # for internal use only, do not document
+        from .classification_model import ClassificationModel
+
+        self.prediction_id = prediction_id
+        self.label = label
+        self.label_name = label_name
+        self.confidence = confidence
+        self.anomaly_score = anomaly_score
+        self.memoryset = LabeledMemoryset.open(memoryset) if isinstance(memoryset, str) else memoryset
+        self.model = ClassificationModel.open(model) if isinstance(model, str) else model
+        self.__telemetry = telemetry if telemetry else None
+
+    def __repr__(self):
+        return (
+            "LabelPrediction({"
+            + f"label: <{self.label_name}: {self.label}>, "
+            + f"confidence: {self.confidence:.2f}, "
+            + f"anomaly_score: {self.anomaly_score:.2f}, "
+            if self.anomaly_score is not None
+            else ""
+            + f"input_value: '{str(self.input_value)[:100] + '...' if len(str(self.input_value)) > 100 else self.input_value}'"
+            + "})"
+        )
+
+    @property
+    def _telemetry(self) -> LabelPredictionWithMemoriesAndFeedback:
+        # for internal use only, do not document
+        if self.__telemetry is None:
+            self.__telemetry = get_prediction(prediction_id=UUID(self.prediction_id))
+        return self.__telemetry
+
+    @property
+    def memory_lookups(self) -> list[LabeledMemoryLookup]:
+        return [LabeledMemoryLookup(self.memoryset.id, lookup) for lookup in self._telemetry.memories]
+
+    @property
+    def input_value(self) -> str | None:
+        return self._telemetry.input_value
+
+    @property
+    def feedback(self) -> dict[str, bool | float]:
+        return {
+            f.category_name: (
+                f.value if f.category_type == FeedbackType.CONTINUOUS else True if f.value == 1 else False
+            )
+            for f in self._telemetry.feedbacks
+        }
+
+    @property
+    def expected_label(self) -> int | None:
+        return self._telemetry.expected_label
+
+    @property
+    def tags(self) -> set[str]:
+        return set(self._telemetry.tags)
+
+    @overload
+    @classmethod
+    def get(cls, prediction_id: str) -> LabelPrediction:  # type: ignore -- this takes precedence
+        pass
+
+    @overload
+    @classmethod
+    def get(cls, prediction_id: Iterable[str]) -> list[LabelPrediction]:
+        pass
+
+    @classmethod
+    def get(cls, prediction_id: str | Iterable[str]) -> LabelPrediction | list[LabelPrediction]:
+        """
+        Fetch a prediction or predictions
+
+        Params:
+            prediction_id: Unique identifier of the prediction or predictions to fetch
+
+        Returns:
+            Prediction or list of predictions
+
+        Raises:
+            LookupError: If no prediction with the given id is found
+
+        Examples:
+            Fetch a single prediction:
+            >>> LabelPrediction.get("0195019a-5bc7-7afb-b902-5945ee1fb766")
+            LabelPrediction({
+                label: <positive: 1>,
+                confidence: 0.95,
+                anomaly_score: 0.1,
+                input_value: "I am happy",
+                memoryset: "my_memoryset",
+                model: "my_model"
+            })
+
+            Fetch multiple predictions:
+            >>> LabelPrediction.get([
+            ...     "0195019a-5bc7-7afb-b902-5945ee1fb766",
+            ...     "019501a1-ea08-76b2-9f62-95e4800b4841",
+            ... ])
+            [
+                LabelPrediction({
+                    label: <positive: 1>,
+                    confidence: 0.95,
+                    anomaly_score: 0.1,
+                    input_value: "I am happy",
+                    memoryset: "my_memoryset",
+                    model: "my_model"
+                }),
+                LabelPrediction({
+                    label: <negative: 0>,
+                    confidence: 0.05,
+                    anomaly_score: 0.2,
+                    input_value: "I am sad",
+                    memoryset: "my_memoryset", model: "my_model"
+                }),
+            ]
+        """
+        if isinstance(prediction_id, str):
+            prediction = get_prediction(prediction_id=UUID(prediction_id))
+            return cls(
+                prediction_id=prediction.prediction_id,
+                label=prediction.label,
+                label_name=prediction.label_name,
+                confidence=prediction.confidence,
+                anomaly_score=prediction.anomaly_score,
+                memoryset=prediction.memoryset_id,
+                model=prediction.model_id,
+                telemetry=prediction,
+            )
+        else:
+            return [
+                cls(
+                    prediction_id=prediction.prediction_id,
+                    label=prediction.label,
+                    label_name=prediction.label_name,
+                    confidence=prediction.confidence,
+                    anomaly_score=prediction.anomaly_score,
+                    memoryset=prediction.memoryset_id,
+                    model=prediction.model_id,
+                    telemetry=prediction,
+                )
+                for prediction in list_predictions(body=ListPredictionsRequest(prediction_ids=list(prediction_id)))
+            ]
+
+    def refresh(self):
+        """Refresh the prediction data from the OrcaCloud"""
+        self.__dict__.update(LabelPrediction.get(self.prediction_id).__dict__)
+
+    def inspect(self):
+        """Open a UI to inspect the memories used by this prediction"""
+        inspect_prediction_result(self)
+
+    def update(self, *, expected_label: int | None = UNSET, tags: set[str] | None = UNSET) -> None:
+        """
+        Update editable prediction properties.
+
+        Params:
+            expected_label: Value to set for the expected label, defaults to `[UNSET]` if not provided.
+            tags: Value to replace existing tags with, defaults to `[UNSET]` if not provided.
+
+        Examples:
+            Update the expected label:
+            >>> prediction.update(expected_label=1)
+
+            Add a new tag:
+            >>> prediction.update(tags=prediction.tags | {"new_tag"})
+
+            Remove expected label and tags:
+            >>> prediction.update(expected_label=None, tags=None)
+        """
+        update_prediction(
+            prediction_id=self.prediction_id,
+            body=UpdatePredictionRequest(
+                expected_label=expected_label if expected_label is not UNSET else CLIENT_UNSET,
+                tags=[] if tags is None else list(tags) if tags is not UNSET else CLIENT_UNSET,
+            ),
+        )
+        self.refresh()
+
+    def add_tag(self, tag: str) -> None:
+        """
+        Add a tag to the prediction
+
+        Params:
+            tag: Tag to add to the prediction
+        """
+        self.update(tags=self.tags | {tag})
+
+    def remove_tag(self, tag: str) -> None:
+        """
+        Remove a tag from the prediction
+
+        Params:
+            tag: Tag to remove from the prediction
+        """
+        self.update(tags=self.tags - {tag})
+
+    def record_feedback(
+        self,
+        category: str,
+        value: bool | float,
+        *,
+        comment: str | None = None,
+    ):
+        """
+        Record feedback for the prediction.
+
+        We support recording feedback in several categories for each prediction. A
+        [`FeedbackCategory`][orca_sdk.telemetry.FeedbackCategory] is created automatically,
+        the first time feedback with a new name is recorded. Categories are global across models.
+        The value type of the category is inferred from the first recorded value. Subsequent
+        feedback for the same category must be of the same type.
+
+        Params:
+            category: Name of the category under which to record the feedback.
+            value: Feedback value to record, should be `True` for positive feedback and `False` for
+                negative feedback or a [`float`][float] between `-1.0` and `+1.0` where negative
+                values indicate negative feedback and positive values indicate positive feedback.
+            comment: Optional comment to record with the feedback.
+
+        Examples:
+            Record whether a suggestion was accepted or rejected:
+            >>> prediction.record_feedback("accepted", True)
+
+            Record star rating as normalized continuous score between `-1.0` and `+1.0`:
+            >>> prediction.record_feedback("rating", -0.5, comment="2 stars")
+
+        Raises:
+            ValueError: If the value does not match previous value types for the category, or is a
+                [`float`][float] that is not between `-1.0` and `+1.0`.
+        """
+        record_prediction_feedback(
+            body=[
+                _parse_feedback(
+                    {"prediction_id": self.prediction_id, "category": category, "value": value, "comment": comment}
+                )
+            ]
+        )
+        self.refresh()
+
+    def delete_feedback(self, category: str) -> None:
+        """
+        Delete prediction feedback for a specific category.
+
+        Params:
+            category: Name of the category of the feedback to delete.
+
+        Raises:
+            ValueError: If the category is not found.
+        """
+        record_prediction_feedback(
+            body=[PredictionFeedbackRequest(prediction_id=self.prediction_id, category_name=category, value=None)]
+        )
+        self.refresh()