arize-phoenix 4.5.0__py3-none-any.whl → 4.6.1__py3-none-any.whl

phoenix/core/model.py

@@ -7,73 +7,73 @@ from .embedding_dimension import EmbeddingDimension
 
 
 def _get_embedding_dimensions(
-    primary_dataset: Inferences, reference_dataset: Optional[Inferences]
+    primary_inferences: Inferences, reference_inferences: Optional[Inferences]
 ) -> List[EmbeddingDimension]:
     embedding_dimensions: List[EmbeddingDimension] = []
     embedding_features: EmbeddingFeatures = {}
 
     primary_embedding_features: Optional[EmbeddingFeatures] = (
-        primary_dataset.schema.embedding_feature_column_names
+        primary_inferences.schema.embedding_feature_column_names
     )
     if primary_embedding_features is not None:
         embedding_features.update(primary_embedding_features)
     primary_prompt_column_names: Optional[EmbeddingColumnNames] = (
-        primary_dataset.schema.prompt_column_names
+        primary_inferences.schema.prompt_column_names
     )
     if primary_prompt_column_names is not None:
         embedding_features.update({"prompt": primary_prompt_column_names})
     primary_response_column_names: Optional[Union[str, EmbeddingColumnNames]] = (
-        primary_dataset.schema.response_column_names
+        primary_inferences.schema.response_column_names
     )
     if isinstance(primary_response_column_names, EmbeddingColumnNames):
         embedding_features.update({"response": primary_response_column_names})
 
-    if reference_dataset is not None:
+    if reference_inferences is not None:
         reference_embedding_features: Optional[EmbeddingFeatures] = (
-            reference_dataset.schema.embedding_feature_column_names
+            reference_inferences.schema.embedding_feature_column_names
         )
         if reference_embedding_features is not None:
             embedding_features.update(reference_embedding_features)
         reference_prompt_column_names: Optional[EmbeddingColumnNames] = (
-            reference_dataset.schema.prompt_column_names
+            reference_inferences.schema.prompt_column_names
         )
         if reference_prompt_column_names is not None:
             embedding_features.update({"prompt": reference_prompt_column_names})
         reference_response_column_names: Optional[Union[str, EmbeddingColumnNames]] = (
-            reference_dataset.schema.response_column_names
+            reference_inferences.schema.response_column_names
         )
         if isinstance(reference_response_column_names, EmbeddingColumnNames):
             embedding_features.update({"response": reference_response_column_names})
 
     for embedding_feature, embedding_column_names in embedding_features.items():
         embedding_dimensions.append(EmbeddingDimension(name=embedding_feature))
