arize-phoenix 0.0.24rc0__tar.gz → 0.0.24rc2__tar.gz

{arize_phoenix-0.0.24rc0 → arize_phoenix-0.0.24rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arize-phoenix
-Version: 0.0.24rc0
+Version: 0.0.24rc2
 Summary: ML Observability in your notebook
 Project-URL: Documentation, https://docs.arize.com/phoenix/
 Project-URL: Issues, https://github.com/Arize-ai/phoenix/issues

{arize_phoenix-0.0.24rc0 → arize_phoenix-0.0.24rc2}/src/phoenix/__init__.py

@@ -3,7 +3,7 @@ from .datasets.fixtures import ExampleDatasets, load_example
 from .datasets.schema import EmbeddingColumnNames, Schema
 from .session.session import Session, active_session, close_app, launch_app
 
-__version__ = "0.0.24rc0"
+__version__ = "0.0.24rc2"
 
 # module level doc-string
 __doc__ = """

{arize_phoenix-0.0.24rc0 → arize_phoenix-0.0.24rc2}/src/phoenix/core/model_schema.py

@@ -599,10 +599,8 @@ class Events(ModelData):
     @cached_property
     def time_range(self) -> TimeRange:
         if self._self_model is None or self.empty:
-            # NOTE: as of Python 3.8.16, pandas 1.5.3:
-            # >>> isinstance(pd.NaT, datetime.datetime)
-            # True
-            return TimeRange(pd.NaT, pd.NaT)  # type: ignore
+            now = datetime.now(timezone.utc)
+            return TimeRange(now, now)
         model = cast(Model, self._self_model)
         min_max = _agg_min_max(model[TIMESTAMP](self))
         start_time = cast(datetime, min_max.min())

{arize_phoenix-0.0.24rc0 → arize_phoenix-0.0.24rc2}/src/phoenix/core/model_schema_adapter.py

@@ -1,7 +1,9 @@
 from itertools import chain
-from typing import Dict, Iterable, List, Optional, Tuple
+from operator import itemgetter
+from typing import Dict, Iterable, List, Optional, Sized, Tuple
 
 import pandas as pd
+from pandas.api.types import is_object_dtype
 from typing_extensions import TypeAlias, TypeGuard
 
 from phoenix import Dataset, EmbeddingColumnNames
@@ -107,8 +109,19 @@ def create_model_from_datasets(*datasets: Optional[Dataset]) -> Model:
         prediction_score=_take_first_str(prediction_scores),
         actual_label=_take_first_str(actual_labels),
         actual_score=_take_first_str(actual_scores),
-        features=chain(features, translated_embeddings),
-        tags=tags,
+        features=chain(
+            *_split_vectors_vs_scalars(
+                features,
+                *map(itemgetter(1), named_dataframes),
+            ),
+            translated_embeddings,
+        ),
+        tags=chain(
+            *_split_vectors_vs_scalars(
+                tags,
+                *map(itemgetter(1), named_dataframes),
+            )
+        ),
         prompt=next(map(_translate_embedding, prompts), None),
         response=next(map(_translate_embedding, responses), None),
     )(
@@ -137,3 +150,37 @@ def _translate_embedding(
         link_to_data=embedding.link_to_data_column_name,
         display_name=display_name,
     )
+
+
+def _split_vectors_vs_scalars(
+    names: Iterable[str],
+    *dataframes: pd.DataFrame,
+) -> Tuple[List[str], List[Embedding]]:
+    """A best-effort attempt at separating vector columns from scalar columns
+    by examining the first non-null item of the column from each dataframe. If
+    any item is `Iterable` and `Sized`, but not `str`, then the column is
+    returned as `Embedding`, else it's returned as scalar.
+    """
+    scalars: List[str] = []
+    vectors: List[Embedding] = []
+    # convert to sets for a speedier lookup
+    column_names = [set(df.columns) for df in dataframes]
+    for name in names:
+        for i, df in enumerate(dataframes):
+            if df.empty or name not in column_names[i]:
+                continue
+            series = df.loc[:, name]
+            if not is_object_dtype(series):
+                continue
+            item = series.iat[series.isna().argmin()]
+            if (
+                isinstance(item, str)  # str is scalar, but Iterable
+                or not isinstance(item, Iterable)
+                or not isinstance(item, Sized)
+            ):
+                continue
+            vectors.append(Embedding(vector=name))
+            break
+        else:
+            scalars.append(name)
+    return scalars, vectors

{arize_phoenix-0.0.24rc0 → arize_phoenix-0.0.24rc2}/src/phoenix/datasets/dataset.py

@@ -443,7 +443,11 @@ def _normalize_timestamps(
     if (timestamp_column_name := schema.timestamp_column_name) is None:
         timestamp_column_name = "timestamp"
         schema = replace(schema, timestamp_column_name=timestamp_column_name)
-        timestamp_column = Series([default_timestamp] * len(dataframe), index=dataframe.index)
+        timestamp_column = (
+            Series([default_timestamp] * len(dataframe), index=dataframe.index)
+            if len(dataframe)
+            else Series([default_timestamp]).iloc[:0].set_axis(dataframe.index, axis=0)
+        )
     elif is_numeric_dtype(timestamp_column_dtype := dataframe[timestamp_column_name].dtype):
         timestamp_column = to_datetime(dataframe[timestamp_column_name], unit="s", utc=True)
     elif is_datetime64tz_dtype(timestamp_column_dtype):

{arize_phoenix-0.0.24rc0 → arize_phoenix-0.0.24rc2}/src/phoenix/pointcloud/projectors.py

@@ -11,6 +11,7 @@ with warnings.catch_warnings():
 
     warnings.simplefilter("ignore", category=NumbaWarning)
     from umap import UMAP
+
 Matrix: TypeAlias = npt.NDArray[np.float64]
 
 
@@ -24,4 +25,11 @@ class Umap:
     min_dist: float = 0.1
 
     def project(self, mat: Matrix, n_components: int) -> Matrix:
-        return _center(UMAP(**asdict(self), n_components=n_components).fit_transform(mat))
+        config = asdict(self)
+        config["n_components"] = n_components
+        if len(mat) <= n_components:
+            # init='spectral', the default, cannot be used when n_components
+            # is greater or equal to the number of samples.
+            # see https://github.com/lmcinnes/umap/issues/201#issuecomment-462097103
+            config["init"] = "random"
+        return _center(UMAP(**config).fit_transform(mat))

{arize_phoenix-0.0.24rc0 → arize_phoenix-0.0.24rc2}/src/phoenix/server/api/types/PerformanceMetric.py

@@ -10,4 +10,4 @@ from phoenix.metrics.wrappers import SkEval
 class PerformanceMetric(Enum):
     # To become enum values, functions need to be wrapped in partial.
     # See https://stackoverflow.com/a/40339397
-    accuracy_score = partial(SkEval.accuracy_score)  # type: ignore
+    accuracyScore = partial(SkEval.accuracy_score)  # type: ignore

{arize_phoenix-0.0.24rc0 → arize_phoenix-0.0.24rc2}/src/phoenix/server/api/types/Segments.py

@@ -84,5 +84,19 @@ class Segments:
     )
 
     def append(self, other: Segment) -> None:
+        if (
+            isinstance(other.bin, IntervalBin)
+            and not math.isfinite(other.bin.range.start)
+            and not math.isfinite(other.bin.range.end)
+            and other.counts.primary_value == 0
+            and other.counts.reference_value == 0
+        ):
+            # Skip the interval bin with zero counts if it has -inf and +inf
+            # as the endpoints, as it could occur due to all values being
+            # missing. Because such bin can exist a priori, the caller may
+            # still try to append it, but the bin has no real value at this
+            # point (and can cause problems for graphql because of the end
+            # points are not serializable to JSON).
+            return
         self.segments.append(other)
         self.total_counts += other.counts