arthur-common 1.0.1__py3-none-any.whl

arthur_common/aggregations/functions/inference_null_count.py

@@ -0,0 +1,82 @@
+from typing import Annotated
+from uuid import UUID
+
+from arthur_common.aggregations.aggregator import NumericAggregationFunction
+from arthur_common.models.metrics import DatasetReference, Dimension, NumericMetric
+from arthur_common.models.schema_definitions import (
+    DType,
+    MetricColumnParameterAnnotation,
+    MetricDatasetParameterAnnotation,
+    ScalarType,
+    ScopeSchemaTag,
+)
+from arthur_common.tools.duckdb_data_loader import escape_identifier
+from duckdb import DuckDBPyConnection
+
+
+class InferenceNullCountAggregationFunction(NumericAggregationFunction):
+    METRIC_NAME = "null_count"
+
+    @staticmethod
+    def id() -> UUID:
+        return UUID("00000000-0000-0000-0000-00000000000b")
+
+    @staticmethod
+    def display_name() -> str:
+        return "Null Value Count"
+
+    @staticmethod
+    def description() -> str:
+        return "Metric that counts the number of null values in the column per time window."
+
+    def aggregate(
+        self,
+        ddb_conn: DuckDBPyConnection,
+        dataset: Annotated[
+            DatasetReference,
+            MetricDatasetParameterAnnotation(
+                friendly_name="Dataset",
+                description="The dataset containing the inference data.",
+            ),
+        ],
+        timestamp_col: Annotated[
+            str,
+            MetricColumnParameterAnnotation(
+                source_dataset_parameter_key="dataset",
+                allowed_column_types=[
+                    ScalarType(dtype=DType.TIMESTAMP),
+                ],
+                tag_hints=[ScopeSchemaTag.PRIMARY_TIMESTAMP],
+                friendly_name="Timestamp Column",
+                description="A column containing timestamp values to bucket by.",
+            ),
+        ],
+        nullable_col: Annotated[
+            str,
+            MetricColumnParameterAnnotation(
+                source_dataset_parameter_key="dataset",
+                allow_any_column_type=True,
+                friendly_name="Nullable Column",
+                description="A column containing nullable values to count.",
+            ),
+        ],
+    ) -> list[NumericMetric]:
+        escaped_timestamp_col = escape_identifier(timestamp_col)
+        escaped_nullable_col = escape_identifier(nullable_col)
+        count_query = f" \
+            select time_bucket(INTERVAL '5 minutes', {escaped_timestamp_col}) as ts, \
+            count(*) as count \
+            from {dataset.dataset_table_name} where {escaped_nullable_col} is null \
+            group by ts \
+        "
+        results = ddb_conn.sql(count_query).df()
+
+        series = self.dimensionless_query_results_to_numeric_metrics(
+            results,
+            "count",
+            "ts",
+        )
+        series.dimensions = [Dimension(name="column_name", value=nullable_col)]
+
+        metric = self.series_to_metric(self.METRIC_NAME, [series])
+        return [metric]

arthur_common/aggregations/functions/mean_absolute_error.py

