Skip to content

View models#

Trace #

Bases: Generic[T], HashableBaseModel

Universal structure for storing prediction traces and training data.

Attributes:

Name Type Description
trace_id str

UUID4 identifier for uniquely referring to a trace.
created str

Timestamp of its (original) construction.
original_execution_time_ms float

Wall-time elapsed while its generating TracingContext was alive.
logged_values Dict[str, Any]

Values persisted through using @parameter or log_metric().
models List[Model]

Marks left by each encountered @use_model decorated function.
exception Optional[str]

Exception description if any was encountered.
output Optional[T]

Return value of the function wrapped by GreatAI.
feedback Any

Feedback obtained using the REST API of add_ground_truth.
tags List[str]

Tags used for filtering traces. Contains the name of the original function, value of ENVIRONMENT, its split if has any, and either ground_truth or online depending on the origin of the Trace.
Source code in great_ai/views/trace.py 
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
class Trace(Generic[T], HashableBaseModel):
    """Universal structure for storing prediction traces and training data.

    Attributes:
        trace_id: UUID4 identifier for uniquely referring to a trace.
        created: Timestamp of its (original) construction.
        original_execution_time_ms: Wall-time elapsed while its generating
            TracingContext was alive.
        logged_values: Values persisted through using `@parameter` or `log_metric()`.
        models: Marks left by each encountered `@use_model` decorated function.
        exception: Exception description if any was encountered.
        output: Return value of the function wrapped by GreatAI.
        feedback: Feedback obtained using the REST API of `add_ground_truth`.
        tags: Tags used for filtering traces. Contains the name of the original
            function, value of `ENVIRONMENT`, its split if has any, and either
            `ground_truth` or `online` depending on the origin of the Trace.
    """

    trace_id: str
    created: str
    original_execution_time_ms: float
    logged_values: Dict[str, Any]
    models: List[Model]
    exception: Optional[str]
    output: Optional[T]
    feedback: Any = None
    tags: List[str]

    class Config:
        extra = Extra.ignore

    @property
    def input(self) -> Any:
        return (
            self.logged_values["input"]
            if list(self.logged_values.keys()) == ["input"]
            else self.logged_values
        )

    @property
    def models_flat(self) -> str:
        return ", ".join(f"{m.key}:{m.version}" for m in self.models)

    @property
    def output_flat(self) -> str:
        return pformat(self.output, indent=2, compact=True)

    @property
    def exception_flat(self) -> str:
        return (
            "null"
            if self.exception is None
            else pformat(self.exception, indent=2, compact=True)
        )

    @property
    def feedback_flat(self) -> str:
        return (
            "null"
            if self.feedback is None
            else pformat(self.feedback, indent=2, compact=True)
        )

    @property
    def tags_flat(self) -> str:
        return ",\n".join(self.tags)

    def to_flat_dict(self, include_original: bool = True) -> Dict[str, Any]:
        return {
            **(
                self.dict()
                if include_original
                else {
                    "trace_id": self.trace_id,
                    "created": self.created,
                    "original_execution_time_ms": self.original_execution_time_ms,
                }
            ),
            **{
                k: v
                if (isinstance(v, float) or isinstance(v, int))
                else pformat(v, indent=2, compact=True)
                for k, v in self.logged_values.items()
            },
            "models_flat": self.models_flat,
            "exception_flat": self.exception_flat,
            "output_flat": self.output_flat,
            "feedback_flat": self.feedback_flat,
            "tags_flat": self.tags_flat,
        }

    def __repr__(self) -> str:
        return f"""Trace[{type(self.output).__name__}]({
            pformat(self.dict(), indent=2, compact=True).replace('{ ', '{', 1)
        })"""

RouteConfig #

Bases: BaseModel

Source code in great_ai/views/route_config.py 
 4
 5
 6
 7
 8
 9
10
class RouteConfig(BaseModel):
    prediction_endpoint_enabled: bool = True
    docs_endpoints_enabled: bool = True
    dashboard_enabled: bool = True
    feedback_endpoints_enabled: bool = True
    trace_endpoints_enabled: bool = True
    meta_endpoints_enabled: bool = True

ClassificationOutput #

Bases: HashableBaseModel

Source code in great_ai/views/outputs/classification_output.py 
6
7
8
9
class ClassificationOutput(HashableBaseModel):
    label: Union[str, int]
    confidence: float
    explanation: Optional[Any]

MultiLabelClassificationOutput #

Bases: HashableBaseModel

Source code in great_ai/views/outputs/multi_label_classification_output.py 
7
8
class MultiLabelClassificationOutput(HashableBaseModel):
    labels: List[ClassificationOutput] = []

RegressionOutput #

Bases: HashableBaseModel

Source code in great_ai/views/outputs/regression_output.py 
6
7
8
class RegressionOutput(HashableBaseModel):
    value: Union[int, float]
    explanation: Optional[Any]

SequenceLabelingOutput #

Bases: HashableBaseModel

Source code in great_ai/views/outputs/sequence_labeling_output.py 
15
16
17
class SequenceLabelingOutput(HashableBaseModel):
    labeled_tokens: List[LabeledToken]
    explanation: Optional[Any]
Last update: July 13, 2022