arize 8.0.0a2__py3-none-any.whl → 8.0.0a4__py3-none-any.whl

arize/constants/model_mapping.json

@@ -0,0 +1,199 @@
+{
+  "external_model_types": [
+    "binary_classification",
+    "regression",
+    "ranking",
+    "object_detection"
+  ],
+  "metric_families": [
+    "classification",
+    "regression",
+    "ranking",
+    "auc_log_loss",
+    "ranking_label"
+  ],
+  "required_columns_map": [
+    {
+      "external_model_type": "binary_classification",
+      "mappings": [
+        {
+          "metrics": [["classification"]],
+          "required_columns": {
+            "arrow": {
+              "required": [["prediction_label_column_name"]],
+              "latent": [["actual_label_column_name"]]
+            },
+            "generic": {
+              "required": [["prediction_label"]],
+              "latent": [["actual_label"]]
+            }
+          }
+        },
+        {
+          "metrics": [["regression"]],
+          "required_columns": {
+            "arrow": {
+              "required": [["prediction_score_column_name"]],
+              "latent": [["actual_score_column_name"]]
+            },
+            "generic": {
+              "required": [["prediction_score"]],
+              "latent": [["actual_score"]]
+            }
+          }
+        },
+        {
+          "metrics": [
+            ["auc_log_loss", "classification"],
+            ["regression", "classification"]
+          ],
+          "required_columns": {
+            "arrow": {
+              "required": [
+                ["prediction_label_column_name", "prediction_score_column_name"]
+              ],
+              "latent": [["actual_label_column_name"]]
+            },
+            "generic": {
+              "required": [["prediction_label", "prediction_score"]],
+              "latent": [["actual_label"]]
+            }
+          }
+        },
+        {
+          "metrics": [["auc_log_loss"]],
+          "required_columns": {
+            "arrow": {
+              "required": [["prediction_score_column_name"]],
+              "latent": [["actual_label_column_name"]]
+            },
+            "generic": {
+              "required": [["prediction_score"]],
+              "latent": [["actual_label"]]
+            }
+          }
+        },
+        {
+          "metrics": [["regression", "auc_log_loss"]],
+          "required_columns": {
+            "arrow": {
+              "required": [["prediction_score_column_name"]],
+              "latent": [
+                ["actual_score_column_name", "actual_label_column_name"]
+              ]
+            },
+            "generic": {
+              "required": [["prediction_score"]],
+              "latent": [["actual_score", "actual_label"]]
+            }
+          }
+        },
+        {
+          "metrics": [["auc_log_loss", "classification", "regression"]],
+          "required_columns": {
+            "arrow": {
+              "required": [
+                ["prediction_label_column_name", "prediction_score_column_name"]
+              ],
+              "latent": [
+                ["actual_label_column_name", "actual_score_column_name"]
+              ]
+            },
+            "generic": {
+              "required": [["prediction_label", "prediction_score"]],
+              "latent": [["actual_label", "actual_score"]]
+            }
+          }
+        }
+      ]
+    },
+    {
+      "external_model_type": "regression",
+      "mappings": [
+        {
+          "metrics": [["regression"]],
+          "required_columns": {
+            "arrow": {
+              "required": [
+                ["prediction_score_column_name"],
+                ["prediction_label_column_name"]
+              ],
+              "latent": [["actual_score_column_name"]]
+            },
+            "generic": {
+              "required": [["prediction_score"]],
+              "latent": [["actual_score"]]
+            }
+          }
+        }
+      ]
+    },
+    {
+      "external_model_type": "ranking",
+      "mappings": [
+        {
+          "metrics": [["ranking"]],
+          "required_columns": {
+            "arrow": {
+              "required": [["rank_column_name"]],
+              "latent": [
+                ["relevance_labels_column_name"],
+                ["relevance_score_column_name"]
+              ]
+            },
+            "generic": {
+              "required": [["rank"]],
+              "latent": [["actual_score"], ["actual_label"]]
+            }
+          }
+        },
+        {
+          "metrics": [["ranking_label"], ["ranking", "ranking_label"]],
+          "required_columns": {
+            "arrow": {
+              "required": [["rank_column_name"]],
+              "latent": [["relevance_labels_column_name"]]
+            },
+            "generic": {
+              "required": [["rank", "prediction_label"]],
+              "latent": [["actual_label"]]
+            }
+          }
+        },
+        {
+          "metrics": [["ranking", "auc_log_loss"], ["auc_log_loss"]],
+          "required_columns": {
+            "arrow": {
+              "required": [
+                ["rank_column_name", "prediction_score_column_name"]
+              ],
+              "latent": [["relevance_labels_column_name"]]
+            },
+            "generic": {
+              "required": [["rank", "prediction_score"]],
+              "latent": [["actual_label"]]
+            }
+          }
+        }
+      ]
+    },
+    {
+      "external_model_type": "object_detection",
+      "mappings": [
+        {
+          "metrics": [["classification"]],
+          "required_columns": {
+            "arrow": {
+              "required": [["object_detection_prediction_column_names"]],
+              "latent": [["object_detection_actual_column_names"]]
+            },
+            "generic": {
+              "required": [["object_detection_prediction"]],
+              "latent": [["object_detection_actual"]]
+            }
+          }
+        }
+      ]
+    }
+  ]
+}