@@ -0,0 +1,110 @@
+from typing import Annotated
+from uuid import UUID
+
+from arthur_common.aggregations.aggregator import NumericAggregationFunction
+from arthur_common.models.datasets import ModelProblemType
+from arthur_common.models.metrics import DatasetReference, NumericMetric
+from arthur_common.models.schema_definitions import (
+    DType,
+    MetricColumnParameterAnnotation,
+    MetricDatasetParameterAnnotation,
+    ScalarType,
+    ScopeSchemaTag,
+)
+from arthur_common.tools.duckdb_data_loader import escape_identifier
+from duckdb import DuckDBPyConnection
+
+
+class MeanAbsoluteErrorAggregationFunction(NumericAggregationFunction):
+    @staticmethod
+    def id() -> UUID:
+        return UUID("00000000-0000-0000-0000-00000000000e")
+
+    @staticmethod
+    def display_name() -> str:
+        return "Mean Absolute Error"
+
+    @staticmethod
+    def description() -> str:
+        return "Metric that sums the absolute error of a prediction and ground truth column. It omits any rows where either the prediction or ground truth are null. It reports the count of non-null rows used in the calculation in a second metric."
+
+    def aggregate(
+        self,
+        ddb_conn: DuckDBPyConnection,
+        dataset: Annotated[
+            DatasetReference,
+            MetricDatasetParameterAnnotation(
+                friendly_name="Dataset",
+                description="The dataset containing the inference data.",
+                model_problem_type=ModelProblemType.REGRESSION,
+            ),
+        ],
+        timestamp_col: Annotated[
+            str,
+            MetricColumnParameterAnnotation(
+                source_dataset_parameter_key="dataset",
+                allowed_column_types=[
+                    ScalarType(dtype=DType.TIMESTAMP),
+                ],
+                tag_hints=[ScopeSchemaTag.PRIMARY_TIMESTAMP],
+                friendly_name="Timestamp Column",
+                description="A column containing timestamp values to bucket by.",
+            ),
+        ],
+        prediction_col: Annotated[
+            str,
+            MetricColumnParameterAnnotation(
+                source_dataset_parameter_key="dataset",
+                allowed_column_types=[
+                    ScalarType(dtype=DType.FLOAT),
+                ],
+                tag_hints=[ScopeSchemaTag.PREDICTION],
+                friendly_name="Prediction Column",
+                description="A column containing float typed prediction values.",
+            ),
+        ],
+        ground_truth_col: Annotated[
+            str,
+            MetricColumnParameterAnnotation(
+                source_dataset_parameter_key="dataset",
+                allowed_column_types=[
+                    ScalarType(dtype=DType.FLOAT),
+                ],
+                tag_hints=[ScopeSchemaTag.GROUND_TRUTH],
+                friendly_name="Ground Truth Column",
+                description="A column containing float typed ground truth values.",
+            ),
+        ],
+    ) -> list[NumericMetric]:
+        escaped_timestamp_col = escape_identifier(timestamp_col)
+        escaped_prediction_col = escape_identifier(prediction_col)
+        escaped_ground_truth_col = escape_identifier(ground_truth_col)
+        count_query = f" \
+            SELECT time_bucket(INTERVAL '5 minutes', {escaped_timestamp_col}) as ts, \
+            SUM(ABS({escaped_prediction_col} - {escaped_ground_truth_col})) as ae, \
+            COUNT(*) as count \
+            FROM {dataset.dataset_table_name} \
+            WHERE {escaped_prediction_col} IS NOT NULL \
+            AND {escaped_ground_truth_col} IS NOT NULL \
+            GROUP BY ts order by ts desc \
+        "
+
+        results = ddb_conn.sql(count_query).df()
+        count_series = self.dimensionless_query_results_to_numeric_metrics(
+            results,
+            "count",
+            "ts",
+        )
+        absolute_error_series = self.dimensionless_query_results_to_numeric_metrics(
+            results,
+            "ae",
+            "ts",
+        )
+
+        count_metric = self.series_to_metric("absolute_error_count", [count_series])
+        absolute_error_metric = self.series_to_metric(
+            "absolute_error_sum",
+            [absolute_error_series],
+        )
+
+        return [count_metric, absolute_error_metric]

arthur_common/aggregations/functions/mean_squared_error.py

