ValidMind for model development 2 — Start the model development process

Learn how to use ValidMind for your end-to-end model documentation process with our series of four introductory notebooks. In this second notebook, you'll run tests and investigate results, then add the results or evidence to your documentation.

You'll become familiar with the individual tests available in ValidMind, as well as how to run them and change parameters as necessary. Using ValidMind's repository of individual tests as building blocks helps you ensure that a model is being built appropriately.

For a full list of out-of-the-box tests, refer to our Test descriptions or try the interactive Test sandbox.

Learn by doing

Our course tailor-made for developers new to ValidMind combines this series of notebooks with more a more in-depth introduction to the ValidMind Platform — Developer Fundamentals

Prerequisites

In order to log test results or evidence to your model documentation with this notebook, you'll need to first have:

• Registered a model within the ValidMind Platform with a predefined documentation template
• Installed the ValidMind Library in your local environment, allowing you to access all its features

Need help with the above steps?

Refer to the first notebook in this series: 1 — Set up the ValidMind Library

Setting up

Initialize the ValidMind Library

First, let's connect up the ValidMind Library to our model we previously registered in the ValidMind Platform:

1. In a browser, log in to ValidMind.

2. In the left sidebar, navigate to Inventory and select the model you registered for this "ValidMind for model development" series of notebooks.

3. Go to Getting Started and click Copy snippet to clipboard.

Next, load your model identifier credentials from an .env file or replace the placeholder with your own code snippet:

# Make sure the ValidMind Library is installed

%pip install -q validmind

# Load your model identifier credentials from an `.env` file

%load_ext dotenv
%dotenv .env

# Or replace with your code snippet

import validmind as vm

vm.init(
    # api_host="...",
    # api_key="...",
    # api_secret="...",
    # model="...",
)

Note: you may need to restart the kernel to use updated packages.

2026-01-30 23:12:33,684 - INFO(validmind.api_client): 🎉 Connected to ValidMind!
📊 Model: [ValidMind Academy] Model development (ID: cmalgf3qi02ce199qm3rdkl46)
📁 Document Type: model_documentation

Import sample dataset

Then, let's import the public Bank Customer Churn Prediction dataset from Kaggle.

In our below example, note that:

• The target column, Exited has a value of 1 when a customer has churned and 0 otherwise.
• The ValidMind Library provides a wrapper to automatically load the dataset as a Pandas DataFrame object. A Pandas Dataframe is a two-dimensional tabular data structure that makes use of rows and columns.

from validmind.datasets.classification import customer_churn as demo_dataset

print(
    f"Loaded demo dataset with: \n\n\t• Target column: '{demo_dataset.target_column}' \n\t• Class labels: {demo_dataset.class_labels}"
)

raw_df = demo_dataset.load_data()
raw_df.head()

Loaded demo dataset with: 

    • Target column: 'Exited' 
    • Class labels: {'0': 'Did not exit', '1': 'Exited'}

	CreditScore	Geography	Gender	Age	Tenure	Balance	NumOfProducts	HasCrCard	IsActiveMember	EstimatedSalary	Exited
0	619	France	Female	42	2	0.00	1	1	1	101348.88	1
1	608	Spain	Female	41	1	83807.86	1	0	1	112542.58	0
2	502	France	Female	42	8	159660.80	3	1	0	113931.57	1
3	699	France	Female	39	1	0.00	2	0	0	93826.63	0
4	850	Spain	Female	43	2	125510.82	1	1	1	79084.10	0

Identify qualitative tests

Next, let's say we want to do some data quality assessments by running a few individual tests.

Use the vm.tests.list_tests() function introduced by the first notebook in this series in combination with vm.tests.list_tags() and vm.tests.list_tasks() to find which prebuilt tests are relevant for data quality assessment:

• tasks represent the kind of modeling task associated with a test. Here we'll focus on classification tasks.
• tags are free-form descriptions providing more details about the test, for example, what category the test falls into. Here we'll focus on the data_quality tag.

# Get the list of available task types
sorted(vm.tests.list_tasks())

['classification',
 'clustering',
 'data_validation',
 'feature_extraction',
 'monitoring',
 'nlp',
 'regression',
 'residual_analysis',
 'text_classification',
 'text_generation',
 'text_qa',
 'text_summarization',
 'time_series_forecasting',
 'visualization']

# Get the list of available tags
sorted(vm.tests.list_tags())

['AUC',
 'analysis',
 'anomaly_detection',
 'bias_and_fairness',
 'binary_classification',
 'calibration',
 'categorical_data',
 'classification',
 'classification_metrics',
 'clustering',
 'correlation',
 'credit_risk',
 'data_analysis',
 'data_distribution',
 'data_quality',
 'data_validation',
 'descriptive_statistics',
 'dimensionality_reduction',
 'distribution',
 'embeddings',
 'feature_importance',
 'feature_selection',
 'few_shot',
 'forecasting',
 'frequency_analysis',
 'kmeans',
 'linear_regression',
 'llm',
 'logistic_regression',
 'metadata',
 'model_comparison',
 'model_diagnosis',
 'model_explainability',
 'model_interpretation',
 'model_performance',
 'model_predictions',
 'model_selection',
 'model_training',
 'model_validation',
 'multiclass_classification',
 'nlp',
 'normality',
 'numerical_data',
 'outliers',
 'qualitative',
 'rag_performance',
 'ragas',
 'regression',
 'retrieval_performance',
 'scorecard',
 'seasonality',
 'senstivity_analysis',
 'sklearn',
 'stationarity',
 'statistical_test',
 'statistics',
 'statsmodels',
 'tabular_data',
 'text_data',
 'threshold_optimization',
 'time_series_data',
 'unit_root_test',
 'visualization',
 'zero_shot']

You can pass tags and tasks as parameters to the vm.tests.list_tests() function to filter the tests based on the tags and task types.

For example, to find tests related to tabular data quality for classification models, you can call list_tests() like this:

vm.tests.list_tests(task="classification", tags=["tabular_data", "data_quality"])

ID	Name	Description	Has Figure	Has Table	Required Inputs	Params	Tags	Tasks
validmind.data_validation.ClassImbalance	Class Imbalance	Evaluates and quantifies class distribution imbalance in a dataset used by a machine learning model....	True	True	['dataset']	{'min_percent_threshold': {'type': 'int', 'default': 10}}	['tabular_data', 'binary_classification', 'multiclass_classification', 'data_quality']	['classification']
validmind.data_validation.DescriptiveStatistics	Descriptive Statistics	Performs a detailed descriptive statistical analysis of both numerical and categorical data within a model's...	False	True	['dataset']	{}	['tabular_data', 'time_series_data', 'data_quality']	['classification', 'regression']
validmind.data_validation.Duplicates	Duplicates	Tests dataset for duplicate entries, ensuring model reliability via data quality verification....	False	True	['dataset']	{'min_threshold': {'type': '_empty', 'default': 1}}	['tabular_data', 'data_quality', 'text_data']	['classification', 'regression']
validmind.data_validation.HighCardinality	High Cardinality	Assesses the number of unique values in categorical columns to detect high cardinality and potential overfitting....	False	True	['dataset']	{'num_threshold': {'type': 'int', 'default': 100}, 'percent_threshold': {'type': 'float', 'default': 0.1}, 'threshold_type': {'type': 'str', 'default': 'percent'}}	['tabular_data', 'data_quality', 'categorical_data']	['classification', 'regression']
validmind.data_validation.HighPearsonCorrelation	High Pearson Correlation	Identifies highly correlated feature pairs in a dataset suggesting feature redundancy or multicollinearity....	False	True	['dataset']	{'max_threshold': {'type': 'float', 'default': 0.3}, 'top_n_correlations': {'type': 'int', 'default': 10}, 'feature_columns': {'type': 'list', 'default': None}}	['tabular_data', 'data_quality', 'correlation']	['classification', 'regression']
validmind.data_validation.MissingValues	Missing Values	Evaluates dataset quality by ensuring missing value ratio across all features does not exceed a set threshold....	False	True	['dataset']	{'min_threshold': {'type': 'int', 'default': 1}}	['tabular_data', 'data_quality']	['classification', 'regression']
validmind.data_validation.MissingValuesBarPlot	Missing Values Bar Plot	Assesses the percentage and distribution of missing values in the dataset via a bar plot, with emphasis on...	True	False	['dataset']	{'threshold': {'type': 'int', 'default': 80}, 'fig_height': {'type': 'int', 'default': 600}}	['tabular_data', 'data_quality', 'visualization']	['classification', 'regression']
validmind.data_validation.Skewness	Skewness	Evaluates the skewness of numerical data in a dataset to check against a defined threshold, aiming to ensure data...	False	True	['dataset']	{'max_threshold': {'type': '_empty', 'default': 1}}	['data_quality', 'tabular_data']	['classification', 'regression']
validmind.plots.BoxPlot	Box Plot	Generates customizable box plots for numerical features in a dataset with optional grouping using Plotly....	True	False	['dataset']	{'columns': {'type': 'Optional', 'default': None}, 'group_by': {'type': 'Optional', 'default': None}, 'width': {'type': 'int', 'default': 1800}, 'height': {'type': 'int', 'default': 1200}, 'colors': {'type': 'Optional', 'default': None}, 'show_outliers': {'type': 'bool', 'default': True}, 'title_prefix': {'type': 'str', 'default': 'Box Plot of'}}	['tabular_data', 'visualization', 'data_quality']	['classification', 'regression', 'clustering']
validmind.plots.HistogramPlot	Histogram Plot	Generates customizable histogram plots for numerical features in a dataset using Plotly....	True	False	['dataset']	{'columns': {'type': 'Optional', 'default': None}, 'bins': {'type': 'Union', 'default': 30}, 'color': {'type': 'str', 'default': 'steelblue'}, 'opacity': {'type': 'float', 'default': 0.7}, 'show_kde': {'type': 'bool', 'default': True}, 'normalize': {'type': 'bool', 'default': False}, 'log_scale': {'type': 'bool', 'default': False}, 'title_prefix': {'type': 'str', 'default': 'Histogram of'}, 'width': {'type': 'int', 'default': 1200}, 'height': {'type': 'int', 'default': 800}, 'n_cols': {'type': 'int', 'default': 2}, 'vertical_spacing': {'type': 'float', 'default': 0.15}, 'horizontal_spacing': {'type': 'float', 'default': 0.1}}	['tabular_data', 'visualization', 'data_quality']	['classification', 'regression', 'clustering']
validmind.stats.DescriptiveStats	Descriptive Stats	Provides comprehensive descriptive statistics for numerical features in a dataset....	False	True	['dataset']	{'columns': {'type': 'Optional', 'default': None}, 'include_advanced': {'type': 'bool', 'default': True}, 'confidence_level': {'type': 'float', 'default': 0.95}}	['tabular_data', 'statistics', 'data_quality']	['classification', 'regression', 'clustering']

Want to learn more about navigating ValidMind tests?

Refer to our notebook outlining the utilities available for viewing and understanding available ValidMind tests: Explore tests

Initialize the ValidMind datasets

With the individual tests we want to run identified, the next step is to connect your data with a ValidMind Dataset object. This step is always necessary every time you want to connect a dataset to documentation and produce test results through ValidMind, but you only need to do it once per dataset.

Initialize a ValidMind dataset object using the init_dataset function from the ValidMind (vm) module. For this example, we'll pass in the following arguments:

• dataset — The raw dataset that you want to provide as input to tests.
• input_id — A unique identifier that allows tracking what inputs are used when running each individual test.
• target_column — A required argument if tests require access to true values. This is the name of the target column in the dataset.

# vm_raw_dataset is now a VMDataset object that you can pass to any ValidMind test
vm_raw_dataset = vm.init_dataset(
    dataset=raw_df,
    input_id="raw_dataset",
    target_column="Exited",
)

Running tests

Now that we know how to initialize a ValidMind dataset object, we're ready to run some tests!

You run individual tests by calling the run_test function provided by the validmind.tests module. For the examples below, we'll pass in the following arguments:

• test_id — The ID of the test to run, as seen in the ID column when you run list_tests.
• params — A dictionary of parameters for the test. These will override any default_params set in the test definition.

Run tabular data tests

The inputs expected by a test can also be found in the test definition — let's take validmind.data_validation.DescriptiveStatistics as an example.

Note that the output of the describe_test() function below shows that this test expects a dataset as input:

vm.tests.describe_test("validmind.data_validation.DescriptiveStatistics")

▶ Test: Descriptive Statistics ('validmind.data_validation.DescriptiveStatistics')

Descriptive Statistics

Performs a detailed descriptive statistical analysis of both numerical and categorical data within a model's dataset.

Purpose

The purpose of the Descriptive Statistics metric is to provide a comprehensive summary of both numerical and categorical data within a dataset. This involves statistics such as count, mean, standard deviation, minimum and maximum values for numerical data. For categorical data, it calculates the count, number of unique values, most common value and its frequency, and the proportion of the most frequent value relative to the total. The goal is to visualize the overall distribution of the variables in the dataset, aiding in understanding the model's behavior and predicting its performance.

Test Mechanism

The testing mechanism utilizes two in-built functions of pandas dataframes: describe() for numerical fields and value_counts() for categorical fields. The describe() function pulls out several summary statistics, while value_counts() accounts for unique values. The resulting data is formatted into two distinct tables, one for numerical and another for categorical variable summaries. These tables provide a clear summary of the main characteristics of the variables, which can be instrumental in assessing the model's performance.

Signs of High Risk

