Implementation:Evidentlyai Evidently Legacy Metric Results

Knowledge Sources	Evidentlyai_Evidently
Domains	ML Monitoring, Data Models
Last Updated	2026-02-14 12:00 GMT

Overview

Defines the Pydantic-based data models (MetricResult subclasses) used to represent the output of legacy Evidently metric calculations, including distributions, confusion matrices, prediction data, classification quality, scatter plots, histograms, correlations, and curve data for ROC, PR, and lift analysis.

Description

This module provides the structured result types that metrics return and renderers consume. All classes extend MetricResult and are serializable via Pydantic, with configuration controlling how fields are included in JSON, pandas, and rendering outputs via IncludeTags.

Core result models:

Distribution -- Stores x and y arrays for histogram/distribution plots. Supports numpy arrays, lists, pandas Series, and Categorical types. Tagged for render-only inclusion.
DistributionIncluded -- A variant of Distribution that is included in dictionary serialization (not render-only).
ConfusionMatrix -- Holds a sequence of labels and a nested list of confusion matrix values.
PredictionData -- Stores predicted labels (pd.Series), label list, and optional prediction probabilities (pd.DataFrame). Includes a validator that aligns column label types.
StatsByFeature -- Wraps a plotting DataFrame and optional predictions for feature-level statistics.
DatasetUtilityColumns -- Names of special columns: date, id, target, prediction.
DatasetColumns -- Complete dataset schema: utility columns, target type, feature name lists (numerical, categorical, text, datetime), target names, and task type. Includes helper methods for listing features and columns.
ScatterField / ScatterAggField -- Scatter plot data for raw and aggregated views, respectively, holding column-to-series/DataFrame mappings, x-axis names, and plot shapes.
ColumnScatterResult / ColumnAggScatterResult -- Paired current/reference scatter data.
Boxes -- Box-plot statistics: mins, lowers (Q1), means (median), uppers (Q3), maxs.
RatesPlotData -- TPR, FPR, FNR, TNR rate curves at various thresholds for binary classification.
PRCurveData / ROCCurveData / LiftCurveData -- Per-label curve data for PR, ROC, and lift analysis.
HistogramData -- A flexible histogram container with x/count Series and factory methods for construction from DataFrames, Distributions, or dictionaries.
Histogram -- Pairs current and reference histograms with optional log-scale variants.
ColumnCorrelations -- Stores correlation values (as DistributionIncluded) between a named column and other features, with a method kind label.
DatasetClassificationQuality -- Full classification quality: accuracy, precision, recall, F1, and optional ROC AUC, log loss, TPR/TNR/FPR/FNR, rate plot data, and box plot data.

Utility functions:

raw_agg_properties -- A factory that creates a pair of property descriptors for accessing raw vs. aggregated scatter data from a single field.
df_from_column_scatter / column_scatter_from_df -- Convert between ColumnScatter dictionaries and pandas DataFrames.

Type aliases:

LabelList = List[Label], PlotData = List[float], PRCurve = Dict[Label, PRCurveData], ROCCurve = Dict[Label, ROCCurveData], LiftCurve = Dict[Label, LiftCurveData]

Usage

These models are returned by metric calculate() methods and consumed by renderers (HTML, JSON, pandas). Import them when defining custom metrics or when building custom rendering logic.

Code Reference

Source Location

Repository: Evidentlyai_Evidently
File: src/evidently/legacy/metric_results.py

Signature

class Distribution(MetricResult):
    x: Union[np.ndarray, list, pd.Categorical, pd.Series]
    y: Union[np.ndarray, list, pd.Categorical, pd.Series]

class ConfusionMatrix(MetricResult):
    labels: Sequence[Label]
    values: list

class PredictionData(MetricResult):
    predictions: pd.Series
    labels: LabelList
    prediction_probas: Optional[pd.DataFrame]

class DatasetUtilityColumns(MetricResult):
    date: Optional[str]
    id: Optional[str]
    target: Optional[str]
    prediction: Optional[Union[str, Sequence[str]]]

class DatasetColumns(MetricResult):
    utility_columns: DatasetUtilityColumns
    target_type: Optional[str]
    num_feature_names: List[str]
    cat_feature_names: List[str]
    text_feature_names: List[str]
    datetime_feature_names: List[str]
    target_names: Optional[TargetNames]
    task: Optional[str]
    def get_all_features_list(...) -> List[str]: ...
    def get_all_columns_list(...) -> List[str]: ...

class ScatterField(MetricResult):
    scatter: ColumnScatter
    x_name: str
    plot_shape: Dict[str, float]

class ScatterAggField(MetricResult):
    scatter: ColumnAggScatter
    x_name: str
    plot_shape: Dict[str, float]