@@ -0,0 +1,110 @@
+from typing import Annotated
+from uuid import UUID
+
+from arthur_common.aggregations.aggregator import NumericAggregationFunction
+from arthur_common.models.datasets import ModelProblemType
+from arthur_common.models.metrics import DatasetReference, NumericMetric
+from arthur_common.models.schema_definitions import (
+    DType,
+    MetricColumnParameterAnnotation,
+    MetricDatasetParameterAnnotation,
+    ScalarType,
+    ScopeSchemaTag,
+)
+from arthur_common.tools.duckdb_data_loader import escape_identifier
+from duckdb import DuckDBPyConnection
+
+
+class MeanSquaredErrorAggregationFunction(NumericAggregationFunction):
+    @staticmethod
+    def id() -> UUID:
+        return UUID("00000000-0000-0000-0000-000000000010")
+
+    @staticmethod
+    def display_name() -> str:
+        return "Mean Squared Error"
+
+    @staticmethod
+    def description() -> str:
+        return "Metric that sums the squared error of a prediction and ground truth column. It omits any rows where either the prediction or ground truth are null. It reports the count of non-null rows used in the calculation in a second metric."
+
+    def aggregate(
+        self,
+        ddb_conn: DuckDBPyConnection,
+        dataset: Annotated[
+            DatasetReference,
+            MetricDatasetParameterAnnotation(
+                friendly_name="Dataset",
+                description="The dataset containing the inference data.",
+                model_problem_type=ModelProblemType.REGRESSION,
+            ),
+        ],
+        timestamp_col: Annotated[
+            str,
+            MetricColumnParameterAnnotation(
+                source_dataset_parameter_key="dataset",
+                allowed_column_types=[
+                    ScalarType(dtype=DType.TIMESTAMP),
+                ],
+                tag_hints=[ScopeSchemaTag.PRIMARY_TIMESTAMP],
+                friendly_name="Timestamp Column",
+                description="A column containing timestamp values to bucket by.",
+            ),
+        ],
+        prediction_col: Annotated[
+            str,
+            MetricColumnParameterAnnotation(
+                source_dataset_parameter_key="dataset",
+                allowed_column_types=[
+                    ScalarType(dtype=DType.FLOAT),
+                ],
+                tag_hints=[ScopeSchemaTag.PREDICTION],
+                friendly_name="Prediction Column",
+                description="A column containing float typed prediction values.",
+            ),
+        ],
+        ground_truth_col: Annotated[
+            str,
+            MetricColumnParameterAnnotation(
+                source_dataset_parameter_key="dataset",
+                allowed_column_types=[
+                    ScalarType(dtype=DType.FLOAT),
+                ],
+                tag_hints=[ScopeSchemaTag.GROUND_TRUTH],
+                friendly_name="Ground Truth Column",
+                description="A column containing float typed ground truth values.",
+            ),
+        ],
+    ) -> list[NumericMetric]:
+        escaped_timestamp_col = escape_identifier(timestamp_col)
+        escaped_prediction_col = escape_identifier(prediction_col)
+        escaped_ground_truth_col = escape_identifier(ground_truth_col)
+        count_query = f" \
+            SELECT time_bucket(INTERVAL '5 minutes', {escaped_timestamp_col}) as ts, \
+            SUM(POW({escaped_prediction_col} - {escaped_ground_truth_col}, 2)) as squared_error, \
+            COUNT(*) as count \
+            FROM {dataset.dataset_table_name} \
+            WHERE {escaped_prediction_col} IS NOT NULL \
+            AND {escaped_ground_truth_col} IS NOT NULL \
+            GROUP BY ts order by ts desc \
+        "
+
+        results = ddb_conn.sql(count_query).df()
+        count_series = self.dimensionless_query_results_to_numeric_metrics(
+            results,
+            "count",
+            "ts",
+        )
+        squared_error_series = self.dimensionless_query_results_to_numeric_metrics(
+            results,
+            "squared_error",
+            "ts",
+        )
+
+        count_metric = self.series_to_metric("squared_error_count", [count_series])
+        absolute_error_metric = self.series_to_metric(
+            "squared_error_sum",
+            [squared_error_series],
+        )
+
+        return [count_metric, absolute_error_metric]

arthur_common/aggregations/functions/multiclass_confusion_matrix.py