• Skewed data or significant outliers can represent high risk. For numerical data, this may be reflected via a significant difference between the mean and median (50% percentile).
• For categorical data, a lack of diversity (low count of unique values), or overdominance of a single category (high frequency of the top value) can indicate high risk.

Strengths

• Provides a comprehensive summary of the dataset, shedding light on the distribution and characteristics of the variables under consideration.
• It is a versatile and robust method, applicable to both numerical and categorical data.
• Helps highlight crucial anomalies such as outliers, extreme skewness, or lack of diversity, which are vital in understanding model behavior during testing and validation.

Limitations

• While this metric offers a high-level overview of the data, it may fail to detect subtle correlations or complex patterns.
• Does not offer any insights on the relationship between variables.
• Alone, descriptive statistics cannot be used to infer properties about future unseen data.
• Should be used in conjunction with other statistical tests to provide a comprehensive understanding of the model's data.

Required Inputs: dataset

Parameters:

Parameter	Default Value

How to Run:

Code:

        
import validmind as vm

# inputs dictionary maps your inputs to the expected input names
# keys are the expected input names and values are the actual inputs
# values may be string input_ids or the actual VMDataset or VMModel objects
inputs = {
    "dataset": "my_vm_dataset"
}
params = {}

# to run and view the result of this test, run the following code:
result = vm.tests.run_test(
  "validmind.data_validation.DescriptiveStatistics", inputs=inputs, params=params
)

# To see the result of the test, ensure that you have called `vm.init()` and then run:
result.log()
    

Now, let's run a few tests to assess the quality of the dataset:

result = vm.tests.run_test(
    test_id="validmind.data_validation.DescriptiveStatistics",
    inputs={"dataset": vm_raw_dataset},
)

Descriptive Statistics

The Descriptive Statistics test evaluates the distributional characteristics and summary statistics of both numerical and categorical variables in the dataset. The results are presented in two tables: one summarizing key statistics for numerical variables such as mean, standard deviation, and percentiles, and another detailing counts, unique values, and frequency distributions for categorical variables. These tables provide a comprehensive overview of the dataset’s structure, central tendencies, and variability, supporting assessment of data quality and potential risk factors.

Key insights:

• Wide range and skewness in balance values: The Balance variable exhibits a minimum of 0.0, a median of 97,264.0, and a maximum of 250,898.0, with a mean (76,434.1) substantially below the median, indicating a right-skewed distribution and a significant proportion of zero balances.
• High concentration in categorical variables: The Geography variable is dominated by "France" (50.12%), and Gender is predominantly "Male" (54.95%), indicating limited diversity in these categories.
• Binary variables with balanced representation: HasCrCard and IsActiveMember are binary variables with means of 0.70 and 0.52, respectively, suggesting moderate balance between classes.
• CreditScore and Age distributions are symmetric: CreditScore and Age have means (650.2 and 38.9) closely aligned with their medians (652.0 and 37.0), and standard deviations (96.8 and 10.5) consistent with their observed ranges, indicating relatively symmetric distributions.
• Low diversity in product holdings: NumOfProducts has a mean of 1.53 and a median of 1.0, with a maximum of 4.0, indicating most customers hold one or two products.

The dataset displays a mix of symmetric and skewed distributions among numerical variables, with Balance showing pronounced right skew and a substantial proportion of zero values. Categorical variables exhibit high concentration in single categories, particularly for Geography and Gender, which may limit representativeness. Binary variables are moderately balanced, and product holdings are concentrated at the lower end. These characteristics highlight areas of potential risk related to data diversity and distributional skewness, which may influence model behavior and generalizability.

Tables

Numerical Variables

Name	Count	Mean	Std	Min	25%	50%	75%	90%	95%	Max
CreditScore	8000.0	650.1596	96.8462	350.0	583.0	652.0	717.0	778.0	813.0	850.0
Age	8000.0	38.9489	10.4590	18.0	32.0	37.0	44.0	53.0	60.0	92.0
Tenure	8000.0	5.0339	2.8853	0.0	3.0	5.0	8.0	9.0	9.0	10.0
Balance	8000.0	76434.0965	62612.2513	0.0	0.0	97264.0	128045.0	149545.0	162488.0	250898.0
NumOfProducts	8000.0	1.5325	0.5805	1.0	1.0	1.0	2.0	2.0	2.0	4.0
HasCrCard	8000.0	0.7026	0.4571	0.0	0.0	1.0	1.0	1.0	1.0	1.0
IsActiveMember	8000.0	0.5199	0.4996	0.0	0.0	1.0	1.0	1.0	1.0	1.0
EstimatedSalary	8000.0	99790.1880	57520.5089	12.0	50857.0	99505.0	149216.0	179486.0	189997.0	199992.0

Categorical Variables

Name	Count	Number of Unique Values	Top Value	Top Value Frequency	Top Value Frequency %
Geography	8000.0	3.0	France	4010.0	50.12
Gender	8000.0	2.0	Male	4396.0	54.95

result2 = vm.tests.run_test(
    test_id="validmind.data_validation.ClassImbalance",
    inputs={"dataset": vm_raw_dataset},
    params={"min_percent_threshold": 30},
)

❌ Class Imbalance

The Class Imbalance test evaluates the distribution of target classes in the dataset to identify potential imbalances that could impact model performance. The results table presents the percentage of records for each class in the "Exited" target variable, alongside a pass/fail assessment based on a minimum percentage threshold of 30%. The accompanying bar plot visually depicts the proportion of each class, highlighting the relative representation of the majority and minority classes.

Key insights:

• Majority class exceeds threshold: The "Exited = 0" class constitutes 79.80% of the dataset and passes the minimum percentage threshold.
• Minority class below threshold: The "Exited = 1" class represents 20.20% of the dataset and fails the 30% minimum threshold, indicating under-representation.
• Visual confirmation of imbalance: The bar plot demonstrates a pronounced disparity between the two classes, with the majority class substantially outnumbering the minority class.

The results indicate a notable class imbalance, with the minority class ("Exited = 1") falling below the specified 30% threshold. This distribution suggests that the dataset is skewed toward the majority class, which may influence model learning and predictive behavior. The observed imbalance is quantitatively supported by both the tabular and visual outputs.

Parameters:

{
  "min_percent_threshold": 30
}
            

Tables

Exited Class Imbalance

Exited	Percentage of Rows (%)	Pass/Fail
0	79.80%	Pass
1	20.20%	Fail

Figures

The output above shows that the class imbalance test did not pass according to the value we set for min_percent_threshold.

To address this issue, we'll re-run the test on some processed data. In this case let's apply a very simple rebalancing technique to the dataset:

import pandas as pd

raw_copy_df = raw_df.sample(frac=1)  # Create a copy of the raw dataset

# Create a balanced dataset with the same number of exited and not exited customers
exited_df = raw_copy_df.loc[raw_copy_df["Exited"] == 1]
not_exited_df = raw_copy_df.loc[raw_copy_df["Exited"] == 0].sample(n=exited_df.shape[0])

balanced_raw_df = pd.concat([exited_df, not_exited_df])
balanced_raw_df = balanced_raw_df.sample(frac=1, random_state=42)

With this new balanced dataset, you can re-run the individual test to see if it now passes the class imbalance test requirement.

As this is technically a different dataset, remember to first initialize a new ValidMind Dataset object to pass in as input as required by run_test():

# Register new data and now 'balanced_raw_dataset' is the new dataset object of interest
vm_balanced_raw_dataset = vm.init_dataset(
    dataset=balanced_raw_df,
    input_id="balanced_raw_dataset",
    target_column="Exited",
)

# Pass the initialized `balanced_raw_dataset` as input into the test run
result = vm.tests.run_test(
    test_id="validmind.data_validation.ClassImbalance",
    inputs={"dataset": vm_balanced_raw_dataset},
    params={"min_percent_threshold": 30},
)

✅ Class Imbalance

The Class Imbalance test evaluates the distribution of target classes in the dataset to identify potential imbalances that could impact model performance. The results table presents the percentage representation of each class in the "Exited" target variable, alongside a pass/fail assessment based on a minimum percentage threshold of 30%. The accompanying bar plot visually displays the proportion of each class, facilitating interpretation of class distribution.

Key insights:

• Equal class representation: Both classes (Exited = 0 and Exited = 1) each constitute 50% of the dataset, indicating a perfectly balanced class distribution.
• All classes meet threshold: Each class exceeds the minimum percentage threshold of 30%, resulting in a "Pass" outcome for both classes.
• No evidence of class imbalance: The visual plot confirms the tabular findings, with both classes represented equally and no indication of under-representation.

The results demonstrate that the dataset exhibits a balanced distribution across the target classes, with both classes equally represented and surpassing the specified minimum threshold. No class imbalance is detected, indicating that the dataset is suitable for training classification models without risk of bias due to class under-representation.

Parameters:

{
  "min_percent_threshold": 30
}
            

Tables

Exited Class Imbalance

Exited	Percentage of Rows (%)	Pass/Fail
0	50.00%	Pass
1	50.00%	Pass

Figures

Utilize test output

You can utilize the output from a ValidMind test for further use, for example, if you want to remove highly correlated features. Removing highly correlated features helps make the model simpler, more stable, and easier to understand.

Below we demonstrate how to retrieve the list of features with the highest correlation coefficients and use them to reduce the final list of features for modeling.

First, we'll run validmind.data_validation.HighPearsonCorrelation with the balanced_raw_dataset we initialized previously as input as is for comparison with later runs:

corr_result = vm.tests.run_test(
    test_id="validmind.data_validation.HighPearsonCorrelation",
    params={"max_threshold": 0.3},
    inputs={"dataset": vm_balanced_raw_dataset},
)

❌ High Pearson Correlation

The High Pearson Correlation test evaluates the linear relationships between feature pairs to identify potential redundancy or multicollinearity. The results table presents the top ten strongest absolute correlations among features, with each pair’s coefficient and Pass/Fail status based on a threshold of 0.3. Only one feature pair exceeds the threshold, while the remaining pairs show lower correlation magnitudes.

Key insights:

• One feature pair exceeds correlation threshold: The (Age, Exited) pair has a correlation coefficient of 0.349, surpassing the 0.3 threshold and resulting in a Fail status.
• All other feature pairs below threshold: The remaining nine feature pairs have absolute correlation coefficients ranging from 0.0404 to 0.1972, all classified as Pass.
• Predominantly weak linear relationships: Most feature pairs exhibit weak linear associations, with coefficients well below the threshold.

The results indicate that the dataset contains predominantly low pairwise linear correlations among features, with only the (Age, Exited) pair exhibiting a moderate correlation above the specified threshold. The overall correlation structure suggests limited risk of feature redundancy or multicollinearity, aside from the identified exception.

Parameters:

{
  "max_threshold": 0.3
}
            

Tables

Columns	Coefficient	Pass/Fail
(Age, Exited)	0.3490	Fail
(IsActiveMember, Exited)	-0.1972	Pass
(Balance, NumOfProducts)	-0.1854	Pass
(Balance, Exited)	0.1378	Pass
(CreditScore, Exited)	-0.0538	Pass
(NumOfProducts, Exited)	-0.0521	Pass
(NumOfProducts, IsActiveMember)	0.0511	Pass
(Age, Tenure)	-0.0453	Pass
(Tenure, IsActiveMember)	-0.0444	Pass
(CreditScore, IsActiveMember)	0.0404	Pass

The output above shows that the test did not pass according to the value we set for max_threshold.

corr_result is an object of type TestResult. We can inspect the result object to see what the test has produced:

print(type(corr_result))
print("Result ID: ", corr_result.result_id)
print("Params: ", corr_result.params)
print("Passed: ", corr_result.passed)
print("Tables: ", corr_result.tables)

<class 'validmind.vm_models.result.result.TestResult'>
Result ID:  validmind.data_validation.HighPearsonCorrelation
Params:  {'max_threshold': 0.3}
Passed:  False
Tables:  [ResultTable]

Let's remove the highly correlated features and create a new VM dataset object.

We'll begin by checking out the table in the result and extracting a list of features that failed the test:

# Extract table from `corr_result.tables`
features_df = corr_result.tables[0].data
features_df

	Columns	Coefficient	Pass/Fail
0	(Age, Exited)	0.3490	Fail
1	(IsActiveMember, Exited)	-0.1972	Pass
2	(Balance, NumOfProducts)	-0.1854	Pass
3	(Balance, Exited)	0.1378	Pass
4	(CreditScore, Exited)	-0.0538	Pass
5	(NumOfProducts, Exited)	-0.0521	Pass
6	(NumOfProducts, IsActiveMember)	0.0511	Pass
7	(Age, Tenure)	-0.0453	Pass
8	(Tenure, IsActiveMember)	-0.0444	Pass
9	(CreditScore, IsActiveMember)	0.0404	Pass

# Extract list of features that failed the test
high_correlation_features = features_df[features_df["Pass/Fail"] == "Fail"]["Columns"].tolist()
high_correlation_features

['(Age, Exited)']

Next, extract the feature names from the list of strings (example: (Age, Exited) > Age):

high_correlation_features = [feature.split(",")[0].strip("()") for feature in high_correlation_features]
high_correlation_features

['Age']

Now, it's time to re-initialize the dataset with the highly correlated features removed.

Note the use of a different input_id. This allows tracking the inputs used when running each individual test.

# Remove the highly correlated features from the dataset
balanced_raw_no_age_df = balanced_raw_df.drop(columns=high_correlation_features)

# Re-initialize the dataset object
vm_raw_dataset_preprocessed = vm.init_dataset(
    dataset=balanced_raw_no_age_df,
    input_id="raw_dataset_preprocessed",
    target_column="Exited",
)