arize/exceptions/base.py

@@ -2,7 +2,12 @@ from abc import ABC, abstractmethod
 from collections.abc import Iterable
 from typing import List
 
-from arize.types import Environments
+INVALID_ARROW_CONVERSION_MSG = (
+    "The dataframe needs to convert to pyarrow but has failed to do so. "
+    "There may be unrecognized data types in the dataframe. "
+    "Another reason may be that a column in the dataframe has a mix of strings and "
+    "numbers, in which case you may want to convert the strings in that column to NaN. "
+)
 
 
 class ValidationError(Exception, ABC):
@@ -26,16 +31,16 @@ class ValidationFailure(Exception):
 # ----------------------
 # Minimum required checks
 # ----------------------
-class InvalidColumnNameEmptyString(ValidationError):
-    def __repr__(self) -> str:
-        return "Invalid_Column_Name_Empty_String"
-
-    def error_message(self) -> str:
-        return (
-            "Empty column name found: ''. The schema cannot point to columns in the "
-            "dataframe denoted by an empty string. You can see the columns used in the "
-            "schema by running schema.get_used_columns()"
-        )
+# class InvalidColumnNameEmptyString(ValidationError):
+#     def __repr__(self) -> str:
+#         return "Invalid_Column_Name_Empty_String"
+#
+#     def error_message(self) -> str:
+#         return (
+#             "Empty column name found: ''. The schema cannot point to columns in the "
+#             "dataframe denoted by an empty string. You can see the columns used in the "
+#             "schema by running schema.get_used_columns()"
+#         )
 
 
 class InvalidFieldTypeConversion(ValidationError):
@@ -53,29 +58,29 @@ class InvalidFieldTypeConversion(ValidationError):
         )
 
 
-class InvalidFieldTypeEmbeddingFeatures(ValidationError):
-    def __repr__(self) -> str:
-        return "Invalid_Input_Type_Embedding_Features"
-
-    def __init__(self) -> None:
-        pass
-
-    def error_message(self) -> str:
-        return (
-            "schema.embedding_feature_column_names should be a dictionary mapping strings "
-            "to EmbeddingColumnNames objects"
-        )
-
-
-class InvalidFieldTypePromptResponse(ValidationError):
-    def __repr__(self) -> str:
-        return "Invalid_Input_Type_Prompt_Response"
+# class InvalidFieldTypeEmbeddingFeatures(ValidationError):
+#     def __repr__(self) -> str:
+#         return "Invalid_Input_Type_Embedding_Features"
+#
+#     def __init__(self) -> None:
+#         pass
+#
+#     def error_message(self) -> str:
+#         return (
+#             "schema.embedding_feature_column_names should be a dictionary mapping strings "
+#             "to EmbeddingColumnNames objects"
+#         )
 
-    def __init__(self, name: str) -> None:
-        self.name = name
 
-    def error_message(self) -> str:
-        return f"'{self.name}' must be of type str or EmbeddingColumnNames"
+# class InvalidFieldTypePromptResponse(ValidationError):
+#     def __repr__(self) -> str:
+#         return "Invalid_Input_Type_Prompt_Response"
+#
+#     def __init__(self, name: str) -> None:
+#         self.name = name
+#
+#     def error_message(self) -> str:
+#         return f"'{self.name}' must be of type str or EmbeddingColumnNames"
 
 
 class InvalidDataFrameIndex(ValidationError):
@@ -89,13 +94,13 @@ class InvalidDataFrameIndex(ValidationError):
         )
 
 
-class InvalidSchemaType(ValidationError):
-    def __repr__(self) -> str:
-        return "Invalid_Schema_Type"
-
-    def __init__(self, schema_type: str, environment: Environments) -> None:
-        self.schema_type = schema_type
-        self.environment = environment
-
-    def error_message(self) -> str:
-        return f"Cannot use a {self.schema_type} for a model with environment: {self.environment}"
+# class InvalidSchemaType(ValidationError):
+#     def __repr__(self) -> str:
+#         return "Invalid_Schema_Type"
+#
+#     def __init__(self, schema_type: str, environment: Environments) -> None:
+#         self.schema_type = schema_type
+#         self.environment = environment
+#
+#     def error_message(self) -> str:
+#         return f"Cannot use a {self.schema_type} for a model with environment: {self.environment}"

arize/exceptions/models.py

@@ -8,3 +8,15 @@ class MissingProjectNameError(Exception):
     @staticmethod
     def _default_message() -> str:
         return "Missing Project Name: pass project_name explicitly"
+
+
+class MissingModelNameError(Exception):
+    def __init__(self, message: str = ""):
+        self.message = message
+
+    def __str__(self) -> str:
+        return self.message or self._default_message()
+
+    @staticmethod
+    def _default_message() -> str:
+        return "Missing Model Name: pass model name explicitly"