@@ -0,0 +1,205 @@
+from typing import Annotated
+from uuid import UUID
+
+from arthur_common.aggregations.aggregator import NumericAggregationFunction
+from arthur_common.models.datasets import ModelProblemType
+from arthur_common.models.metrics import DatasetReference, NumericMetric
+from arthur_common.models.schema_definitions import (
+    DType,
+    MetricColumnParameterAnnotation,
+    MetricDatasetParameterAnnotation,
+    MetricLiteralParameterAnnotation,
+    ScalarType,
+    ScopeSchemaTag,
+)
+from arthur_common.tools.duckdb_data_loader import escape_identifier, escape_str_literal
+from duckdb import DuckDBPyConnection
+
+
+class MulticlassClassifierStringLabelSingleClassConfusionMatrixAggregationFunction(
+    NumericAggregationFunction,
+):
+    @staticmethod
+    def id() -> UUID:
+        return UUID("dc728927-6928-4a3b-b174-8c1ec8b58d62")
+
+    @staticmethod
+    def display_name() -> str:
+        return "Multiclass Classification Confusion Matrix Single Class - String Class Label Prediction"
+
+    @staticmethod
+    def description() -> str:
+        return (
+            "Aggregation that takes in the string label for the positive class, "
+            "and calculates the confusion matrix (True Positives, False Positives, "
+            "False Negatives, True Negatives) for that class compared to all others."
+        )
+
+    def aggregate(
+        self,
+        ddb_conn: DuckDBPyConnection,
+        dataset: Annotated[
+            DatasetReference,
+            MetricDatasetParameterAnnotation(
+                friendly_name="Dataset",
+                description="The dataset containing the prediction and ground truth values.",
+                model_problem_type=ModelProblemType.MULTICLASS_CLASSIFICATION,
+            ),
+        ],
+        timestamp_col: Annotated[
+            str,
+            MetricColumnParameterAnnotation(
+                source_dataset_parameter_key="dataset",
+                tag_hints=[ScopeSchemaTag.PRIMARY_TIMESTAMP],
+                allowed_column_types=[
+                    ScalarType(dtype=DType.TIMESTAMP),
+                ],
+                friendly_name="Timestamp Column",
+                description="A column containing timestamp values to bucket by.",
+            ),
+        ],
+        prediction_col: Annotated[
+            str,
+            MetricColumnParameterAnnotation(
+                source_dataset_parameter_key="dataset",
+                allowed_column_types=[
+                    ScalarType(dtype=DType.STRING),
+                ],
+                tag_hints=[ScopeSchemaTag.PREDICTION],
+                friendly_name="Prediction Column",
+                description="A column containing the predicted string class label.",
+            ),
+        ],
+        gt_values_col: Annotated[
+            str,
+            MetricColumnParameterAnnotation(
+                source_dataset_parameter_key="dataset",
+                allowed_column_types=[
+                    ScalarType(dtype=DType.STRING),
+                ],
+                tag_hints=[ScopeSchemaTag.GROUND_TRUTH],
+                friendly_name="Ground Truth Column",
+                description="A column containing the ground truth string class label.",
+            ),
+        ],
+        positive_class_label: Annotated[
+            str,
+            MetricLiteralParameterAnnotation(
+                parameter_dtype=DType.STRING,
+                friendly_name="Positive Class Label",
+                description="The label indicating a positive class.",
+            ),
+        ],
+    ) -> list[NumericMetric]:
+        escaped_positive_class_label = escape_str_literal(positive_class_label)
+        normalization_case = f"""
+                CASE
+                    WHEN value = {escaped_positive_class_label} THEN 1
+                    ELSE 0
+                END
+                """
+        return self.generate_confusion_matrix_metrics(
+            ddb_conn,
+            timestamp_col,
+            prediction_col,
+            gt_values_col,
+            normalization_case,
+            normalization_case,
+            dataset,
+            escaped_positive_class_label,
+        )
+
+    def generate_confusion_matrix_metrics(
+        self,
+        ddb_conn: DuckDBPyConnection,
+        timestamp_col: str,
+        prediction_col: str,
+        gt_values_col: str,
+        prediction_normalization_case: str,
+        gt_normalization_case: str,
+        dataset: DatasetReference,
+        escaped_positive_class_label: str,
+    ) -> list[NumericMetric]:
+        """
+        Generate a SQL query to compute confusion matrix metrics over time.
+
+        Args:
+            ddb_conn: duck DB connection
+            timestamp_col: Column name containing timestamps
+            prediction_col: Column name containing predictions
+            gt_values_col: Column name containing ground truth values
+            prediction_normalization_case: SQL CASE statement for normalizing predictions to 0 / 1 / null using 'value' as the target column name
+            gt_normalization_case: SQL CASE statement for normalizing ground truth values to 0 / 1 / null using 'value' as the target column name
+            dataset: DatasetReference containing dataset metadata
+            escaped_positive_class_label: escaped label for the class to include in the dimensions
+
+        Returns:
+            str: SQL query that computes confusion matrix metrics
+        """
+        escaped_timestamp_col = escape_identifier(timestamp_col)
+        escaped_prediction_col = escape_identifier(prediction_col)
+        escaped_gt_values_col = escape_identifier(gt_values_col)
+        confusion_matrix_query = f"""
+            WITH normalized_data AS (
+                SELECT
+                    {escaped_timestamp_col} AS timestamp,
+                    {prediction_normalization_case.replace('value', escaped_prediction_col)} AS prediction,
+                    {gt_normalization_case.replace('value', escaped_gt_values_col)} AS actual_value
+                FROM {dataset.dataset_table_name}
+                WHERE {escaped_timestamp_col} IS NOT NULL
+            )
+            SELECT
+                time_bucket(INTERVAL '5 minutes', timestamp) AS ts,
+                SUM(CASE WHEN prediction = 1 AND actual_value = 1 THEN 1 ELSE 0 END) AS true_positive_count,
+                SUM(CASE WHEN prediction = 1 AND actual_value = 0 THEN 1 ELSE 0 END) AS false_positive_count,
+                SUM(CASE WHEN prediction = 0 AND actual_value = 1 THEN 1 ELSE 0 END) AS false_negative_count,
+                SUM(CASE WHEN prediction = 0 AND actual_value = 0 THEN 1 ELSE 0 END) AS true_negative_count,
+                any_value({escaped_positive_class_label}) as class_label
+            FROM normalized_data
+            GROUP BY ts
+            ORDER BY ts
+        """
+
+        results = ddb_conn.sql(confusion_matrix_query).df()
+
+        tp = self.group_query_results_to_numeric_metrics(
+            results,
+            "true_positive_count",
+            dim_columns=["class_label"],
+            timestamp_col="ts",
+        )
+        fp = self.group_query_results_to_numeric_metrics(
+            results,
+            "false_positive_count",
+            dim_columns=["class_label"],
+            timestamp_col="ts",
+        )
+        fn = self.group_query_results_to_numeric_metrics(
+            results,
+            "false_negative_count",
+            dim_columns=["class_label"],
+            timestamp_col="ts",
+        )
+        tn = self.group_query_results_to_numeric_metrics(
+            results,
+            "true_negative_count",
+            dim_columns=["class_label"],
+            timestamp_col="ts",
+        )
+        tp_metric = self.series_to_metric(
+            "multiclass_confusion_matrix_single_class_true_positive_count",
+            tp,
+        )
+        fp_metric = self.series_to_metric(
+            "multiclass_confusion_matrix_single_class_false_positive_count",
+            fp,
+        )
+        fn_metric = self.series_to_metric(
+            "multiclass_confusion_matrix_single_class_false_negative_count",
+            fn,
+        )
+        tn_metric = self.series_to_metric(
+            "multiclass_confusion_matrix_single_class_true_negative_count",
+            tn,
+        )
+        return [tp_metric, fp_metric, fn_metric, tn_metric]