Re-running the test with the reduced feature set should pass the test:

corr_result = vm.tests.run_test(
    test_id="validmind.data_validation.HighPearsonCorrelation",
    params={"max_threshold": 0.3},
    inputs={"dataset": vm_raw_dataset_preprocessed},
)

✅ High Pearson Correlation

The High Pearson Correlation test evaluates the linear relationships between feature pairs to identify potential redundancy or multicollinearity. The results table presents the top ten absolute Pearson correlation coefficients among feature pairs, along with their Pass/Fail status relative to the threshold of 0.3. All reported coefficients are below the threshold, and each feature pair is marked as Pass.

Key insights:

• No high correlations detected: All absolute Pearson correlation coefficients are below the 0.3 threshold, with the highest magnitude observed at 0.1972 between IsActiveMember and Exited.
• Consistent Pass status across feature pairs: Every evaluated feature pair received a Pass status, indicating no evidence of strong linear relationships among the top correlations.
• Low to moderate relationships observed: The reported coefficients range from 0.0331 to 0.1972 in absolute value, reflecting only weak to moderate linear associations.

The test results indicate an absence of strong linear dependencies among the evaluated feature pairs. The observed correlation structure suggests low risk of feature redundancy or multicollinearity within the dataset based on the current threshold. All feature pairs meet the test criteria, supporting the interpretability and stability of subsequent modeling efforts.

Parameters:

{
  "max_threshold": 0.3
}
            

Tables

Columns	Coefficient	Pass/Fail
(IsActiveMember, Exited)	-0.1972	Pass
(Balance, NumOfProducts)	-0.1854	Pass
(Balance, Exited)	0.1378	Pass
(CreditScore, Exited)	-0.0538	Pass
(NumOfProducts, Exited)	-0.0521	Pass
(NumOfProducts, IsActiveMember)	0.0511	Pass
(Tenure, IsActiveMember)	-0.0444	Pass
(CreditScore, IsActiveMember)	0.0404	Pass
(HasCrCard, IsActiveMember)	-0.0362	Pass
(Balance, EstimatedSalary)	0.0331	Pass

You can also plot the correlation matrix to visualize the new correlation between features:

corr_result = vm.tests.run_test(
    test_id="validmind.data_validation.PearsonCorrelationMatrix",
    inputs={"dataset": vm_raw_dataset_preprocessed},
)

Pearson Correlation Matrix

The Pearson Correlation Matrix test evaluates the linear relationships between all pairs of numerical variables in the dataset, providing a visual summary of correlation coefficients ranging from -1 to 1. The resulting heatmap displays the magnitude and direction of these relationships, with higher absolute values indicating stronger linear associations. In this result, the matrix shows the pairwise correlations among variables such as CreditScore, Tenure, Balance, NumOfProducts, HasCrCard, IsActiveMember, EstimatedSalary, and Exited, with no coefficients exceeding the high-correlation threshold of 0.7 in absolute value.

Key insights:

• No high correlations detected: All pairwise correlation coefficients fall well below the 0.7 threshold, indicating an absence of strong linear dependencies among the variables.
• Weak negative association between NumOfProducts and Balance: The most pronounced correlation is -0.19 between NumOfProducts and Balance, which remains in the weak range.
• Minimal association with target variable: The Exited variable shows low correlations with all other features, with the highest absolute value being -0.20 with IsActiveMember.
• Overall low inter-variable dependency: Most coefficients are close to zero, reflecting minimal linear relationships across the dataset.

The correlation structure demonstrates that the dataset does not exhibit material linear redundancy among its numerical variables. All observed relationships are weak, supporting the independence of features and reducing concerns regarding multicollinearity or unnecessary dimensionality.

Figures

Documenting test results

Now that we've done some analysis on two different datasets, we can use ValidMind to easily document why certain things were done to our raw data with testing to support it.

Every test result returned by the run_test() function has a .log() method that can be used to send the test results to the ValidMind Platform:

• When using run_documentation_tests(), documentation sections will be automatically populated with the results of all tests registered in the documentation template.
• When logging individual test results to the platform, you'll need to manually add those results to the desired section of the model documentation.

To demonstrate how to add test results to your model documentation, we'll populate the entire Data Preparation section of the documentation using the clean vm_raw_dataset_preprocessed dataset as input, and then document an additional individual result for the highly correlated dataset vm_balanced_raw_dataset.

Run and log multiple tests

run_documentation_tests() allows you to run multiple tests at once and automatically log the results to your documentation. Below, we'll run the tests using the previously initialized vm_raw_dataset_preprocessed as input — this will populate the entire Data Preparation section for every test that is part of the documentation template.

For this example, we'll pass in the following arguments:

• inputs: Any inputs to be passed to the tests.
• config: A dictionary <test_id>:<test_config> that allows configuring each test individually. Each test config requires the following:
  • params: Individual test parameters.
  • inputs: Individual test inputs. This overrides any inputs passed from the run_documentation_tests() function.

When including explicit configuration for individual tests, you'll need to specify the inputs even if they mirror what is included in your global configuration.

# Individual test config with inputs specified
test_config = {
    "validmind.data_validation.ClassImbalance": {
        "params": {"min_percent_threshold": 30},
        "inputs": {"dataset": vm_raw_dataset_preprocessed},
    },
    "validmind.data_validation.HighPearsonCorrelation": {
        "params": {"max_threshold": 0.3},
        "inputs": {"dataset": vm_raw_dataset_preprocessed},
    },
}

# Global test config
tests_suite = vm.run_documentation_tests(
    inputs={
        "dataset": vm_raw_dataset_preprocessed,
    },
    config=test_config,
    section=["data_preparation"],
)

Test suite complete!

26/26 (100.0%)

Test Suite Results: Binary Classification V2

---

Check out the updated documentation on ValidMind.

Template for binary classification models.

▶ Data Preparation

Data Preparation

▶ Test Result: Dataset Description (validmind.data_validation.DatasetDescription)

Dataset Description

The DatasetDescription test provides a comprehensive statistical summary of each column in the model’s dataset, detailing data types, counts, missingness, and the number of unique values per feature. The results table enumerates all columns, their inferred types, and key statistics, enabling a clear assessment of dataset structure and completeness. All columns are fully populated, with no missing values, and the distribution of unique values varies substantially across features, reflecting a mix of categorical and continuous variables.

Key insights:

• No missing values across all columns: All 10 columns report 0 missing entries, resulting in 0.0% missingness for every feature.
• High cardinality in key numeric features: EstimatedSalary contains 3,232 unique values (100% distinct), and Balance has 2,209 unique values (68.4% distinct), indicating continuous or near-continuous distributions.
• Low cardinality in categorical features: Geography, Gender, HasCrCard, IsActiveMember, and Exited each have 2 or 3 unique values, consistent with categorical or binary encoding.
• Moderate cardinality in other numeric features: CreditScore and Tenure have 438 and 11 unique values respectively, while NumOfProducts has 4 unique values, reflecting discrete numeric distributions.

The dataset is complete with no missing data and exhibits a clear separation between high-cardinality numeric features and low-cardinality categorical variables. The presence of both continuous and categorical data types is evident, supporting a range of modeling approaches. No unsupported data types or structural anomalies are present in the dataset summary.

Tables

Dataset Description

Name	Type	Count	Missing	Missing %	Distinct	Distinct %
CreditScore	Numeric	3232.0	0	0.0	438	0.1355
Geography	Categorical	3232.0	0	0.0	3	0.0009
Gender	Categorical	3232.0	0	0.0	2	0.0006
Tenure	Numeric	3232.0	0	0.0	11	0.0034
Balance	Numeric	3232.0	0	0.0	2209	0.6835
NumOfProducts	Numeric	3232.0	0	0.0	4	0.0012
HasCrCard	Categorical	3232.0	0	0.0	2	0.0006
IsActiveMember	Categorical	3232.0	0	0.0	2	0.0006
EstimatedSalary	Numeric	3232.0	0	0.0	3232	1.0000
Exited	Categorical	3232.0	0	0.0	2	0.0006

▶ Test Result: Class Imbalance (validmind.data_validation.ClassImbalance)

✅ Class Imbalance

The Class Imbalance test evaluates the distribution of target classes in the dataset to identify potential imbalances that could impact model performance. The results table presents the percentage representation of each class in the "Exited" target variable, alongside a pass/fail assessment based on a minimum threshold of 30%. The accompanying bar plot visually displays the proportion of each class, facilitating interpretation of class distribution.

Key insights:

• Equal class representation: Both classes (Exited = 0 and Exited = 1) constitute exactly 50% of the dataset, indicating a perfectly balanced class distribution.
• All classes meet threshold: Each class exceeds the 30% minimum percentage threshold, resulting in a "Pass" outcome for both classes.
• No evidence of class imbalance: The visual plot confirms the tabular findings, with both bars reaching the same height, further supporting the absence of imbalance.

The results demonstrate that the dataset exhibits a balanced distribution across the target classes, with each class equally represented and surpassing the specified minimum threshold. No class imbalance is detected, indicating that the dataset is well-suited for training classification models without risk of bias due to disproportionate class frequencies.

Parameters:

{
  "min_percent_threshold": 30
}
            

Tables

Exited Class Imbalance

Exited	Percentage of Rows (%)	Pass/Fail
0	50.00%	Pass
1	50.00%	Pass

Figures

▶ Test Result: Duplicates (validmind.data_validation.Duplicates)

✅ Duplicates

The Duplicates test evaluates the presence of duplicate rows within the dataset to ensure data quality and reduce the risk of model overfitting due to redundant information. The results table provides the absolute number and percentage of duplicate rows detected in the dataset. In this instance, the table indicates both the number and percentage of duplicate rows, allowing for a clear assessment of data redundancy.

Key insights:

• No duplicate rows detected: The dataset contains 0 duplicate rows, as indicated by the "Number of Duplicates" value.
• Zero percent duplication: The "Percentage of Rows (%)" is 0.0%, confirming the absence of duplicate entries in the dataset.

The results demonstrate that the dataset is free from duplicate rows, indicating a high level of data quality with respect to redundancy. This reduces the risk of model bias or overfitting due to repeated entries and supports the reliability of subsequent modeling processes.

Tables

Duplicate Rows Results for Dataset

Number of Duplicates	Percentage of Rows (%)
0	0.0

▶ Test Result: High Cardinality (validmind.data_validation.HighCardinality)

✅ High Cardinality

The High Cardinality test evaluates the number of unique values in categorical columns to identify potential risks of overfitting and data noise. The results table presents the number and percentage of distinct values for each categorical column, along with a pass/fail status based on a predefined threshold. Both the "Geography" and "Gender" columns are assessed, with their respective distinct value counts and percentages reported.

Key insights:

• All categorical columns pass cardinality threshold: Both "Geography" (3 distinct values, 0.0928%) and "Gender" (2 distinct values, 0.0619%) are below the high cardinality threshold and receive a "Pass" status.
• Low percentage of distinct values observed: The percentage of distinct values for both columns remains well below 0.1%, indicating limited diversity within these categorical features.

The results indicate that the evaluated categorical columns exhibit low cardinality, with all tested features passing the high cardinality threshold. This suggests a reduced risk of overfitting or noise due to excessive unique values in the categorical data.

Tables

Column	Number of Distinct Values	Percentage of Distinct Values (%)	Pass/Fail
Geography	3	0.0928	Pass
Gender	2	0.0619	Pass

▶ Test Result: Missing Values (validmind.data_validation.MissingValues)

✅ Missing Values

The Missing Values test evaluates dataset quality by measuring the proportion of missing values in each feature and comparing it to a predefined threshold. The results table presents, for each column, the number and percentage of missing values, along with a Pass/Fail status based on the threshold. All features, including CreditScore, Geography, Gender, Tenure, Balance, NumOfProducts, HasCrCard, IsActiveMember, EstimatedSalary, and Exited, are shown with zero missing values and a Pass status.

Key insights:

• No missing values detected: All features report zero missing values, with both the count and percentage of missing values at 0.0% for every column.
• Universal pass across features: Every feature meets the missing value threshold, resulting in a Pass status for all columns.

The dataset demonstrates complete data integrity with respect to missing values, as all features are fully populated and pass the established threshold. This indicates a high level of data quality for subsequent modeling or analysis steps.

Tables

Column	Number of Missing Values	Percentage of Missing Values (%)	Pass/Fail
CreditScore	0	0.0	Pass
Geography	0	0.0	Pass
Gender	0	0.0	Pass
Tenure	0	0.0	Pass
Balance	0	0.0	Pass
NumOfProducts	0	0.0	Pass
HasCrCard	0	0.0	Pass
IsActiveMember	0	0.0	Pass
EstimatedSalary	0	0.0	Pass
Exited	0	0.0	Pass

▶ Test Result: Skewness (validmind.data_validation.Skewness)

❌ Skewness

The Skewness test evaluates the asymmetry of numerical data distributions to identify deviations from normality that may impact model performance. The results table presents skewness values for each numeric column, with a threshold of 1 used to determine pass or fail status. Most columns exhibit skewness values well within the threshold, while one column exceeds the limit and is flagged accordingly. The pass/fail status is provided for each column to facilitate targeted review.

Key insights:

• Majority of columns within skewness threshold: Seven out of eight numeric columns have skewness values between -0.84 and 0.13, all passing the defined threshold.
• Single column exceeds skewness threshold: NumOfProducts registers a skewness of 1.2392, exceeding the threshold and resulting in a fail status.
• Minimal skewness in core financial variables: CreditScore, Balance, and EstimatedSalary display skewness values close to zero, indicating near-symmetric distributions.
• Binary and categorical indicators show low skewness: HasCrCard, IsActiveMember, and Exited all exhibit skewness values between -0.84 and 0.13, remaining within acceptable limits.