-        if reference_dataset is not None:
-            _check_embedding_vector_lengths_match_across_datasets(
-                embedding_feature, embedding_column_names, primary_dataset, reference_dataset
+        if reference_inferences is not None:
+            _check_embedding_vector_lengths_match_across_inference_sets(
+                embedding_feature, embedding_column_names, primary_inferences, reference_inferences
             )
 
     return embedding_dimensions
 
 
-def _check_embedding_vector_lengths_match_across_datasets(
+def _check_embedding_vector_lengths_match_across_inference_sets(
     embedding_feature_name: str,
     embedding_column_names: EmbeddingColumnNames,
-    primary_dataset: Inferences,
-    reference_dataset: Inferences,
+    primary_inferences: Inferences,
+    reference_inferences: Inferences,
 ) -> None:
     """
     Ensure that for each embedding feature, the vector lengths match across the primary
-    and reference datasets which is required for calculating embedding drift (vector distance)
+    and reference inferences which is required for calculating embedding drift (vector distance)
     """
     primary_vector_length = _get_column_vector_length(
-        primary_dataset, embedding_column_names.vector_column_name
+        primary_inferences, embedding_column_names.vector_column_name
     )
     reference_vector_length = _get_column_vector_length(
-        reference_dataset, embedding_column_names.vector_column_name
+        reference_inferences, embedding_column_names.vector_column_name
     )
 
-    # if one of the datasets doesn't have the embedding column at all, which is fine since we
-    # just consider this as missing from one of the datasets and won't need to worry about
+    # if one of the inferences doesn't have the embedding column at all, which is fine since we
+    # just consider this as missing from one of the inferences and won't need to worry about
     # calculating drift
     if primary_vector_length is None or reference_vector_length is None:
         return
@@ -81,23 +81,23 @@ def _check_embedding_vector_lengths_match_across_datasets(
     if primary_vector_length != reference_vector_length:
         raise ValueError(
             f"Embedding vector length must match for "
-            f"both datasets; embedding_feature={embedding_feature_name} "
+            f"both inference sets; embedding_feature={embedding_feature_name} "
             f"vector_column={embedding_column_names.vector_column_name}"
         )
 
 
 def _get_column_vector_length(
-    dataset: Inferences, embedding_vector_column_name: str
+    inferences: Inferences, embedding_vector_column_name: str
 ) -> Optional[int]:
     """
-    Because a dataset has already been constructed, we can assume that the lengths
-    of the vectors for any given embedding feature in the dataset are the same.
+    Because a inferences has already been constructed, we can assume that the lengths
+    of the vectors for any given embedding feature in the inferences are the same.
     Returns the length a vector by getting the length first non-null vector.
     """
-    if embedding_vector_column_name not in dataset.dataframe:
+    if embedding_vector_column_name not in inferences.dataframe:
         return None
 
-    column = dataset.dataframe[embedding_vector_column_name]
+    column = inferences.dataframe[embedding_vector_column_name]
 
     for row in column:
         # None/NaN is a valid entry for a row and represents the fact that the

phoenix/core/model_schema.py

@@ -48,7 +48,7 @@ from pandas.core.dtypes.common import (
 from typing_extensions import TypeAlias, TypeGuard
 from wrapt import ObjectProxy
 
-from phoenix.config import GENERATED_DATASET_NAME_PREFIX
+from phoenix.config import GENERATED_INFERENCES_NAME_PREFIX
 from phoenix.datetime_utils import floor_to_minute
 
 
@@ -185,7 +185,7 @@ class RetrievalEmbedding(Embedding):
                 yield value
 
 
-class DatasetRole(Enum):
+class InferencesRole(Enum):
     """A dataframe's role in a Model: primary or reference (as
     baseline for drift).
     """
@@ -194,8 +194,8 @@ class DatasetRole(Enum):
     REFERENCE = auto()
 
 
-PRIMARY = DatasetRole.PRIMARY
-REFERENCE = DatasetRole.REFERENCE
+PRIMARY = InferencesRole.PRIMARY
+REFERENCE = InferencesRole.REFERENCE
 
 
 @dataclass(frozen=True, repr=False, eq=False)
@@ -381,7 +381,7 @@ class Dimension(Column, ABC):
             # But we really want the role to be specified for a Dimension.
             raise ValueError("role must be assigned")
 
-    def __getitem__(self, df_role: DatasetRole) -> "pd.Series[Any]":
+    def __getitem__(self, df_role: InferencesRole) -> "pd.Series[Any]":
         if self._model is None:
             return pd.Series(dtype=object)
         model = cast(Model, self._model)
@@ -416,7 +416,7 @@ class ScalarDimension(Dimension):
         if self._model is None or self.data_type is CONTINUOUS:
             return ()
         model = cast(Model, self._model)
-        return model.dimension_categories_from_all_datasets(self.name)
+        return model.dimension_categories_from_all_inferences(self.name)
 
 
 @dataclass(frozen=True)
@@ -582,7 +582,7 @@ class EventId(NamedTuple):
     """Identifies an event."""
 
     row_id: int = 0
-    dataset_id: DatasetRole = PRIMARY
+    inferences_id: InferencesRole = PRIMARY
 
     def __str__(self) -> str:
         return ":".join(map(str, self))
@@ -625,7 +625,7 @@ class Events(ModelData):
         self,
         df: pd.DataFrame,
         /,
-        role: DatasetRole,
+        role: InferencesRole,
         **kwargs: Any,
     ) -> None:
         super().__init__(df, **kwargs)
@@ -676,7 +676,7 @@ class Events(ModelData):
         return super().__getitem__(key)
 
 
-class Dataset(Events):
+class Inferences(Events):
     """pd.DataFrame wrapped with extra functions and metadata."""
 
     def __init__(
@@ -701,13 +701,13 @@ class Dataset(Events):
         friendly. Falls back to the role of the dataset if no name is provided.
         """
         ds_name = self._self_name
-        if ds_name.startswith(GENERATED_DATASET_NAME_PREFIX):
+        if ds_name.startswith(GENERATED_INFERENCES_NAME_PREFIX):
             # The generated names are UUIDs so use the role as the name
-            return "primary" if self.role is DatasetRole.PRIMARY else "reference"
+            return "primary" if self.role is InferencesRole.PRIMARY else "reference"
         return ds_name
 
     @property
-    def role(self) -> DatasetRole:
+    def role(self) -> InferencesRole:
         return self._self_role
 
     @property
@@ -746,14 +746,14 @@ class Model:
     a column of NaNs.
     """
 
-    _datasets: Dict[DatasetRole, Dataset]
+    _inference_sets: Dict[InferencesRole, Inferences]
     _dimensions: Dict[Name, Dimension]
     _dim_names_by_role: Dict[DimensionRole, List[Name]]
-    _original_columns_by_role: Dict[DatasetRole, "pd.Index[Any]"]
+    _original_columns_by_role: Dict[InferencesRole, "pd.Index[Any]"]
     _default_timestamps_factory: _ConstantValueSeriesFactory
     _nan_series_factory: _ConstantValueSeriesFactory
-    _dimension_categories_from_all_datasets: _Cache[Name, Tuple[str, ...]]
-    _dimension_min_max_from_all_datasets: _Cache[Name, Tuple[float, float]]
+    _dimension_categories_from_all_inferences: _Cache[Name, Tuple[str, ...]]
+    _dimension_min_max_from_all_inferences: _Cache[Name, Tuple[float, float]]
 
     def __init__(
         self,
@@ -769,12 +769,12 @@ class Model:
         # memoization
         object.__setattr__(
             self,
-            "_dimension_categories_from_all_datasets",
+            "_dimension_categories_from_all_inferences",
             _Cache[Name, "pd.Series[Any]"](),
         )
         object.__setattr__(
             self,
-            "_dimension_min_max_from_all_datasets",
+            "_dimension_min_max_from_all_inferences",
             _Cache[Name, Tuple[float, float]](),
         )
 
@@ -785,21 +785,21 @@ class Model:
         str_col_dfs = _coerce_str_column_names(dfs)
         padded_dfs = _add_padding(str_col_dfs, pd.DataFrame)
         padded_df_names = _add_padding(df_names, _rand_str)
-        datasets = starmap(
-            self._new_dataset,
-            zip(padded_dfs, padded_df_names, DatasetRole),
+        inference_sets = starmap(
+            self._new_inferences,
+            zip(padded_dfs, padded_df_names, InferencesRole),
         )
-        # Store datasets by role.
+        # Store inferences by role.
         object.__setattr__(
             self,
-            "_datasets",
-            {dataset.role: dataset for dataset in datasets},
+            "_inference_sets",
+            {inferences.role: inferences for inferences in inference_sets},
         )
         # Preserve originals, useful for exporting.
         object.__setattr__(
             self,
             "_original_columns_by_role",
-            {role: dataset.columns for role, dataset in self._datasets.items()},
+            {role: inferences.columns for role, inferences in self._inference_sets.items()},
         )
 
         object.__setattr__(
@@ -828,7 +828,7 @@ class Model:
                 (name, self._new_dimension(name, role=FEATURE))
                 for name in _get_omitted_column_names(
                     self._dimensions.values(),
-                    self._datasets.values(),
+                    self._inference_sets.values(),
                 )
             )
 
@@ -849,7 +849,7 @@ class Model:
                 data_type=(
                     _guess_data_type(
                         dataset.loc[:, dim.name]
-                        for dataset in self._datasets.values()
+                        for dataset in self._inference_sets.values()
                         if dim.name in dataset.columns
                     )
                 ),
@@ -859,9 +859,9 @@ class Model:
         # Add TIMESTAMP if missing.
         # If needed, normalize the timestamps values.
         # If needed, sort the dataframes by time.
-        for dataset_role, dataset in list(self._datasets.items()):
+        for inferences_role, dataset in list(self._inference_sets.items()):
             df = dataset.__wrapped__
-            df_original_columns = self._original_columns_by_role[dataset_role]
+            df_original_columns = self._original_columns_by_role[inferences_role]
 
             # PREDICTION_ID
             dim_pred_id = self._dimensions.get(
@@ -897,20 +897,20 @@ class Model:
             df = df.set_index(dim_time.name, drop=False)
 
             # Update dataset since its dataframe may have changed.
-            self._datasets[dataset_role] = self._new_dataset(
-                df, name=dataset.name, role=dataset_role
+            self._inference_sets[inferences_role] = self._new_inferences(
+                df, name=dataset.name, role=inferences_role
             )
 
     @cached_property
     def is_empty(self) -> bool:
         """Returns True if the model has no data."""
-        return not any(map(len, self._datasets.values()))
+        return not any(map(len, self._inference_sets.values()))
 
     def export_rows_as_parquet_file(
         self,
-        row_numbers: Mapping[DatasetRole, Iterable[int]],
+        row_numbers: Mapping[InferencesRole, Iterable[int]],
         parquet_file: BinaryIO,
-        cluster_ids: Optional[Mapping[DatasetRole, Mapping[int, str]]] = None,
+        cluster_ids: Optional[Mapping[InferencesRole, Mapping[int, str]]] = None,
     ) -> None:
         """
         Given row numbers, exports dataframe subset into parquet file.
@@ -921,29 +921,31 @@ class Model:
 
         Parameters
         ----------
-        row_numbers: Mapping[DatasetRole, Iterable[int]]
+        row_numbers: Mapping[InferencesRole, Iterable[int]]
             mapping of dataset role to list of row numbers
         parquet_file: file handle
             output parquet file handle
-        cluster_ids: Optional[Mapping[DatasetRole, Mapping[int, str]]]
-            mapping of dataset role to mapping of row number to cluster id.
+        cluster_ids: Optional[Mapping[InferencesRole, Mapping[int, str]]]
+            mapping of inferences role to mapping of row number to cluster id.
             If cluster_ids is non-empty, a new column is inserted to the
             dataframe containing the cluster IDs of each row in the exported
             data. The name of the added column name is `__phoenix_cluster_id__`.
         """
         export_dataframes = [pd.DataFrame()]
-        model_has_multiple_datasets = sum(not df.empty for df in self._datasets.values()) > 1
-        for dataset_role, numbers in row_numbers.items():
-            df = self._datasets[dataset_role]
+        model_has_multiple_inference_sets = (
+            sum(not df.empty for df in self._inference_sets.values()) > 1
+        )
+        for inferences_role, numbers in row_numbers.items():
+            df = self._inference_sets[inferences_role]
             columns = [
                 df.columns.get_loc(column_name)
-                for column_name in self._original_columns_by_role[dataset_role]
+                for column_name in self._original_columns_by_role[inferences_role]
             ]
             rows = pd.Series(sorted(set(numbers)))
             filtered_df = df.iloc[rows, columns].reset_index(drop=True)
-            if model_has_multiple_datasets:
+            if model_has_multiple_inference_sets:
                 filtered_df["__phoenix_dataset_name__"] = df.display_name
-            if cluster_ids and (ids := cluster_ids.get(dataset_role)):
+            if cluster_ids and (ids := cluster_ids.get(inferences_role)):
                 filtered_df["__phoenix_cluster_id__"] = rows.apply(ids.get)
             export_dataframes.append(filtered_df)
         pd.concat(export_dataframes).to_parquet(
@@ -977,24 +979,24 @@ class Model:
             if not dim.is_dummy and isinstance(dim, EmbeddingDimension)
         )
 
-    def dimension_categories_from_all_datasets(
+    def dimension_categories_from_all_inferences(
         self,
         dimension_name: Name,
     ) -> Tuple[str, ...]:
         dim = self[dimension_name]
         if dim.data_type is CONTINUOUS:
             return cast(Tuple[str, ...], ())
-        with self._dimension_categories_from_all_datasets() as cache:
+        with self._dimension_categories_from_all_inferences() as cache:
             try:
                 return cache[dimension_name]
             except KeyError:
                 pass
         categories_by_dataset = (
-            pd.Series(dim[role].unique()).dropna().astype(str) for role in DatasetRole
+            pd.Series(dim[role].unique()).dropna().astype(str) for role in InferencesRole
         )
         all_values_combined = chain.from_iterable(categories_by_dataset)
         ans = tuple(np.sort(pd.Series(all_values_combined).unique()))
-        with self._dimension_categories_from_all_datasets() as cache:
+        with self._dimension_categories_from_all_inferences() as cache:
             cache[dimension_name] = ans
         return ans
 
@@ -1005,24 +1007,24 @@ class Model:
         dim = self[dimension_name]
         if dim.data_type is not CONTINUOUS:
             return (np.nan, np.nan)
-        with self._dimension_min_max_from_all_datasets() as cache:
+        with self._dimension_min_max_from_all_inferences() as cache:
             try:
                 return cache[dimension_name]
             except KeyError:
                 pass
-        min_max_by_df = (_agg_min_max(dim[df_role]) for df_role in DatasetRole)
+        min_max_by_df = (_agg_min_max(dim[df_role]) for df_role in InferencesRole)
         all_values_combined = chain.from_iterable(min_max_by_df)
         min_max = _agg_min_max(pd.Series(all_values_combined))
         ans = (min_max.min(), min_max.max())
-        with self._dimension_min_max_from_all_datasets() as cache:
+        with self._dimension_min_max_from_all_inferences() as cache:
             cache[dimension_name] = ans
         return ans
 
     @overload
-    def __getitem__(self, key: Type[Dataset]) -> Iterator[Dataset]: ...
+    def __getitem__(self, key: Type[Inferences]) -> Iterator[Inferences]: ...
 
     @overload
-    def __getitem__(self, key: DatasetRole) -> Dataset: ...
+    def __getitem__(self, key: InferencesRole) -> Inferences: ...
 
     @overload
     def __getitem__(self, key: ColumnKey) -> Dimension: ...
@@ -1049,10 +1051,10 @@ class Model:
     ) -> Iterator[Dimension]: ...
 
     def __getitem__(self, key: Any) -> Any:
-        if key is Dataset:
-            return self._datasets.values()
-        if isinstance(key, DatasetRole):
-            return self._datasets[key]
+        if key is Inferences:
+            return self._inference_sets.values()
+        if isinstance(key, InferencesRole):
+            return self._inference_sets[key]
         if _is_column_key(key):
             return self._get_dim(key)
         if _is_multi_dimension_key(key):
@@ -1152,17 +1154,17 @@ class Model:
             )
         raise ValueError(f"invalid argument: {repr(obj)}")
 
-    def _new_dataset(
+    def _new_inferences(
         self,
         df: pd.DataFrame,
         /,
         name: str,
-        role: DatasetRole,
-    ) -> Dataset:
-        """Creates a new Dataset, setting the model weak reference to the
+        role: InferencesRole,
+    ) -> Inferences:
+        """Creates a new Inferences, setting the model weak reference to the
         `self` Model instance.
         """
-        return Dataset(df, name=name, role=role, _model=proxy(self))
+        return Inferences(df, name=name, role=role, _model=proxy(self))
 
 
 @dataclass(frozen=True)
@@ -1344,7 +1346,7 @@ def _series_uuid(length: int) -> "pd.Series[str]":
 
 
 def _raise_if_too_many_dataframes(given: int) -> None:
-    limit = len(DatasetRole)
+    limit = len(InferencesRole)
     if not 0 < given <= limit:
         raise ValueError(f"expected between 1 to {limit} dataframes, but {given} were given")
 

phoenix/core/model_schema_adapter.py

@@ -10,21 +10,21 @@ from phoenix import EmbeddingColumnNames, Inferences
 from phoenix.core.model import _get_embedding_dimensions
 from phoenix.core.model_schema import Embedding, Model, RetrievalEmbedding, Schema
 from phoenix.inferences.schema import RetrievalEmbeddingColumnNames
-from phoenix.inferences.schema import Schema as DatasetSchema
+from phoenix.inferences.schema import Schema as InferencesSchema
 
-DatasetName: TypeAlias = str
+InferencesName: TypeAlias = str
 ColumnName: TypeAlias = str
 DisplayName: TypeAlias = str
 
 
-def create_model_from_datasets(*datasets: Optional[Inferences]) -> Model:
+def create_model_from_inferences(*inference_sets: Optional[Inferences]) -> Model:
     # TODO: move this validation into model_schema.Model.
-    if len(datasets) > 1 and datasets[0] is not None:
+    if len(inference_sets) > 1 and inference_sets[0] is not None:
         # Check that for each embedding dimension all vectors
-        # have the same length between datasets.
-        _ = _get_embedding_dimensions(datasets[0], datasets[1])
+        # have the same length between inferences.
+        _ = _get_embedding_dimensions(inference_sets[0], inference_sets[1])
 
-    named_dataframes: List[Tuple[DatasetName, pd.DataFrame]] = []
+    named_dataframes: List[Tuple[InferencesName, pd.DataFrame]] = []
     prediction_ids: List[ColumnName] = []
     timestamps: List[ColumnName] = []
     prediction_labels: List[ColumnName] = []
@@ -37,33 +37,35 @@ def create_model_from_datasets(*datasets: Optional[Inferences]) -> Model:
     prompts: List[EmbeddingColumnNames] = []
     responses: List[Union[str, EmbeddingColumnNames]] = []
 
-    for dataset in filter(_is_dataset, datasets):
-        df = dataset.dataframe
+    for inferences in filter(_is_inferences, inference_sets):
+        df = inferences.dataframe
         # Coerce string column names at run time.
         df = df.set_axis(
             map(str, df.columns),
             axis=1,
         )
-        named_dataframes.append((dataset.name, df))
-        dataset_schema = dataset.schema if dataset.schema is not None else DatasetSchema()
+        named_dataframes.append((inferences.name, df))
+        inferences_schema = (
+            inferences.schema if inferences.schema is not None else InferencesSchema()
+        )
         for display_name, embedding in (
-            dataset_schema.embedding_feature_column_names or {}
+            inferences_schema.embedding_feature_column_names or {}
         ).items():
             if display_name not in embeddings:
                 embeddings[display_name] = embedding
-        if dataset_schema.prompt_column_names is not None:
-            prompts.append(dataset_schema.prompt_column_names)
-        if dataset_schema.response_column_names is not None:
-            responses.append(dataset_schema.response_column_names)
+        if inferences_schema.prompt_column_names is not None:
+            prompts.append(inferences_schema.prompt_column_names)
+        if inferences_schema.response_column_names is not None:
+            responses.append(inferences_schema.response_column_names)
         for source, sink in (
-            ([dataset_schema.prediction_id_column_name], prediction_ids),
-            ([dataset_schema.timestamp_column_name], timestamps),
-            ([dataset_schema.prediction_label_column_name], prediction_labels),
-            ([dataset_schema.prediction_score_column_name], prediction_scores),
-            ([dataset_schema.actual_label_column_name], actual_labels),
-            ([dataset_schema.actual_score_column_name], actual_scores),
-            (dataset_schema.feature_column_names or (), features),
-            (dataset_schema.tag_column_names or (), tags),
+            ([inferences_schema.prediction_id_column_name], prediction_ids),
+            ([inferences_schema.timestamp_column_name], timestamps),
+            ([inferences_schema.prediction_label_column_name], prediction_labels),
+            ([inferences_schema.prediction_score_column_name], prediction_scores),
+            ([inferences_schema.actual_label_column_name], actual_labels),
+            ([inferences_schema.actual_score_column_name], actual_scores),
+            (inferences_schema.feature_column_names or (), features),
+            (inferences_schema.tag_column_names or (), tags),
         ):
             # Coerce None to "" to simplify type checks.
             sink.extend(map(lambda s: "" if s is None else str(s), source))
@@ -132,7 +134,7 @@ def create_model_from_datasets(*datasets: Optional[Inferences]) -> Model:
     )
 
 
-def _is_dataset(obj: Optional[Inferences]) -> TypeGuard[Inferences]:
+def _is_inferences(obj: Optional[Inferences]) -> TypeGuard[Inferences]:
     return type(obj) is Inferences
 
 

phoenix/datetime_utils.py

@@ -14,6 +14,10 @@ from pandas.core.dtypes.common import (
 _LOCAL_TIMEZONE = datetime.now(timezone.utc).astimezone().tzinfo
 
 
+def local_now() -> datetime:
+    return datetime.now(timezone.utc).astimezone(tz=_LOCAL_TIMEZONE)
+
+
 def normalize_datetime(
     dt: Optional[datetime],
     tz: Optional[tzinfo] = None,