arthur_common/aggregations/functions/multiclass_inference_count_by_class.py

@@ -0,0 +1,90 @@
+from typing import Annotated
+from uuid import UUID
+
+from arthur_common.aggregations.functions.inference_count_by_class import (
+    BinaryClassifierCountByClassAggregationFunction,
+)
+from arthur_common.models.datasets import ModelProblemType
+from arthur_common.models.metrics import DatasetReference, NumericMetric
+from arthur_common.models.schema_definitions import (
+    DType,
+    MetricColumnParameterAnnotation,
+    MetricDatasetParameterAnnotation,
+    ScalarType,
+    ScopeSchemaTag,
+)
+from duckdb import DuckDBPyConnection
+
+
+class MulticlassClassifierCountByClassAggregationFunction(
+    BinaryClassifierCountByClassAggregationFunction,
+):
+    """
+    This class simply exposes the same calculation as the BinaryClassifierCountByClassAggregationFunction
+    but using the MULTICLASS_CLASSIFICATION tags
+    """
+
+    @staticmethod
+    def id() -> UUID:
+        return UUID("64a338fb-6c99-4c40-ba39-81ab8baa8687")
+
+    @staticmethod
+    def display_name() -> str:
+        return "Multiclass Classification Count by Class - Class Label"
+
+    @staticmethod
+    def description() -> str:
+        return (
+            "Aggregation that counts the number of predictions by class for a multiclass classifier. "
+            "Takes boolean, integer, or string prediction values and groups them by time bucket "
+            "to show prediction distribution over time."
+        )
+
+    @staticmethod
+    def _metric_name() -> str:
+        return "multiclass_classifier_count_by_class"
+
+    def aggregate(
+        self,
+        ddb_conn: DuckDBPyConnection,
+        dataset: Annotated[
+            DatasetReference,
+            MetricDatasetParameterAnnotation(
+                friendly_name="Dataset",
+                description="The dataset containing multiclass classifier prediction values.",
+                model_problem_type=ModelProblemType.MULTICLASS_CLASSIFICATION,
+            ),
+        ],
+        timestamp_col: Annotated[
+            str,
+            MetricColumnParameterAnnotation(
+                source_dataset_parameter_key="dataset",
+                tag_hints=[ScopeSchemaTag.PRIMARY_TIMESTAMP],
+                allowed_column_types=[
+                    ScalarType(dtype=DType.TIMESTAMP),
+                ],
+                friendly_name="Timestamp Column",
+                description="A column containing timestamp values to bucket by.",
+            ),
+        ],
+        prediction_col: Annotated[
+            str,
+            MetricColumnParameterAnnotation(
+                source_dataset_parameter_key="dataset",
+                allowed_column_types=[
+                    ScalarType(dtype=DType.BOOL),
+                    ScalarType(dtype=DType.INT),
+                    ScalarType(dtype=DType.STRING),
+                ],
+                tag_hints=[ScopeSchemaTag.PREDICTION],
+                friendly_name="Prediction Column",
+                description="A column containing boolean, integer, or string labelled prediction values.",
+            ),
+        ],
+    ) -> list[NumericMetric]:
+        return super().aggregate(
+            ddb_conn=ddb_conn,
+            dataset=dataset,
+            timestamp_col=timestamp_col,
+            prediction_col=prediction_col,
+        )