The results indicate that the dataset is predominantly composed of numeric columns with low skewness, supporting distributional symmetry in most features. The exception is NumOfProducts, which displays substantial positive skewness and does not meet the test threshold. Overall, the data demonstrates strong distributional quality, with isolated skewness present in a single feature.

Tables

Skewness Results for Dataset

Column	Skewness	Pass/Fail
CreditScore	-0.1171	Pass
Tenure	0.0324	Pass
Balance	-0.2883	Pass
NumOfProducts	1.2392	Fail
HasCrCard	-0.8376	Pass
IsActiveMember	0.1290	Pass
EstimatedSalary	0.0106	Pass
Exited	0.0000	Pass

▶ Test Result: Unique Rows (validmind.data_validation.UniqueRows)

❌ Unique Rows

The UniqueRows test evaluates the diversity of the dataset by measuring the proportion of unique values in each column and comparing it to a prescribed minimum threshold. The results table presents, for each column, the number and percentage of unique values, along with a pass/fail outcome based on whether the uniqueness threshold was met. Columns such as EstimatedSalary and Balance exhibit high percentages of unique values and pass the test, while categorical and low-cardinality columns such as Geography, Gender, and HasCrCard show low uniqueness percentages and fail.

Key insights:

• High uniqueness in continuous variables: EstimatedSalary (100.0%) and Balance (68.35%) display high proportions of unique values, both passing the uniqueness threshold.
• Low uniqueness in categorical variables: Columns such as Geography (0.09%), Gender (0.06%), HasCrCard (0.06%), IsActiveMember (0.06%), and Exited (0.06%) have very low percentages of unique values and fail the test.
• Mixed results for numeric features: CreditScore (13.55%) passes the threshold, while Tenure (0.34%) and NumOfProducts (0.12%) do not, indicating variability in uniqueness among numeric columns.
• Majority of columns fail uniqueness threshold: Only 3 out of 10 columns pass the test, with the remaining 7 failing due to low unique value percentages.

The results indicate that while certain continuous variables in the dataset exhibit high diversity, the majority of columns—particularly those representing categorical or low-cardinality features—do not meet the prescribed uniqueness threshold. This pattern reflects the inherent structure of the data, with continuous variables contributing most to overall diversity and categorical variables showing limited uniqueness. The overall dataset contains a mix of high- and low-diversity columns, with the majority failing the uniqueness criterion as defined by the test parameters.

Tables

Column	Number of Unique Values	Percentage of Unique Values (%)	Pass/Fail
CreditScore	438	13.5520	Pass
Geography	3	0.0928	Fail
Gender	2	0.0619	Fail
Tenure	11	0.3403	Fail
Balance	2209	68.3478	Pass
NumOfProducts	4	0.1238	Fail
HasCrCard	2	0.0619	Fail
IsActiveMember	2	0.0619	Fail
EstimatedSalary	3232	100.0000	Pass
Exited	2	0.0619	Fail

▶ Test Result: Too Many Zero Values (validmind.data_validation.TooManyZeroValues)

❌ Too Many Zero Values

The TooManyZeroValues test identifies numerical columns with a proportion of zero values exceeding a defined threshold, set at 0.03% for this analysis. The results table summarizes the number and percentage of zero values for each numerical column, along with a pass/fail status based on the threshold. All four evaluated columns—Tenure, Balance, HasCrCard, and IsActiveMember—exceed the threshold and are marked as failing the test, with zero value percentages ranging from approximately 4% to over 53%.

Key insights:

• All evaluated columns exceed zero value threshold: Each of the four numerical columns analyzed fails the test, with zero value proportions significantly above the 0.03% threshold.
• High concentration of zeros in IsActiveMember: The IsActiveMember column contains 53.22% zero values, representing the highest proportion among all columns tested.
• Substantial zero values in Balance and HasCrCard: Balance and HasCrCard columns show 31.68% and 30.69% zero values, respectively, indicating a high degree of sparsity.
• Tenure column also affected: The Tenure column, while lower than the others, still registers 3.99% zero values, exceeding the threshold and failing the test.

The results indicate that all tested numerical columns contain zero values at rates far above the defined threshold, with IsActiveMember, Balance, and HasCrCard exhibiting particularly high concentrations. This pattern highlights a notable degree of sparsity or lack of variation in these features, as reflected by their failure status in the test. The findings provide clear evidence of widespread zero value prevalence across key numerical variables in the dataset.

Tables

Variable	Row Count	Number of Zero Values	Percentage of Zero Values (%)	Pass/Fail
Tenure	3232	129	3.9913	Fail
Balance	3232	1024	31.6832	Fail
HasCrCard	3232	992	30.6931	Fail
IsActiveMember	3232	1720	53.2178	Fail

▶ Test Result: IQR Outliers Table (validmind.data_validation.IQROutliersTable)

IQR Outliers Table

The Interquartile Range Outliers Table (IQROutliersTable) test identifies and summarizes outliers in numerical features using the IQR method, providing counts and value distributions for detected outliers. The results table presents, for each variable, the total number of outliers, the mean value of the variable, and summary statistics (minimum, quartiles, and maximum) for the outlier values. This enables a detailed assessment of the extent and characteristics of outliers present in the dataset.

Key insights:

• Concentration of outliers in NumOfProducts: The NumOfProducts variable exhibits 44 outliers, all with a value of 4, which is notably higher than the mean value of 1.5071 for this variable.
• Lower-end outliers in CreditScore: CreditScore has 11 outliers, with values ranging from 350 to 376, all below the mean value of 650.5442, indicating that outliers are concentrated at the lower end of the distribution.
• Homogeneity of outlier values in NumOfProducts: All outlier values for NumOfProducts are identical (value = 4), as reflected in the minimum, quartiles, and maximum statistics.
• Tight clustering of CreditScore outliers: The outlier values for CreditScore are closely grouped, with the 25th, 50th, and 75th percentiles spanning from 350 to 370.

The results indicate that outliers are present in both CreditScore and NumOfProducts, with a higher frequency observed in NumOfProducts. Outliers in NumOfProducts are uniform and occur at the upper boundary of observed values, while CreditScore outliers are concentrated at the lower end of the distribution and display a narrow value range. These patterns provide a clear characterization of outlier behavior within the tested features.

Tables

Summary of Outliers Detected by IQR Method

Variable	Total Count of Outliers	Mean Value of Variable	Minimum Outlier Value	Outlier Value at 25th Percentile	Outlier Value at 50th Percentile	Outlier Value at 75th Percentile	Maximum Outlier Value
CreditScore	11	650.5442	350	350.0	359.0	370.0	376
NumOfProducts	44	1.5071	4	4.0	4.0	4.0	4

▶ Test Result: IQR Outliers Bar Plot (validmind.data_validation.IQROutliersBarPlot)

IQR Outliers Bar Plot

The InterQuartile Range Outliers Bar Plot (IQROutliersBarPlot) test evaluates the distribution of outliers across percentiles for each numeric feature using the IQR method. The resulting bar plots display the count of outliers within four percentile bands (0-25, 25-50, 50-75, 75-100) for each feature, providing a visual summary of where outliers are concentrated. The test results for the features "CreditScore" and "NumOfProducts" are presented as separate bar plots, each illustrating the distribution of outlier counts across the defined percentile ranges.

Key insights:

• Outliers in CreditScore concentrated in mid and upper percentiles: For CreditScore, outliers are absent in the lowest quartile (0-25) and most prevalent in the 25-50 percentile range (5 outliers), with moderate counts in the 50-75 and 75-100 percentiles (3 outliers each).
• NumOfProducts outliers isolated to uppermost percentile: For NumOfProducts, outliers are exclusively present in the 75-100 percentile range (over 40 outliers), with no outliers detected in the lower three quartiles (0-75).

The results indicate that outlier presence varies substantially by feature and percentile range. CreditScore exhibits a moderate and distributed pattern of outliers across the middle and upper percentiles, while NumOfProducts shows a pronounced concentration of outliers solely in the highest percentile band. This distribution highlights feature-specific patterns of extreme values, with potential implications for model sensitivity to upper-tail data in NumOfProducts and a broader spread of moderate outliers in CreditScore.

Figures

▶ Test Result: Descriptive Statistics (validmind.data_validation.DescriptiveStatistics)

Descriptive Statistics

The Descriptive Statistics test evaluates the distributional characteristics and diversity of both numerical and categorical variables in the dataset. The results present summary statistics for seven numerical variables, including measures of central tendency, dispersion, and range, as well as frequency-based summaries for two categorical variables. The numerical table details metrics such as mean, standard deviation, and percentiles, while the categorical table reports unique value counts and the dominance of the most frequent category. These results provide a comprehensive overview of the dataset’s structure and highlight key aspects of variable distributions.

Key insights:

• Wide range and skewness in Balance: The Balance variable exhibits a minimum of 0.0, a median of 104,113.0, and a maximum of 250,898.0, with a mean (82,570.0) notably below the median, indicating right-skewness and a substantial proportion of zero or low balances.
• CreditScore distribution is broad and symmetric: CreditScore spans from 350.0 to 850.0, with a mean (650.5) and median (653.0) closely aligned, and a standard deviation of 98.5, suggesting a wide but relatively symmetric distribution.
• Categorical dominance in Geography and Gender: The most frequent Geography (France) accounts for 46.41% of records, while the most frequent Gender (Male) represents 51.61%, indicating moderate category concentration but not overwhelming dominance.
• Binary variables show balanced representation: HasCrCard and IsActiveMember display means of 0.693 and 0.468, respectively, with medians at 1.0 and 0.0, reflecting a relatively balanced split between binary states.

The dataset demonstrates a mix of variable distributions, with some numerical features such as Balance showing pronounced skewness and a high proportion of low or zero values, while others like CreditScore and EstimatedSalary are more symmetrically distributed. Categorical variables exhibit moderate concentration in their top categories but retain diversity. Overall, the data structure is characterized by broad value ranges and balanced representation across key binary and categorical fields.

Tables

Numerical Variables

Name	Count	Mean	Std	Min	25%	50%	75%	90%	95%	Max
CreditScore	3232.0	650.5442	98.4779	350.0	583.0	653.0	718.0	781.0	813.0	850.0
Tenure	3232.0	5.0300	2.9107	0.0	3.0	5.0	8.0	9.0	10.0	10.0
Balance	3232.0	82569.9998	61528.5819	0.0	0.0	104113.0	129652.0	151925.0	164850.0	250898.0
NumOfProducts	3232.0	1.5071	0.6708	1.0	1.0	1.0	2.0	2.0	3.0	4.0
HasCrCard	3232.0	0.6931	0.4613	0.0	0.0	1.0	1.0	1.0	1.0	1.0
IsActiveMember	3232.0	0.4678	0.4990	0.0	0.0	0.0	1.0	1.0	1.0	1.0
EstimatedSalary	3232.0	99584.8530	57986.6823	12.0	49703.0	99107.0	149540.0	179773.0	189891.0	199953.0

Categorical Variables

Name	Count	Number of Unique Values	Top Value	Top Value Frequency	Top Value Frequency %
Geography	3232.0	3.0	France	1500.0	46.41
Gender	3232.0	2.0	Male	1668.0	51.61

▶ Test Result: Pearson Correlation Matrix (validmind.data_validation.PearsonCorrelationMatrix)

Pearson Correlation Matrix

The Pearson Correlation Matrix test evaluates the linear relationships between all pairs of numerical variables in the dataset, providing a visual summary of correlation coefficients ranging from -1 to 1. The resulting heatmap displays the magnitude and direction of these relationships, with higher absolute values indicating stronger linear associations. In this result, the matrix shows the pairwise correlations among variables such as CreditScore, Tenure, Balance, NumOfProducts, HasCrCard, IsActiveMember, EstimatedSalary, and Exited, with color intensity reflecting the strength and direction of each relationship.

Key insights:

• No high correlations detected: All pairwise correlation coefficients fall well below the 0.7 threshold, with the highest absolute value observed at 0.20 (between IsActiveMember and Exited).
• Weak linear relationships dominate: Most variable pairs exhibit correlation coefficients close to zero, indicating minimal linear dependency across the dataset.
• No evidence of multicollinearity: The absence of strong correlations suggests that the variables are largely independent, reducing the risk of redundancy or instability in downstream modeling.

The correlation structure indicates that the dataset's numerical variables are largely independent, with no evidence of strong linear relationships or multicollinearity. This supports the suitability of the variables for inclusion in modeling without concerns of redundancy or excessive linear dependency.

Figures

▶ Test Result: High Pearson Correlation (validmind.data_validation.HighPearsonCorrelation)

✅ High Pearson Correlation

The High Pearson Correlation test evaluates the linear relationships between feature pairs to identify potential redundancy or multicollinearity within the dataset. The results table presents the top ten absolute Pearson correlation coefficients, each paired with a Pass/Fail status based on a threshold of 0.3. All reported feature pairs have coefficients below the threshold, and each is marked as Pass, indicating no high linear correlations among the top pairs.

Key insights:

• No feature pairs exceed correlation threshold: All reported absolute correlation coefficients are below the 0.3 threshold, with the highest magnitude observed at 0.1972.
• Weakest observed correlation is minimal: The lowest absolute coefficient among the top pairs is 0.0331, indicating very limited linear association.
• Consistent Pass status across all pairs: Every feature pair in the top ten list is marked as Pass, reflecting the absence of strong linear dependencies.