class Boxes(MetricResult):
    mins: PlotData; lowers: PlotData; means: PlotData; uppers: PlotData; maxs: PlotData

class RatesPlotData(MetricResult):
    thrs: PlotData; tpr: PlotData; fpr: PlotData; fnr: PlotData; tnr: PlotData

class HistogramData(MetricResult):
    x: pd.Series; count: pd.Series; name: Optional[str]
    @classmethod
    def from_distribution(cls, dist: Optional[Distribution], name: Optional[str] = None): ...
    @classmethod
    def from_any(cls, value, name: Optional[str] = None): ...

class Histogram(MetricResult):
    current: HistogramData
    reference: Optional[HistogramData]

class ColumnCorrelations(MetricResult):
    column_name: str; kind: str; values: DistributionIncluded

class DatasetClassificationQuality(MetricResult):
    accuracy: float; precision: float; recall: float; f1: float
    roc_auc: Optional[float]; log_loss: Optional[float]
    tpr: Optional[float]; tnr: Optional[float]
    fpr: Optional[float]; fnr: Optional[float]
    rate_plots_data: Optional[RatesPlotData]
    plot_data: Optional[Boxes]

def raw_agg_properties(field_name, raw_type, agg_type, optional) -> Tuple[property, property]: ...

Import

from evidently.legacy.metric_results import (
    Distribution,
    DistributionIncluded,
    ConfusionMatrix,
    PredictionData,
    DatasetColumns,
    DatasetUtilityColumns,
    DatasetClassificationQuality,
    HistogramData,
    Histogram,
    ColumnCorrelations,
    Boxes,
    RatesPlotData,
    ScatterField,
    ScatterAggField,
    ColumnScatterResult,
    PRCurveData,
    ROCCurveData,
    LiftCurveData,
    raw_agg_properties,
)

I/O Contract

Inputs

Name	Type	Required	Description
x	`Union[np.ndarray, list, pd.Series]`	Yes (for Distribution)	X-axis values for distribution data.
y	`Union[np.ndarray, list, pd.Series]`	Yes (for Distribution)	Y-axis values for distribution data.
labels	`Sequence[Label]`	Yes (for ConfusionMatrix)	Class labels in sorted order.
values	`list`	Yes (for ConfusionMatrix)	Nested list of confusion matrix counts.
predictions	`pd.Series`	Yes (for PredictionData)	Predicted class labels or values.
prediction_probas	`Optional[pd.DataFrame]`	No (for PredictionData)	Prediction probability matrix indexed by class labels.

Outputs

Name	Type	Description
MetricResult subclass	Various	Serializable Pydantic models consumed by renderers and exported as JSON, dict, or DataFrame.
pd.DataFrame	`pd.DataFrame`	Via `get_pandas()` on result classes like ColumnCorrelations.

Usage Examples

import pandas as pd
from evidently.legacy.metric_results import (
    Distribution,
    HistogramData,
    DatasetColumns,
    DatasetUtilityColumns,
    ColumnCorrelations,
    DistributionIncluded,
)

# Create a distribution
dist = Distribution(x=[1, 2, 3, 4], y=[10, 20, 30, 40])

# Create a histogram from a distribution
hist = HistogramData.from_distribution(dist, name="my_feature")
print(hist.x.tolist())  # [1, 2, 3, 4]

# Build dataset columns metadata
columns = DatasetColumns(
    utility_columns=DatasetUtilityColumns(date=None, id=None, target="y", prediction="pred"),
    target_type="num",
    num_feature_names=["f1", "f2"],
    cat_feature_names=["c1"],
    text_feature_names=[],
    datetime_feature_names=[],
    target_names=None,
    task="regression",
)
all_features = columns.get_all_features_list()
print(all_features)  # ['c1', 'f1', 'f2']

# Create column correlations result
corr = ColumnCorrelations(
    column_name="f1",
    kind="pearson",
    values=DistributionIncluded(x=["f2", "f3"], y=[0.9, -0.3]),
)
df = corr.get_pandas()
print(df)

Related Pages

Environment:Evidentlyai_Evidently_Python_Core_Environment
Evidentlyai_Evidently_Legacy_Base_Metric -- Base MetricResult class and Metric framework
Evidentlyai_Evidently_Legacy_Classification_Calculations -- Functions that produce DatasetClassificationQuality, ConfusionMatrix, etc.
Evidentlyai_Evidently_Legacy_Data_Drift_Calculations -- Functions that produce ColumnDataDriftMetrics using Distribution, ScatterField, etc.
Evidentlyai_Evidently_Legacy_HTML_Widgets -- Rendering layer that consumes these result models

Page Connections

Double-click a node to navigate. Hold to expand connections.

Principle

Implementation

Heuristic

Environment