arthur_common/aggregations/functions/numeric_stats.py

@@ -0,0 +1,90 @@
+from typing import Annotated
+from uuid import UUID
+
+from arthur_common.aggregations.aggregator import SketchAggregationFunction
+from arthur_common.models.metrics import DatasetReference, SketchMetric
+from arthur_common.models.schema_definitions import (
+    DType,
+    MetricColumnParameterAnnotation,
+    MetricDatasetParameterAnnotation,
+    ScalarType,
+    ScopeSchemaTag,
+)
+from arthur_common.tools.duckdb_data_loader import escape_identifier, escape_str_literal
+from duckdb import DuckDBPyConnection
+
+
+class NumericSketchAggregationFunction(SketchAggregationFunction):
+    METRIC_NAME = "numeric_sketch"
+
+    @staticmethod
+    def id() -> UUID:
+        return UUID("00000000-0000-0000-0000-00000000000d")
+
+    @staticmethod
+    def display_name() -> str:
+        return "Numeric Distribution"
+
+    @staticmethod
+    def description() -> str:
+        return (
+            "Metric that calculates a distribution (data sketch) on a numeric column."
+        )
+
+    def aggregate(
+        self,
+        ddb_conn: DuckDBPyConnection,
+        dataset: Annotated[
+            DatasetReference,
+            MetricDatasetParameterAnnotation(
+                friendly_name="Dataset",
+                description="The dataset containing the numeric data.",
+            ),
+        ],
+        timestamp_col: Annotated[
+            str,
+            MetricColumnParameterAnnotation(
+                source_dataset_parameter_key="dataset",
+                allowed_column_types=[
+                    ScalarType(dtype=DType.TIMESTAMP),
+                ],
+                tag_hints=[ScopeSchemaTag.PRIMARY_TIMESTAMP],
+                friendly_name="Timestamp Column",
+                description="A column containing timestamp values to bucket by.",
+            ),
+        ],
+        numeric_col: Annotated[
+            str,
+            MetricColumnParameterAnnotation(
+                source_dataset_parameter_key="dataset",
+                allowed_column_types=[
+                    ScalarType(dtype=DType.INT),
+                    ScalarType(dtype=DType.FLOAT),
+                ],
+                tag_hints=[ScopeSchemaTag.CONTINUOUS],
+                friendly_name="Numeric Column",
+                description="A column containing numeric values to calculate a data sketch on.",
+            ),
+        ],
+    ) -> list[SketchMetric]:
+        escaped_timestamp_col_id = escape_identifier(timestamp_col)
+        escaped_numeric_col_id = escape_identifier(numeric_col)
+        numeric_col_name_str = escape_str_literal(numeric_col)
+        data_query = f" \
+            select {escaped_timestamp_col_id} as ts, \
+                   {escaped_numeric_col_id}, \
+                   {numeric_col_name_str} as column_name \
+            from {dataset.dataset_table_name} \
+            where {escaped_numeric_col_id} is not null \
+        "
+        results = ddb_conn.sql(data_query).df()
+
+        series = self.group_query_results_to_sketch_metrics(
+            results,
+            numeric_col,
+            ["column_name"],
+            "ts",
+        )
+
+        metric = self.series_to_metric(self.METRIC_NAME, series)
+        return [metric]