The test results indicate that the dataset does not exhibit high linear correlations among the top feature pairs, suggesting a low risk of feature redundancy or multicollinearity based on the Pearson correlation metric. The observed relationships are weak, supporting the interpretability and stability of subsequent modeling efforts.

Parameters:

{
  "max_threshold": 0.3
}
            

Tables

Columns	Coefficient	Pass/Fail
(IsActiveMember, Exited)	-0.1972	Pass
(Balance, NumOfProducts)	-0.1854	Pass
(Balance, Exited)	0.1378	Pass
(CreditScore, Exited)	-0.0538	Pass
(NumOfProducts, Exited)	-0.0521	Pass
(NumOfProducts, IsActiveMember)	0.0511	Pass
(Tenure, IsActiveMember)	-0.0444	Pass
(CreditScore, IsActiveMember)	0.0404	Pass
(HasCrCard, IsActiveMember)	-0.0362	Pass
(Balance, EstimatedSalary)	0.0331	Pass

Run and log an individual test

Next, we'll use the previously initialized vm_balanced_raw_dataset (that still has a highly correlated Age column) as input to run an individual test, then log the result to the ValidMind Platform.

When running individual tests, you can use a custom result_id to tag the individual result with a unique identifier:

• This result_id can be appended to test_id with a : separator.
• The balanced_raw_dataset result identifier will correspond to the balanced_raw_dataset input, the dataset that still has the Age column.

result = vm.tests.run_test(
    test_id="validmind.data_validation.HighPearsonCorrelation:balanced_raw_dataset",
    params={"max_threshold": 0.3},
    inputs={"dataset": vm_balanced_raw_dataset},
)
result.log()

❌ High Pearson Correlation Balanced Raw Dataset

The High Pearson Correlation test identifies pairs of features in the dataset that exhibit strong linear relationships, with the aim of detecting potential feature redundancy or multicollinearity. The results table lists the top ten feature pairs ranked by the absolute value of their Pearson correlation coefficients, along with their corresponding Pass or Fail status based on a threshold of 0.3. Only one feature pair exceeds the threshold, while the remaining pairs display lower correlation values and pass the test criteria.

Key insights:

• One feature pair exceeds correlation threshold: The pair (Age, Exited) shows a correlation coefficient of 0.349, surpassing the 0.3 threshold and resulting in a Fail status.
• All other feature pairs below threshold: The remaining nine feature pairs have absolute correlation coefficients ranging from 0.0404 to 0.1972, all classified as Pass.
• Predominantly weak linear relationships: Most feature pairs exhibit low to moderate correlation, indicating limited linear association among the majority of features.

The test results indicate that the dataset contains minimal evidence of strong linear relationships between most feature pairs, with only the (Age, Exited) pair exceeding the defined correlation threshold. This suggests a generally low risk of feature redundancy or multicollinearity, aside from the identified exception. The overall correlation structure supports the interpretability and stability of the feature set.

Parameters:

{
  "max_threshold": 0.3
}
            

Tables

Columns	Coefficient	Pass/Fail
(Age, Exited)	0.3490	Fail
(IsActiveMember, Exited)	-0.1972	Pass
(Balance, NumOfProducts)	-0.1854	Pass
(Balance, Exited)	0.1378	Pass
(CreditScore, Exited)	-0.0538	Pass
(NumOfProducts, Exited)	-0.0521	Pass
(NumOfProducts, IsActiveMember)	0.0511	Pass
(Age, Tenure)	-0.0453	Pass
(Tenure, IsActiveMember)	-0.0444	Pass
(CreditScore, IsActiveMember)	0.0404	Pass

2026-01-30 23:13:42,696 - INFO(validmind.vm_models.result.result): Test driven block with result_id validmind.data_validation.HighPearsonCorrelation:balanced_raw_dataset does not exist in model's document

Note the output returned indicating that a test-driven block doesn't currently exist in your model's documentation for this particular test ID.

That's expected, as when we run individual tests the results logged need to be manually added to your documentation within the ValidMind Platform.

Add individual test results to model documentation

With the test results logged, let's head to the model we connected to at the beginning of this notebook and insert our test results into the documentation (Need more help?):

1. From the Inventory in the ValidMind Platform, go to the model you connected to earlier.

2. In the left sidebar that appears for your model, click Documentation under Documents.

3. Locate the Data Preparation section and click on 2.3. Correlations and Interactions to expand that section.

4. Hover under the Pearson Correlation Matrix content block until a horizontal dashed line with a + button appears, indicating that you can insert a new block.

   
   
   

5. Click + and then select Test-Driven Block under FROM LIBRARY:

   • Click on VM Library under TEST-DRIVEN in the left sidebar.
   • In the search bar, type in HighPearsonCorrelation.
   • Select HighPearsonCorrelation:balanced_raw_dataset as the test.

   A preview of the test gets shown:

   
   
   

6. Finally, click Insert 1 Test Result to Document to add the test result to the documentation.

   Confirm that the individual results for the high correlation test has been correctly inserted into section 2.3. Correlations and Interactions of the documentation.

7. Finalize the documentation by editing the test result's description block to explain the changes you made to the raw data and the reasons behind them as shown in the screenshot below:

   

Model testing

So far, we've focused on the data assessment and pre-processing that usually occurs prior to any models being built. Now, let's instead assume we have already built a model and we want to incorporate some model results into our documentation.

Train simple logistic regression model

Using ValidMind tests, we'll train a simple logistic regression model on our dataset and evaluate its performance by using the LogisticRegression class from the sklearn.linear_model.

To start, let's grab the first few rows from the balanced_raw_no_age_df dataset with the highly correlated features removed we initialized earlier:

balanced_raw_no_age_df.head()

	CreditScore	Geography	Gender	Tenure	Balance	NumOfProducts	HasCrCard	IsActiveMember	EstimatedSalary	Exited
2240	714	Spain	Female	10	103121.33	2	1	1	49672.01	0
311	752	Germany	Male	3	183102.29	1	1	1	71557.12	0
1034	700	France	Female	2	58781.76	1	1	0	16874.92	0
323	538	Spain	Female	9	141434.04	1	0	0	173779.25	1
3143	807	France	Female	9	167664.83	1	0	0	125440.11	1

Before training the model, we need to encode the categorical features in the dataset:

• Use the OneHotEncoder class from the sklearn.preprocessing module to encode the categorical features.
• The categorical features in the dataset are Geography and Gender.

balanced_raw_no_age_df = pd.get_dummies(
    balanced_raw_no_age_df, columns=["Geography", "Gender"], drop_first=True
)
balanced_raw_no_age_df.head()

	CreditScore	Tenure	Balance	NumOfProducts	HasCrCard	IsActiveMember	EstimatedSalary	Exited	Geography_Germany	Geography_Spain	Gender_Male
2240	714	10	103121.33	2	1	1	49672.01	0	False	True	False
311	752	3	183102.29	1	1	1	71557.12	0	True	False	True
1034	700	2	58781.76	1	1	0	16874.92	0	False	False	False
323	538	9	141434.04	1	0	0	173779.25	1	False	True	False
3143	807	9	167664.83	1	0	0	125440.11	1	False	False	False

We'll split our preprocessed dataset into training and testing, to help assess how well the model generalizes to unseen data:

• We start by dividing our balanced_raw_no_age_df dataset into training and test subsets using train_test_split, with 80% of the data allocated to training (train_df) and 20% to testing (test_df).
• From each subset, we separate the features (all columns except "Exited") into X_train and X_test, and the target column ("Exited") into y_train and y_test.

from sklearn.model_selection import train_test_split

train_df, test_df = train_test_split(balanced_raw_no_age_df, test_size=0.20)

X_train = train_df.drop("Exited", axis=1)
y_train = train_df["Exited"]
X_test = test_df.drop("Exited", axis=1)
y_test = test_df["Exited"]

Then using GridSearchCV, we'll find the best-performing hyperparameters or settings and save them:

from sklearn.linear_model import LogisticRegression

# Logistic Regression grid params
log_reg_params = {
    "penalty": ["l1", "l2"],
    "C": [0.001, 0.01, 0.1, 1, 10, 100, 1000],
    "solver": ["liblinear"],
}

# Grid search for Logistic Regression
from sklearn.model_selection import GridSearchCV

grid_log_reg = GridSearchCV(LogisticRegression(), log_reg_params)
grid_log_reg.fit(X_train, y_train)

# Logistic Regression best estimator
log_reg = grid_log_reg.best_estimator_

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1135: FutureWarning:

'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.

/opt/hostedtoolcache/Python/3.11.14/x64/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:1160: UserWarning:

Inconsistent values: penalty=l1 with l1_ratio=0.0. penalty is deprecated. Please use l1_ratio only.

Initialize model evaluation objects

The last step for evaluating the model's performance is to initialize the ValidMind Dataset and Model objects in preparation for assigning model predictions to each dataset.

# Initialize the datasets into their own dataset objects
vm_train_ds = vm.init_dataset(
    input_id="train_dataset_final",
    dataset=train_df,
    target_column="Exited",
)

vm_test_ds = vm.init_dataset(
    input_id="test_dataset_final",
    dataset=test_df,
    target_column="Exited",
)

You'll also need to initialize a ValidMind model object (vm_model) that can be passed to other functions for analysis and tests on the data for each of our three models.

You simply initialize this model object with vm.init_model():

# Register the model
vm_model = vm.init_model(log_reg, input_id="log_reg_model_v1")

Assign predictions

Once the model has been registered you can assign model predictions to the training and testing datasets.

• The assign_predictions() method from the Dataset object can link existing predictions to any number of models.
• This method links the model's class prediction values and probabilities to our vm_train_ds and vm_test_ds datasets.

If no prediction values are passed, the method will compute predictions automatically:

vm_train_ds.assign_predictions(model=vm_model)
vm_test_ds.assign_predictions(model=vm_model)

2026-01-30 23:13:44,095 - INFO(validmind.vm_models.dataset.utils): Running predict_proba()... This may take a while
2026-01-30 23:13:44,097 - INFO(validmind.vm_models.dataset.utils): Done running predict_proba()
2026-01-30 23:13:44,098 - INFO(validmind.vm_models.dataset.utils): Running predict()... This may take a while
2026-01-30 23:13:44,100 - INFO(validmind.vm_models.dataset.utils): Done running predict()
2026-01-30 23:13:44,102 - INFO(validmind.vm_models.dataset.utils): Running predict_proba()... This may take a while
2026-01-30 23:13:44,103 - INFO(validmind.vm_models.dataset.utils): Done running predict_proba()
2026-01-30 23:13:44,103 - INFO(validmind.vm_models.dataset.utils): Running predict()... This may take a while
2026-01-30 23:13:44,105 - INFO(validmind.vm_models.dataset.utils): Done running predict()

Run the model evaluation tests

In this next example, we'll focus on running the tests within the Model Development section of the model documentation. Only tests associated with this section will be executed, and the corresponding results will be updated in the model documentation.

• Note the additional config that is passed to run_documentation_tests() — this allows you to override inputs or params in certain tests.
• In our case, we want to explicitly use the vm_train_ds for the validmind.model_validation.sklearn.ClassifierPerformance:in_sample test, since it's supposed to run on the training dataset and not the test dataset.

test_config = {
    "validmind.model_validation.sklearn.ClassifierPerformance:in_sample": {
        "inputs": {
            "dataset": vm_train_ds,
            "model": vm_model,
        },
    }
}
results = vm.run_documentation_tests(
    section=["model_development"],
    inputs={
        "dataset": vm_test_ds,  # Any test that requires a single dataset will use vm_test_ds
        "model": vm_model,
        "datasets": (
            vm_train_ds,
            vm_test_ds,
        ),  # Any test that requires multiple datasets will use vm_train_ds and vm_test_ds
    },
    config=test_config,
)

Test suite complete!

34/34 (100.0%)

Test Suite Results: Binary Classification V2

---

Check out the updated documentation on ValidMind.

Template for binary classification models.

▶ Model Development

Model Development

▶ Test Result: Model Metadata (validmind.model_validation.ModelMetadata)

Model Metadata

The ModelMetadata test compares key metadata attributes across models, including modeling technique, framework, framework version, and programming language. The results are presented in a summary table, with each row corresponding to a model and columns detailing the respective metadata fields. In this test instance, the table contains a single model entry, providing a clear view of its documented metadata.

Key insights:

• Single model metadata captured: The summary table includes metadata for one model, with all required fields populated.
• Consistent framework and language specification: The model is implemented using the sklearn framework (version 1.8.0) and Python as the programming language.
• Explicit modeling technique identified: The modeling technique is specified as SKlearnModel, aligning with the framework and language metadata.

The results indicate that the model's metadata is fully documented and internally consistent across all reported fields. The presence of a single, well-specified entry provides a clear reference for model identification and traceability. No inconsistencies or missing metadata are observed in this test instance.

Tables

Modeling Technique	Modeling Framework	Framework Version	Programming Language
SKlearnModel	sklearn	1.8.0	Python

▶ Test Result: Dataset Split (validmind.data_validation.DatasetSplit)

Dataset Split

The DatasetSplit test evaluates the distribution of data among the training, testing, and validation datasets to assess the proportional allocation within the model. The results are presented in a table showing the absolute size and relative proportion of each dataset split. The table indicates the number of records assigned to the training and testing datasets, with proportions calculated relative to the total dataset size.

Key insights:

• Training dataset comprises majority of data: The training dataset contains 2,585 records, representing 79.98% of the total dataset.
• Testing dataset forms a smaller proportion: The testing dataset includes 647 records, accounting for 20.02% of the total.
• No validation dataset present: The results do not indicate the existence of a separate validation dataset in the current split.

The dataset split is characterized by a predominant allocation to the training set, with a smaller but substantial portion reserved for testing. The absence of a validation dataset is noted in the current configuration. The proportions reflect a conventional approach to dataset partitioning, with the majority of data used for model training and a defined subset for performance evaluation.

Tables

Dataset	Size	Proportion
train_dataset_final	2585	79.98%
test_dataset_final	647	20.02%
Total	3232	100%

▶ Test Result: Population Stability Index (validmind.model_validation.sklearn.PopulationStabilityIndex)

Population Stability Index

The Population Stability Index (PSI) test evaluates the stability of model prediction distributions by comparing the binned output ratios between the initial (train) and new (test) datasets. The results table presents the population ratios and PSI values for each bin, with a total PSI value summarizing the overall distributional shift. The accompanying bar and line plot visualizes the population ratios for both datasets across bins and the corresponding PSI contributions.

Key insights:

• Minimal overall population shift: The total PSI value is 0.0125, indicating a negligible shift in the distribution of model predictions between the initial and new datasets.
• Consistent bin-level ratios: Population ratios for each bin remain closely aligned between the initial and new datasets, with differences generally below 2 percentage points.
• No localized concentration of drift: PSI contributions per bin are uniformly low, with the highest single-bin PSI at 0.0043, and no bin exhibiting a disproportionate shift.

The results indicate strong stability in the model’s prediction distribution across the evaluated datasets. Both the aggregate and bin-level PSI values remain well below commonly used thresholds for concern, reflecting a consistent population profile and absence of material drift in model outputs.

Tables

Population Stability Index for train_dataset_final and test_dataset_final Datasets

Bin	Count Initial	Percent Initial (%)	Count New	Percent New (%)	PSI
0	159	6.1509	30	4.6368	0.0043
1	267	10.3288	57	8.8099	0.0024
2	275	10.6383	66	10.2009	0.0002
3	363	14.0426	101	15.6105	0.0017
4	382	14.7776	95	14.6832	0.0000
5	299	11.5667	80	12.3648	0.0005
6	315	12.1857	85	13.1376	0.0007
7	231	8.9362	56	8.6553	0.0001
8	124	4.7969	38	5.8733	0.0022
9	170	6.5764	39	6.0278	0.0005
Total	2585	100.0000	647	100.0000	0.0125

Figures

▶ Test Result: Confusion Matrix (validmind.model_validation.sklearn.ConfusionMatrix)

Confusion Matrix

The Confusion Matrix test evaluates the classification model’s predictive performance by quantifying the counts of true positives, true negatives, false positives, and false negatives. The resulting matrix provides a visual summary of the model’s ability to correctly and incorrectly classify each class. The matrix displays the distribution of predictions across the four possible outcomes, allowing for assessment of both correct classifications and types of misclassification.

Key insights:

• True Positives and True Negatives are the largest groups: The model correctly identified 209 true positives and 205 true negatives, indicating a substantial proportion of accurate predictions for both classes.
• False Positives exceed False Negatives: There are 126 false positives compared to 107 false negatives, showing a higher rate of incorrect positive predictions than missed positive cases.
• Misclassification is present in both classes: Both false positive and false negative counts are material, with misclassifications distributed across both classes rather than concentrated in one.

The confusion matrix reveals that the model achieves a balanced number of correct predictions for both positive and negative classes, with true positives and true negatives forming the majority of outcomes. However, the presence of notable false positive and false negative counts indicates that misclassification risk is present for both classes, with a slightly higher tendency toward false positive errors. The results provide a clear basis for further analysis of model performance and error patterns.

Figures

▶ Test Result: Classifier Performance In Sample (validmind.model_validation.sklearn.ClassifierPerformance:in_sample)

Classifier Performance In Sample

The Classifier Performance test evaluates the effectiveness of the classification model by reporting key metrics including precision, recall, F1-score, accuracy, and ROC AUC. The results are presented for each class, as well as macro and weighted averages, providing a comprehensive view of model performance across all classes. The reported values allow for assessment of both overall accuracy and the balance between precision and recall, with ROC AUC offering additional insight into the model's ability to distinguish between classes.

Key insights:

• Balanced class performance: Precision, recall, and F1-scores are similar across both classes, with values ranging from 0.6362 to 0.6669, indicating no substantial performance disparity between classes.
• Consistent average metrics: Macro and weighted averages for precision, recall, and F1-score are all approximately 0.6515, reflecting uniform model behavior across the dataset.
• Moderate overall accuracy: The model achieves an accuracy of 0.6515, indicating that approximately 65% of predictions are correct.
• ROC AUC indicates moderate separability: The ROC AUC score of 0.6996 suggests the model has moderate ability to distinguish between the two classes.

The results indicate that the model demonstrates consistent and balanced performance across both classes, with moderate accuracy and separability as reflected in the ROC AUC. The similarity between macro and weighted averages further supports the absence of class imbalance effects on performance metrics. Overall, the model exhibits stable but moderate classification capability on the evaluated dataset.

Tables

Precision, Recall, and F1

Class	Precision	Recall	F1
0	0.6444	0.6669	0.6554
1	0.6590	0.6362	0.6474
Weighted Average	0.6517	0.6515	0.6514
Macro Average	0.6517	0.6515	0.6514

Accuracy and ROC AUC

Metric	Value
Accuracy	0.6515
ROC AUC	0.6996

▶ Test Result: Classifier Performance Out Of Sample (validmind.model_validation.sklearn.ClassifierPerformance:out_of_sample)

Classifier Performance Out Of Sample

The Classifier Performance test evaluates the predictive effectiveness of the classification model by reporting precision, recall, F1-Score, accuracy, and ROC AUC metrics. The results are presented for each class, as well as macro and weighted averages, providing a comprehensive view of model performance across all classes. The accuracy and ROC AUC scores are also reported to summarize overall classification quality and the model's ability to distinguish between classes.

Key insights:

• Balanced class-wise performance: Precision, recall, and F1-Score are similar across both classes, with values ranging from 0.6193 to 0.6614, indicating consistent model behavior for each class.
• Moderate overall accuracy and F1-Score: The model achieves an accuracy of 0.6399 and a weighted average F1-Score of 0.6398, reflecting moderate predictive performance.
• ROC AUC above random baseline: The ROC AUC score is 0.6746, indicating the model's ability to discriminate between classes is above the random baseline of 0.5 but does not approach high discrimination thresholds.

The results indicate that the model demonstrates moderate and balanced classification performance across both classes, with no substantial disparity in precision, recall, or F1-Score. The ROC AUC and accuracy values suggest the model provides some discriminatory power, though performance remains in a moderate range. No evidence of class imbalance or extreme metric divergence is observed in the reported results.

Tables

Precision, Recall, and F1

Class	Precision	Recall	F1
0	0.6571	0.6193	0.6376
1	0.6239	0.6614	0.6421
Weighted Average	0.6409	0.6399	0.6398
Macro Average	0.6405	0.6404	0.6399

Accuracy and ROC AUC

Metric	Value
Accuracy	0.6399
ROC AUC	0.6746

▶ Test Result: Precision Recall Curve (validmind.model_validation.sklearn.PrecisionRecallCurve)

Precision Recall Curve

The Precision Recall Curve test evaluates the trade-off between precision and recall for binary classification models by plotting precision against recall at various threshold levels. The resulting curve provides a visual summary of the model’s ability to balance minimizing false positives (precision) and capturing true positives (recall) across the full range of decision thresholds. The plot displays precision values on the y-axis and recall values on the x-axis, with the curve shape indicating the relationship between these two metrics as the threshold varies.

Key insights:

• Precision remains above 0.6 for most recall values: The curve shows that precision consistently stays above 0.6 across a broad range of recall values, indicating stable performance in minimizing false positives.
• Peak precision observed at low recall: The highest precision values, approaching 0.8, are observed at low recall levels, reflecting strong accuracy when the model is highly selective.
• Gradual decline in precision as recall increases: As recall increases beyond 0.4, precision gradually decreases, reaching values near 0.5 at the highest recall levels, which is characteristic of the trade-off between capturing more positives and maintaining accuracy.

The Precision-Recall Curve demonstrates that the model maintains a favorable balance between precision and recall across most threshold settings, with precision remaining relatively high except at the extreme upper end of recall. The observed curve shape indicates that the model is effective at minimizing false positives while still capturing a substantial proportion of true positives, with performance gradually tapering as recall increases.

Figures

▶ Test Result: ROC Curve (validmind.model_validation.sklearn.ROCCurve)

ROC Curve

The ROC Curve test evaluates the binary classification performance of the model by plotting the trade-off between the true positive rate and false positive rate across all possible thresholds, and by calculating the Area Under the Curve (AUC) as a summary metric. The resulting plot displays the ROC curve for the model log_reg_model_v1 on the test_dataset_final, with the AUC value indicated in the legend. The plot also includes a reference line representing random classification performance (AUC = 0.5), providing a visual benchmark for model discrimination.

Key insights:

• AUC indicates moderate discrimination: The model achieves an AUC of 0.67, reflecting moderate ability to distinguish between the two classes on the test dataset.
• ROC curve consistently above random: The ROC curve remains above the diagonal line representing random performance, indicating the model provides meaningful separation between positive and negative classes.
• No evidence of near-random performance: The curve does not approach the random baseline, and the AUC is substantially above 0.5, suggesting the model is not at high risk of non-discriminative behavior.

The ROC analysis demonstrates that log_reg_model_v1 exhibits moderate discriminative power on the test dataset, with an AUC of 0.67 indicating performance above random classification. The ROC curve consistently outperforms the random baseline across all thresholds, supporting the model's ability to differentiate between classes. No signs of high-risk or non-discriminative behavior are observed in this evaluation.

Figures

▶ Test Result: Training Test Degradation (validmind.model_validation.sklearn.TrainingTestDegradation)

✅ Training Test Degradation

The TrainingTestDegradation test evaluates the extent of model performance degradation between the training and test datasets across key classification metrics, including precision, recall, and F1-score, for each class. The results table presents the metric scores for both datasets, the calculated degradation percentage, and the corresponding pass/fail status based on a 10% threshold. All metrics for both classes are accompanied by their respective degradation values and test outcomes.

Key insights:

• All metrics pass degradation threshold: Every evaluated metric for both classes registers a degradation percentage below the 10% threshold, resulting in a "Pass" status across the board.
• Degradation values remain low: The highest observed degradation is 7.14% (Class 0 Recall), with most metrics showing degradation well below 5%, and some metrics exhibiting negative degradation, indicating improved test performance relative to training.
• Consistent performance across classes: Both Class 0 and Class 1 display similar patterns, with no metric showing excessive divergence between training and test scores.

The results indicate that the model maintains consistent performance between training and test datasets, with all evaluated metrics demonstrating degradation percentages comfortably within the predefined threshold. No evidence of overfitting or significant generalization issues is observed, and the model exhibits stable behavior across both classes and all measured metrics.

Tables

Class	Metric	train_dataset_final Score	test_dataset_final Score	Degradation (%)	Pass/Fail
0	Precision	0.6444	0.6571	-1.9695	Pass
0	Recall	0.6669	0.6193	7.1358	Pass
0	F1-Score	0.6554	0.6376	2.7177	Pass
1	Precision	0.6590	0.6239	5.3240	Pass
1	Recall	0.6362	0.6614	-3.9674	Pass
1	F1-Score	0.6474	0.6421	0.8139	Pass

▶ Test Result: Minimum Accuracy (validmind.model_validation.sklearn.MinimumAccuracy)

❌ Minimum Accuracy

The Minimum Accuracy test evaluates whether the model's prediction accuracy meets or exceeds a specified threshold, providing a direct measure of overall model correctness. The results table presents the model's observed accuracy score, the minimum threshold set for the test, and the corresponding pass/fail outcome. In this instance, the model's accuracy score is compared against a threshold of 0.7, with the test outcome indicating whether the model satisfies this minimum performance criterion.

Key insights:

• Accuracy below threshold: The model achieved an accuracy score of 0.6399, which is below the specified threshold of 0.7.
• Test outcome is Fail: The test result is marked as "Fail," indicating the model did not meet the minimum accuracy requirement.

The results indicate that the model's overall prediction accuracy does not reach the predefined minimum threshold, as evidenced by the observed score of 0.6399 against the 0.7 benchmark. This outcome highlights a shortfall in the model's ability to produce correct predictions at the required level, as reflected in the test's fail designation.

Tables

Score	Threshold	Pass/Fail
0.6399	0.7	Fail

▶ Test Result: Minimum F1 Score (validmind.model_validation.sklearn.MinimumF1Score)

✅ Minimum F1 Score

The MinimumF1Score test evaluates whether the model's F1 score on the validation set meets or exceeds a predefined minimum threshold, ensuring balanced performance between precision and recall. The results table presents the observed F1 score, the minimum threshold for acceptance, and the pass/fail outcome. The model achieved an F1 score of 0.6421 against a threshold of 0.5, with the test outcome marked as "Pass".

Key insights:

• F1 score exceeds minimum threshold: The model's F1 score of 0.6421 is above the required threshold of 0.5.
• Test outcome is positive: The result is classified as "Pass", indicating the model meets the minimum balanced performance criteria for precision and recall.

The results indicate that the model demonstrates balanced classification performance on the validation set, with the F1 score surpassing the predefined minimum requirement. This outcome reflects adequate alignment between precision and recall, as measured by the F1 metric, and confirms that the model satisfies the established acceptance criterion for this test.

Tables

Score	Threshold	Pass/Fail
0.6421	0.5	Pass

▶ Test Result: Minimum ROCAUC Score (validmind.model_validation.sklearn.MinimumROCAUCScore)

✅ Minimum ROCAUC Score

The Minimum ROC AUC Score test evaluates whether the model's multiclass ROC AUC score on the validation dataset meets or exceeds a predefined threshold, providing an aggregate measure of the model's ability to distinguish between classes. The results table presents the observed ROC AUC score, the minimum threshold for passing, and the test outcome. The reported ROC AUC score is 0.6746, with a threshold set at 0.5, and the test outcome is recorded as "Pass".

Key insights:

• ROC AUC score exceeds threshold: The model achieved a ROC AUC score of 0.6746, which is above the minimum required threshold of 0.5.
• Test outcome is positive: The test result is marked as "Pass", indicating the model's class discrimination performance meets the specified criterion.

The test results indicate that the model demonstrates adequate ability to distinguish between classes according to the multiclass ROC AUC metric, as the observed score surpasses the established threshold. The passing outcome confirms that, under the conditions of this test, the model's aggregate classification performance is satisfactory relative to the defined benchmark.

Tables

Score	Threshold	Pass/Fail
0.6746	0.5	Pass

▶ Test Result: Permutation Feature Importance (validmind.model_validation.sklearn.PermutationFeatureImportance)

Permutation Feature Importance

The Permutation Feature Importance (PFI) test evaluates the relative importance of each input feature by measuring the decrease in model performance when the feature's values are randomly permuted. The resulting bar plot displays the magnitude of importance for each feature, with higher values indicating greater influence on the model's predictive accuracy. The plot ranks features from most to least important, providing a clear visualization of the model's reliance on individual variables.

Key insights:

• Geography_Germany is the most influential feature: Geography_Germany exhibits the highest permutation importance, indicating substantial impact on model predictions.
• IsActiveMember and Gender_Male are highly significant: Both IsActiveMember and Gender_Male show strong importance scores, closely following Geography_Germany in their contribution to model performance.
• Balance is moderately important: Balance demonstrates a moderate level of importance, with a lower but still notable effect on predictive accuracy.
• Limited influence from remaining features: HasCrCard, CreditScore, NumOfProducts, Geography_Spain, EstimatedSalary, and Tenure all display low permutation importance, suggesting minimal impact on model output.

The permutation feature importance results indicate that model predictions are primarily driven by Geography_Germany, IsActiveMember, and Gender_Male, with Balance providing moderate additional influence. The remaining features contribute minimally to the model's predictive capability, highlighting a concentrated reliance on a small subset of input variables.

Figures

▶ Test Result: SHAP Global Importance (validmind.model_validation.sklearn.SHAPGlobalImportance)

SHAP Global Importance

The SHAPGlobalImportance test evaluates global feature importance by quantifying and visualizing the contribution of each input variable to the model’s predictions using SHAP values. The results are presented through a mean importance plot, which ranks features by their normalized average absolute SHAP values, and a summary plot, which displays the distribution and directionality of SHAP values for each feature across all samples. These visualizations provide insight into which features most strongly influence model output and the nature of their impact.

Key insights:

• Dominance of IsActiveMember and Geography_Germany: IsActiveMember and Geography_Germany exhibit the highest normalized SHAP values, indicating they are the most influential features in the model’s predictions.
• Gender_Male and Balance as secondary drivers: Gender_Male and Balance also show substantial importance, with normalized SHAP values significantly above the remaining features.
• Low importance for EstimatedSalary and HasCrCard: EstimatedSalary and HasCrCard have minimal normalized SHAP values, suggesting limited impact on model output.
• SHAP value distributions are concentrated: The summary plot shows that the majority of SHAP values for most features are centered near zero, with limited spread, indicating relatively consistent feature effects across samples.
• No evidence of extreme outliers or high scatter: The summary plot does not display excessive variability or outlier behavior in SHAP values for any feature.

The SHAPGlobalImportance results indicate that model predictions are primarily driven by a small subset of features, with IsActiveMember and Geography_Germany contributing the most to model output. Other features, such as Gender_Male and Balance, provide additional but lesser influence, while several variables have minimal effect. The distribution of SHAP values suggests stable and consistent feature contributions, with no indications of anomalous or erratic model behavior in the evaluated sample.

Figures

▶ Test Result: Weakspots Diagnosis (validmind.model_validation.sklearn.WeakspotsDiagnosis)

❌ Weakspots Diagnosis

The WeakspotsDiagnosis test evaluates model performance across segmented regions of the feature space to identify areas where key metrics fall below defined thresholds. The results are presented as bar charts and tables for each feature, showing accuracy, precision, recall, and F1 scores for both training and test datasets across feature bins. The visualizations highlight bins where performance metrics do not meet the specified thresholds, indicating potential weak spots in the model's predictive capability.

Key insights:

• Consistent sub-threshold performance across multiple features: For all evaluated features (CreditScore, Tenure, Balance, NumOfProducts, HasCrCard, EstimatedSalary, Geography_Germany, Geography_Spain, Gender_Male, IsActiveMember), no feature bin in the test dataset meets the accuracy, precision, recall, or F1 score thresholds set in the test (e.g., accuracy threshold of 0.75, F1 threshold of 0.7).
• Pronounced weak spots in specific feature bins: The lowest performance is observed in certain bins, such as the highest and lowest bins of CreditScore, Balance, and NumOfProducts, where F1 scores and accuracy are notably below threshold (e.g., F1 as low as 0.0 for some Balance and CreditScore bins).
• Performance disparities between training and test datasets: Several feature bins show a drop in test set performance relative to training, particularly in mid-range bins for features like Tenure and NumOfProducts, indicating potential overfitting or lack of generalization in those regions.
• Sparse data in extreme bins: Bins with very few records (e.g., Balance and CreditScore extremes) exhibit highly variable and often poor performance metrics, suggesting instability in model predictions for underrepresented regions of the feature space.
• No feature region achieves all metric thresholds: Across all features and bins, none of the regions in the test dataset simultaneously meet the defined thresholds for all four metrics, indicating the absence of high-performing subspaces under current threshold settings.

The results of the WeakspotsDiagnosis test reveal that the model exhibits widespread performance weaknesses across the feature space, with no feature bin in the test dataset achieving the established thresholds for accuracy, precision, recall, or F1 score. The most pronounced deficiencies are observed in bins with sparse data and at the extremes of feature distributions, where performance metrics are highly variable and often substantially below threshold. Disparities between training and test performance in several regions further indicate potential overfitting and limited generalization. These findings collectively highlight the need for careful consideration of model reliability, particularly in underrepresented or extreme regions of the input space.

Tables

Slice	Number of Records	Feature	Accuracy	Precision	Recall	F1	Dataset
(-250.898, 25089.809]	201	Balance	0.6318	0.5636	0.3827	0.4559	test_dataset_final
(25089.809, 50179.618]	3	Balance	0.6667	0.0000	0.0000	0.0000	test_dataset_final
(50179.618, 75269.427]	22	Balance	0.5000	0.5833	0.5385	0.5600	test_dataset_final
(75269.427, 100359.236]	88	Balance	0.6136	0.6222	0.6222	0.6222	test_dataset_final
(100359.236, 125449.045]	143	Balance	0.7273	0.6947	0.8684	0.7719	test_dataset_final
(125449.045, 150538.854]	125	Balance	0.6640	0.6860	0.7973	0.7375	test_dataset_final
(150538.854, 175628.663]	42	Balance	0.5476	0.3929	0.8462	0.5366	test_dataset_final
(175628.663, 200718.472]	18	Balance	0.3889	0.3636	0.5000	0.4211	test_dataset_final
(200718.472, 225808.281]	5	Balance	0.6000	1.0000	0.6000	0.7500	test_dataset_final
(225808.281, 250898.09]	0	Balance	0.0000	0.0000	0.0000	0.0000	test_dataset_final
(-250.898, 25089.809]	826	Balance	0.6550	0.5918	0.3614	0.4487	train_dataset_final
(25089.809, 50179.618]	23	Balance	0.5652	0.7143	0.3846	0.5000	train_dataset_final
(50179.618, 75269.427]	88	Balance	0.4773	0.5641	0.4314	0.4889	train_dataset_final
(75269.427, 100359.236]	285	Balance	0.6386	0.6078	0.6838	0.6436	train_dataset_final
(100359.236, 125449.045]	602	Balance	0.7243	0.7612	0.7945	0.7775	train_dataset_final
(125449.045, 150538.854]	480	Balance	0.6500	0.6581	0.7715	0.7103	train_dataset_final
(150538.854, 175628.663]	225	Balance	0.5733	0.5522	0.6727	0.6066	train_dataset_final
(175628.663, 200718.472]	42	Balance	0.5238	0.5769	0.6250	0.6000	train_dataset_final
(200718.472, 225808.281]	12	Balance	0.5000	1.0000	0.4545	0.6250	train_dataset_final
(225808.281, 250898.09]	2	Balance	0.5000	1.0000	0.5000	0.6667	train_dataset_final
(349.5, 400.0]	2	CreditScore	1.0000	1.0000	1.0000	1.0000	test_dataset_final
(400.0, 450.0]	10	CreditScore	0.7000	0.6000	0.7500	0.6667	test_dataset_final
(450.0, 500.0]	34	CreditScore	0.5000	0.4583	0.7333	0.5641	test_dataset_final
(500.0, 550.0]	66	CreditScore	0.6061	0.6136	0.7500	0.6750	test_dataset_final
(550.0, 600.0]	87	CreditScore	0.5862	0.6279	0.5745	0.6000	test_dataset_final
(600.0, 650.0]	116	CreditScore	0.7155	0.7581	0.7231	0.7402	test_dataset_final
(650.0, 700.0]	133	CreditScore	0.6316	0.5775	0.6833	0.6260	test_dataset_final
(700.0, 750.0]	79	CreditScore	0.6582	0.6571	0.6053	0.6301	test_dataset_final
(750.0, 800.0]	68	CreditScore	0.5882	0.4643	0.5000	0.4815	test_dataset_final
(800.0, 850.0]	52	CreditScore	0.7308	0.7143	0.6522	0.6818	test_dataset_final
(349.5, 400.0]	12	CreditScore	0.6667	1.0000	0.6667	0.8000	train_dataset_final
(400.0, 450.0]	48	CreditScore	0.6458	0.7600	0.6333	0.6909	train_dataset_final
(450.0, 500.0]	113	CreditScore	0.6106	0.6027	0.7458	0.6667	train_dataset_final
(500.0, 550.0]	260	CreditScore	0.6500	0.6788	0.6643	0.6715	train_dataset_final
(550.0, 600.0]	363	CreditScore	0.6612	0.6634	0.7090	0.6854	train_dataset_final
(600.0, 650.0]	464	CreditScore	0.6078	0.6089	0.5931	0.6009	train_dataset_final
(650.0, 700.0]	514	CreditScore	0.6576	0.6344	0.6076	0.6207	train_dataset_final
(700.0, 750.0]	400	CreditScore	0.6875	0.7299	0.6195	0.6702	train_dataset_final
(750.0, 800.0]	249	CreditScore	0.6908	0.6803	0.6860	0.6831	train_dataset_final
(800.0, 850.0]	162	CreditScore	0.6173	0.6129	0.5000	0.5507	train_dataset_final
(-188.362, 20005.755]	70	EstimatedSalary	0.7286	0.6923	0.7941	0.7397	test_dataset_final
(20005.755, 39999.93]	67	EstimatedSalary	0.6716	0.6410	0.7576	0.6944	test_dataset_final
(39999.93, 59994.105]	61	EstimatedSalary	0.6393	0.6400	0.5517	0.5926	test_dataset_final
(59994.105, 79988.28]	81	EstimatedSalary	0.6667	0.6190	0.7027	0.6582	test_dataset_final
(79988.28, 99982.455]	52	EstimatedSalary	0.6346	0.6800	0.6071	0.6415	test_dataset_final
(99982.455, 119976.63]	67	EstimatedSalary	0.6119	0.7188	0.5750	0.6389	test_dataset_final
(119976.63, 139970.805]	56	EstimatedSalary	0.5893	0.5000	0.7826	0.6102	test_dataset_final
(139970.805, 159964.98]	57	EstimatedSalary	0.6316	0.6667	0.6452	0.6557	test_dataset_final
(159964.98, 179959.155]	69	EstimatedSalary	0.6087	0.5946	0.6471	0.6197	test_dataset_final
(179959.155, 199953.33]	67	EstimatedSalary	0.5970	0.5000	0.5556	0.5263	test_dataset_final
(-188.362, 20005.755]	265	EstimatedSalary	0.7019	0.7328	0.6391	0.6827	train_dataset_final
(20005.755, 39999.93]	245	EstimatedSalary	0.6367	0.6446	0.6290	0.6367	train_dataset_final
(39999.93, 59994.105]	260	EstimatedSalary	0.6577	0.6341	0.6393	0.6367	train_dataset_final
(59994.105, 79988.28]	267	EstimatedSalary	0.6554	0.6855	0.6159	0.6489	train_dataset_final
(79988.28, 99982.455]	263	EstimatedSalary	0.6692	0.6418	0.6880	0.6641	train_dataset_final
(99982.455, 119976.63]	251	EstimatedSalary	0.6255	0.6148	0.6148	0.6148	train_dataset_final
(119976.63, 139970.805]	266	EstimatedSalary	0.6391	0.6642	0.6357	0.6496	train_dataset_final
(139970.805, 159964.98]	244	EstimatedSalary	0.6516	0.6579	0.6198	0.6383	train_dataset_final
(159964.98, 179959.155]	275	EstimatedSalary	0.6364	0.6692	0.6138	0.6403	train_dataset_final
(179959.155, 199953.33]	249	EstimatedSalary	0.6386	0.6493	0.6692	0.6591	train_dataset_final
(-0.001, 0.1]	306	Gender_Male	0.6307	0.6355	0.7953	0.7065	test_dataset_final
(0.9, 1.0]	341	Gender_Male	0.6481	0.6033	0.5034	0.5489	test_dataset_final
(-0.001, 0.1]	1258	Gender_Male	0.6558	0.6726	0.7848	0.7244	train_dataset_final
(0.9, 1.0]	1327	Gender_Male	0.6473	0.6308	0.4487	0.5244	train_dataset_final
(-0.001, 0.1]	451	Geography_Germany	0.6297	0.5796	0.4740	0.5215	test_dataset_final
(0.9, 1.0]	196	Geography_Germany	0.6633	0.6629	0.9516	0.7815	test_dataset_final
(-0.001, 0.1]	1807	Geography_Germany	0.6348	0.5996	0.4299	0.5008	train_dataset_final
(0.9, 1.0]	778	Geography_Germany	0.6902	0.7055	0.9358	0.8045	train_dataset_final
(-0.001, 0.1]	515	Geography_Spain	0.6447	0.6357	0.7061	0.6691	test_dataset_final
(0.9, 1.0]	132	Geography_Spain	0.6212	0.5455	0.4444	0.4898	test_dataset_final
(-0.001, 0.1]	1959	Geography_Spain	0.6508	0.6622	0.6777	0.6699	train_dataset_final
(0.9, 1.0]	626	Geography_Spain	0.6534	0.6425	0.4819	0.5507	train_dataset_final
(-0.001, 0.1]	204	HasCrCard	0.5882	0.5833	0.6176	0.6000	test_dataset_final
(0.9, 1.0]	443	HasCrCard	0.6637	0.6432	0.6822	0.6621	test_dataset_final
(-0.001, 0.1]	788	HasCrCard	0.6358	0.6423	0.6046	0.6229	train_dataset_final
(0.9, 1.0]	1797	HasCrCard	0.6583	0.6659	0.6498	0.6577	train_dataset_final
(-0.001, 0.1]	374	IsActiveMember	0.6417	0.6381	0.8221	0.7185	test_dataset_final
(0.9, 1.0]	273	IsActiveMember	0.6374	0.5672	0.3519	0.4343	test_dataset_final
(-0.001, 0.1]	1346	IsActiveMember	0.6434	0.6704	0.8027	0.7306	train_dataset_final
(0.9, 1.0]	1239	IsActiveMember	0.6602	0.6197	0.3599	0.4554	train_dataset_final
(0.997, 1.3]	387	NumOfProducts	0.6486	0.6974	0.7035	0.7004	test_dataset_final
(1.9, 2.2]	215	NumOfProducts	0.6558	0.3373	0.5957	0.4308	test_dataset_final
(2.8, 3.1]	34	NumOfProducts	0.5294	0.9000	0.5625	0.6923	test_dataset_final
(3.7, 4.0]	11	NumOfProducts	0.3636	1.0000	0.3636	0.5333	test_dataset_final
(0.997, 1.3]	1485	NumOfProducts	0.6471	0.7248	0.6682	0.6953	train_dataset_final
(1.9, 2.2]	910	NumOfProducts	0.6780	0.3958	0.5848	0.4721	train_dataset_final
(2.8, 3.1]	157	NumOfProducts	0.5732	0.9880	0.5541	0.7100	train_dataset_final
(3.7, 4.0]	33	NumOfProducts	0.4848	1.0000	0.4848	0.6531	train_dataset_final
(-0.01, 1.0]	83	Tenure	0.7831	0.7755	0.8444	0.8085	test_dataset_final
(1.0, 2.0]	71	Tenure	0.5634	0.5333	0.7059	0.6076	test_dataset_final
(2.0, 3.0]	70	Tenure	0.5286	0.4545	0.6897	0.5479	test_dataset_final
(3.0, 4.0]	71	Tenure	0.6761	0.6829	0.7368	0.7089	test_dataset_final
(4.0, 5.0]	61	Tenure	0.6230	0.6000	0.5357	0.5660	test_dataset_final
(5.0, 6.0]	56	Tenure	0.6071	0.5806	0.6667	0.6207	test_dataset_final
(6.0, 7.0]	70	Tenure	0.5429	0.5172	0.4545	0.4839	test_dataset_final
(7.0, 8.0]	63	Tenure	0.7302	0.7000	0.7241	0.7119	test_dataset_final
(8.0, 9.0]	75	Tenure	0.6667	0.7576	0.5952	0.6667	test_dataset_final
(9.0, 10.0]	27	Tenure	0.6667	0.6250	0.4545	0.5263	test_dataset_final
(-0.01, 1.0]	374	Tenure	0.6310	0.6651	0.6715	0.6683	train_dataset_final
(1.0, 2.0]	266	Tenure	0.6504	0.6183	0.6532	0.6353	train_dataset_final
(2.0, 3.0]	285	Tenure	0.6175	0.6216	0.6345	0.6280	train_dataset_final
(3.0, 4.0]	257	Tenure	0.6187	0.6357	0.6165	0.6260	train_dataset_final
(4.0, 5.0]	245	Tenure	0.6939	0.7244	0.6970	0.7104	train_dataset_final
(5.0, 6.0]	248	Tenure	0.6452	0.6789	0.5827	0.6271	train_dataset_final
(6.0, 7.0]	238	Tenure	0.6513	0.5981	0.6154	0.6066	train_dataset_final
(7.0, 8.0]	277	Tenure	0.6787	0.6842	0.5954	0.6367	train_dataset_final
(8.0, 9.0]	247	Tenure	0.6802	0.6838	0.6557	0.6695	train_dataset_final
(9.0, 10.0]	148	Tenure	0.6689	0.7031	0.6000	0.6475	train_dataset_final

Figures

▶ Test Result: Overfit Diagnosis (validmind.model_validation.sklearn.OverfitDiagnosis)

Overfit Diagnosis

The Overfit Diagnosis test evaluates the extent to which model performance on the training set diverges from performance on the test set across feature segments, using AUC as the metric for this classification model. The results are presented as AUC gaps for each feature slice, with a threshold of 0.04 used to flag regions of potential overfitting. Multiple features display segments where the AUC gap between training and test sets exceeds this threshold, indicating localized overfit risk. Visualizations provide a detailed view of the magnitude and distribution of these gaps across the feature space.

Key insights:

• Pronounced overfitting in specific feature segments: Notable AUC gaps are observed in segments such as CreditScore (e.g., (450.0, 500.0] with gap 0.1931; (750.0, 800.0] with gap 0.194), Balance ((200718.472, 225808.281] with gap 0.7273), and NumOfProducts ((2.8, 3.1] with gap 0.5573), all substantially exceeding the 0.04 threshold.
• Multiple features with moderate overfit regions: Tenure, EstimatedSalary, IsActiveMember, and HasCrCard each contain segments with AUC gaps above the threshold, with Tenure showing gaps up to 0.1298 and EstimatedSalary up to 0.0909.
• Overfitting concentrated in low-support or extreme-value bins: The largest AUC gaps are often associated with feature slices that have relatively few test records, such as Balance and NumOfProducts, indicating sensitivity in regions with limited data.
• Geographic and demographic features show limited overfit: Geography_Spain and Gender_Male display AUC gaps near or just above the threshold (0.0759 and 0.0449, respectively), while Geography_Germany remains below the threshold.
• Visualization confirms segment-specific risk: Plots consistently show that overfitting is not uniform but localized to particular feature intervals, with the majority of segments remaining below the threshold.

The Overfit Diagnosis test reveals that overfitting is present in several distinct feature segments, with the most substantial AUC gaps occurring in regions with low sample support or extreme feature values. While most feature intervals remain within acceptable limits, certain segments—particularly for Balance, NumOfProducts, and CreditScore—exhibit pronounced divergence between training and test performance. These findings indicate that model generalization is uneven across the feature space, with localized risk concentrated in specific data regions.

Tables

Overfit Diagnosis

Feature	Slice	Number of Training Records	Number of Test Records	Training AUC	Test AUC	Gap
CreditScore	(450.0, 500.0]	113	34	0.6773	0.4842	0.1931
CreditScore	(700.0, 750.0]	400	79	0.7361	0.6528	0.0833
CreditScore	(750.0, 800.0]	249	68	0.7380	0.5440	0.1940
Tenure	(1.0, 2.0]	266	71	0.6905	0.6367	0.0538
Tenure	(2.0, 3.0]	285	70	0.6522	0.6106	0.0416
Tenure	(4.0, 5.0]	245	61	0.7656	0.6677	0.0978
Tenure	(6.0, 7.0]	238	70	0.6867	0.5569	0.1298
Tenure	(9.0, 10.0]	148	27	0.6992	0.5966	0.1026
Balance	(-250.898, 25089.809]	826	201	0.6794	0.6052	0.0741
Balance	(25089.809, 50179.618]	23	3	0.6846	0.5000	0.1846
Balance	(175628.663, 200718.472]	42	18	0.4468	0.3125	0.1343
Balance	(200718.472, 225808.281]	12	5	0.7273	0.0000	0.7273
NumOfProducts	(2.8, 3.1]	157	34	0.8386	0.2812	0.5573
HasCrCard	(-0.001, 0.1]	788	204	0.6859	0.6349	0.0510
IsActiveMember	(0.9, 1.0]	1239	273	0.6692	0.6113	0.0579
EstimatedSalary	(59994.105, 79988.28]	267	81	0.7192	0.6757	0.0436
EstimatedSalary	(79988.28, 99982.455]	263	52	0.7246	0.6518	0.0729
EstimatedSalary	(99982.455, 119976.63]	251	67	0.6674	0.6130	0.0544
EstimatedSalary	(159964.98, 179959.155]	275	69	0.6926	0.6017	0.0909
EstimatedSalary	(179959.155, 199953.33]	249	67	0.6935	0.6185	0.0750
Geography_Spain	(0.9, 1.0]	626	132	0.7008	0.6249	0.0759
Gender_Male	(-0.001, 0.1]	1258	306	0.6793	0.6344	0.0449

Figures

▶ Test Result: Robustness Diagnosis (validmind.model_validation.sklearn.RobustnessDiagnosis)

✅ Robustness Diagnosis

The Robustness Diagnosis test evaluates the resilience of the model to input perturbations by measuring AUC decay under increasing levels of Gaussian noise applied to numeric features. The results table and plot display AUC values and performance decay across both train and test datasets for perturbation sizes ranging from 0.0 to 0.5 standard deviations. AUC values and performance decay are reported for each perturbation level, with visualizations illustrating the relationship between noise magnitude and model performance.

Key insights:

• Minimal performance decay at low noise levels: For perturbation sizes up to 0.2, AUC decay remains below 0.0042 on both train and test datasets, indicating limited sensitivity to small input noise.
• Gradual AUC reduction with increasing noise: As perturbation size increases to 0.5, AUC decreases by 0.0179 on train and 0.0079 on test datasets, with the largest observed decay at 0.3 for the test set (0.0164).
• No threshold breaches observed: All performance decay values remain below the plotted threshold lines for both train and test datasets, and all test points are marked as passed.
• Consistent robustness across datasets: The pattern of AUC decay is similar for both train and test datasets, with no abrupt drops or divergence between the two.

The results indicate that the model maintains stable performance under moderate levels of Gaussian noise, with only incremental reductions in AUC as perturbation size increases. No significant or abrupt performance degradation is observed, and all tested perturbation levels remain within the defined acceptance thresholds. The model demonstrates consistent robustness to input noise across both train and test datasets.

Tables

Perturbation Size	Dataset	Row Count	AUC	Performance Decay	Passed
Baseline (0.0)	train_dataset_final	2585	0.6996	0.0000	True
Baseline (0.0)	test_dataset_final	647	0.6746	0.0000	True
0.1	train_dataset_final	2585	0.6981	0.0015	True
0.1	test_dataset_final	647	0.6727	0.0019	True
0.2	train_dataset_final	2585	0.6978	0.0018	True
0.2	test_dataset_final	647	0.6705	0.0041	True
0.3	train_dataset_final	2585	0.6890	0.0106	True
0.3	test_dataset_final	647	0.6583	0.0164	True
0.4	train_dataset_final	2585	0.6880	0.0116	True
0.4	test_dataset_final	647	0.6617	0.0130	True
0.5	train_dataset_final	2585	0.6818	0.0179	True
0.5	test_dataset_final	647	0.6668	0.0079	True

Figures

In summary

In this second notebook, you learned how to:

• Import a sample dataset
• Identify which tests you might want to run with ValidMind
• Initialize ValidMind datasets and model objects
• Run individual tests
• Utilize the output from tests you've run
• Log test results from sets of or individual tests as evidence to the ValidMind Platform
• Add supplementary individual test results to your documentation
• Assign model predictions to your ValidMind model objects

Next steps

Integrate custom tests

Now that you're familiar with the basics of using the ValidMind Library to run and log tests to provide evidence for your model documentation, let's learn how to incorporate your own custom tests into ValidMind: 3 — Integrate custom tests

---

Copyright © 2023-2026 ValidMind Inc. All rights reserved.
Refer to LICENSE for details.
SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial