validmind 2.2.5__py3-none-any.whl → 2.3.1__py3-none-any.whl

validmind/tests/model_validation/ragas/AnswerRelevance.py

@@ -11,7 +11,7 @@ from ragas.metrics import answer_relevancy
 
 from validmind import tags, tasks
 
-from .utils import get_renamed_columns
+from .utils import get_ragas_config, get_renamed_columns
 
 
 @tags("ragas", "llm", "rag_performance")
@@ -108,8 +108,7 @@ def AnswerRelevance(
     df = get_renamed_columns(dataset.df, required_columns)
 
     result_df = evaluate(
-        Dataset.from_pandas(df),
-        metrics=[answer_relevancy],
+        Dataset.from_pandas(df), metrics=[answer_relevancy], **get_ragas_config()
     ).to_pandas()
 
     fig_histogram = px.histogram(x=result_df["answer_relevancy"].to_list(), nbins=10)
@@ -117,7 +116,9 @@ def AnswerRelevance(
 
     return (
         {
-            "Scores": result_df[["question", "contexts", "answer", "answer_relevancy"]],
+            "Scores (will not be uploaded to UI)": result_df[
+                ["question", "contexts", "answer", "answer_relevancy"]
+            ],
             "Aggregate Scores": [
                 {
                     "Mean Score": result_df["answer_relevancy"].mean(),

validmind/tests/model_validation/ragas/AnswerSimilarity.py

@@ -11,7 +11,7 @@ from ragas.metrics import answer_similarity
 
 from validmind import tags, tasks
 
-from .utils import get_renamed_columns
+from .utils import get_ragas_config, get_renamed_columns
 
 
 @tags("ragas", "llm")
@@ -93,8 +93,7 @@ def AnswerSimilarity(
     df = get_renamed_columns(dataset.df, required_columns)
 
     result_df = evaluate(
-        Dataset.from_pandas(df),
-        metrics=[answer_similarity],
+        Dataset.from_pandas(df), metrics=[answer_similarity], **get_ragas_config()
     ).to_pandas()
 
     fig_histogram = px.histogram(x=result_df["answer_similarity"].to_list(), nbins=10)
@@ -102,7 +101,9 @@ def AnswerSimilarity(
 
     return (
         {
-            "Scores": result_df[["answer", "ground_truth", "answer_similarity"]],
+            "Scores (will not be uploaded to UI)": result_df[
+                ["answer", "ground_truth", "answer_similarity"]
+            ],
             "Aggregate Scores": [
                 {
                     "Mean Score": result_df["answer_similarity"].mean(),

validmind/tests/model_validation/ragas/AspectCritique.py

@@ -18,7 +18,7 @@ from ragas.metrics.critique import (
 
 from validmind import tags, tasks
 
-from .utils import get_renamed_columns
+from .utils import get_ragas_config, get_renamed_columns
 
 aspect_map = {
     "coherence": coherence,
@@ -36,14 +36,14 @@ def AspectCritique(
     question_column="question",
     answer_column="answer",
     contexts_column="contexts",
-    aspects: list = [
+    aspects: list = [  # noqa: B006 this is fine as immutable default since it never gets modified
         "coherence",
         "conciseness",
         "correctness",
         "harmfulness",
         "maliciousness",
     ],
-    additional_aspects: list = [],
+    additional_aspects: list = None,
 ):
     """
     Evaluates generations against the following aspects: harmfulness, maliciousness,
@@ -131,13 +131,19 @@ def AspectCritique(
     df = get_renamed_columns(dataset.df, required_columns)
 
     built_in_aspects = [aspect_map[aspect] for aspect in aspects]
-    custom_aspects = [
-        _AspectCritique(name=name, definition=description)
-        for name, description in additional_aspects
-    ]
+    custom_aspects = (
+        [
+            _AspectCritique(name=name, definition=description)
+            for name, description in additional_aspects
+        ]
+        if additional_aspects
+        else []
+    )
     all_aspects = [*built_in_aspects, *custom_aspects]
 
-    result_df = evaluate(Dataset.from_pandas(df), metrics=all_aspects).to_pandas()
+    result_df = evaluate(
+        Dataset.from_pandas(df), metrics=all_aspects, **get_ragas_config()
+    ).to_pandas()
 
     df_melted = result_df.melt(
         id_vars=["question", "answer", "contexts"],

validmind/tests/model_validation/ragas/ContextEntityRecall.py

@@ -11,7 +11,7 @@ from ragas.metrics import context_entity_recall
 
 from validmind import tags, tasks
 
-from .utils import get_renamed_columns
+from .utils import get_ragas_config, get_renamed_columns
 
 
 @tags("ragas", "llm", "retrieval_performance")
@@ -99,8 +99,7 @@ def ContextEntityRecall(
     df = get_renamed_columns(dataset.df, required_columns)
 
     result_df = evaluate(
-        Dataset.from_pandas(df),
-        metrics=[context_entity_recall],
+        Dataset.from_pandas(df), metrics=[context_entity_recall], **get_ragas_config()
     ).to_pandas()
 
     fig_histogram = px.histogram(
@@ -110,7 +109,7 @@ def ContextEntityRecall(
 
     return (
         {
-            "Scores": result_df[
+            "Scores (will not be uploaded to UI)": result_df[
                 [
                     "contexts",
                     "ground_truth",

validmind/tests/model_validation/ragas/ContextPrecision.py

@@ -11,7 +11,7 @@ from ragas.metrics import context_precision
 
 from validmind import tags, tasks
 
-from .utils import get_renamed_columns
+from .utils import get_ragas_config, get_renamed_columns
 
 
 @tags("ragas", "llm", "retrieval_performance")
@@ -21,7 +21,7 @@ def ContextPrecision(
     question_column: str = "question",
     contexts_column: str = "contexts",
     ground_truth_column: str = "ground_truth",
-):
+):  # noqa: B950
     """
     Context Precision is a metric that evaluates whether all of the ground-truth
     relevant items present in the contexts are ranked higher or not. Ideally all the
@@ -95,8 +95,7 @@ def ContextPrecision(
     df = get_renamed_columns(dataset.df, required_columns)
 
     result_df = evaluate(
-        Dataset.from_pandas(df),
-        metrics=[context_precision],
+        Dataset.from_pandas(df), metrics=[context_precision], **get_ragas_config()
     ).to_pandas()
 
     fig_histogram = px.histogram(x=result_df["context_precision"].to_list(), nbins=10)
@@ -104,7 +103,7 @@ def ContextPrecision(
 
     return (
         {
-            "Scores": result_df[
+            "Scores (will not be uploaded to UI)": result_df[
                 ["question", "contexts", "ground_truth", "context_precision"]
             ],
             "Aggregate Scores": [

validmind/tests/model_validation/ragas/ContextRecall.py

@@ -11,7 +11,7 @@ from ragas.metrics import context_recall
 
 from validmind import tags, tasks
 
-from .utils import get_renamed_columns
+from .utils import get_ragas_config, get_renamed_columns
 
 
 @tags("ragas", "llm", "retrieval_performance")
@@ -95,8 +95,7 @@ def ContextRecall(
     df = get_renamed_columns(dataset.df, required_columns)
 
     result_df = evaluate(
-        Dataset.from_pandas(df),
-        metrics=[context_recall],
+        Dataset.from_pandas(df), metrics=[context_recall], **get_ragas_config()
     ).to_pandas()
 
     fig_histogram = px.histogram(x=result_df["context_recall"].to_list(), nbins=10)
@@ -104,7 +103,7 @@ def ContextRecall(
 
     return (
         {
-            "Scores": result_df[
+            "Scores (will not be uploaded to UI)": result_df[
                 ["question", "contexts", "ground_truth", "context_recall"]
             ],
             "Aggregate Scores": [

validmind/tests/model_validation/ragas/ContextRelevancy.py

@@ -11,7 +11,7 @@ from ragas.metrics import context_relevancy
 
 from validmind import tags, tasks
 
-from .utils import get_renamed_columns
+from .utils import get_ragas_config, get_renamed_columns
 
 
 @tags("ragas", "llm", "retrieval_performance")
@@ -88,8 +88,7 @@ def ContextRelevancy(
     df = get_renamed_columns(dataset.df, required_columns)
 
     result_df = evaluate(
-        Dataset.from_pandas(df),
-        metrics=[context_relevancy],
+        Dataset.from_pandas(df), metrics=[context_relevancy], **get_ragas_config()
     ).to_pandas()
 
     fig_histogram = px.histogram(x=result_df["context_relevancy"].to_list(), nbins=10)
@@ -97,7 +96,9 @@ def ContextRelevancy(
 
     return (
         {
-            "Scores": result_df[["question", "contexts", "context_relevancy"]],
+            "Scores (will not be uploaded to UI)": result_df[
+                ["question", "contexts", "context_relevancy"]
+            ],
             "Aggregate Scores": [
                 {
                     "Mean Score": result_df["context_relevancy"].mean(),

validmind/tests/model_validation/ragas/Faithfulness.py

@@ -11,7 +11,7 @@ from ragas.metrics import faithfulness
 
 from validmind import tags, tasks
 
-from .utils import get_renamed_columns
+from .utils import get_ragas_config, get_renamed_columns
 
 
 @tags("ragas", "llm", "rag_performance")
@@ -20,7 +20,7 @@ def Faithfulness(
     dataset,
     answer_column="answer",
     contexts_column="contexts",
-):
+):  # noqa
     """
     Evaluates the faithfulness of the generated answers with respect to retrieved contexts.
 
@@ -93,8 +93,7 @@ def Faithfulness(
     df = get_renamed_columns(dataset.df, required_columns)
 
     result_df = evaluate(
-        Dataset.from_pandas(df),
-        metrics=[faithfulness],
+        Dataset.from_pandas(df), metrics=[faithfulness], **get_ragas_config()
     ).to_pandas()
 
     fig_histogram = px.histogram(x=result_df["faithfulness"].to_list(), nbins=10)
@@ -102,7 +101,9 @@ def Faithfulness(
 
     return (
         {
-            "Scores": result_df[["contexts", "answer", "faithfulness"]],
+            "Scores (will not be uploaded to UI)": result_df[
+                ["contexts", "answer", "faithfulness"]
+            ],
             "Aggregate Scores": [
                 {
                     "Mean Score": result_df["faithfulness"].mean(),

validmind/tests/model_validation/ragas/utils.py

@@ -2,17 +2,42 @@
 # See the LICENSE file in the root of this repository for details.
 # SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
 
+import os
 
-def _udf_get_sub_col(x, root_col, sub_col):
-    if not isinstance(x, dict):
-        raise TypeError(f"Expected a dictionary in column '{root_col}', got {type(x)}.")
+from langchain_openai import ChatOpenAI, OpenAIEmbeddings
 
-    if sub_col not in x:
-        raise KeyError(
-            f"Sub-column '{sub_col}' not found in dictionary in column '{root_col}'."
-        )
+from validmind.ai.utils import get_client_and_model
 
-    return x[sub_col]
+EMBEDDINGS_MODEL = "text-embedding-3-small"
+
+
+def get_ragas_config():
+    client, model = get_client_and_model()
+    os.environ["OPENAI_API_BASE"] = str(client.base_url)
+
+    return {
+        "llm": ChatOpenAI(api_key=client.api_key, model=model),
+        "embeddings": OpenAIEmbeddings(api_key=client.api_key, model=EMBEDDINGS_MODEL),
+    }
+
+
+def make_sub_col_udf(root_col, sub_col):
+    """Create a udf that extracts sub-column values from a dictionary."""
+
+    def _udf_get_sub_col(x):
+        if not isinstance(x, dict):
+            raise TypeError(
+                f"Expected a dictionary in column '{root_col}', got {type(x)}."
+            )
+
+        if sub_col not in x:
+            raise KeyError(
+                f"Sub-column '{sub_col}' not found in dictionary in column '{root_col}'."
+            )
+
+        return x[sub_col]
+
+    return _udf_get_sub_col
 
 
 def get_renamed_columns(df, column_map):
@@ -34,6 +59,7 @@ def get_renamed_columns(df, column_map):
     Returns:
         pd.DataFrame: The DataFrame with columns renamed.
     """
+
     new_df = df.copy()
 
     for new_name, source in column_map.items():
@@ -50,7 +76,7 @@ def get_renamed_columns(df, column_map):
 
             if root_col in new_df.columns:
                 new_df[new_name] = new_df[root_col].apply(
-                    lambda x: _udf_get_sub_col(x, root_col, sub_col)
+                    make_sub_col_udf(root_col, sub_col)
                 )
 
             else:

validmind/tests/model_validation/sklearn/ClusterPerformance.py

@@ -66,7 +66,7 @@ class ClusterPerformance(Metric):
         y_true_test = y_true_test.astype(y_pred_test.dtype).flatten()
         results = []
         for metric_name, metric_fcn in metric_info.items():
-            for sample in samples:
+            for _ in samples:
                 train_value = metric_fcn(list(y_true_train), y_pred_train)
                 test_value = metric_fcn(list(y_true_test), y_pred_test)
             results.append(
@@ -85,7 +85,7 @@ class ClusterPerformance(Metric):
         """
         table_records = []
         for result in raw_results:
-            for key, value in result.items():
+            for key, _ in result.items():
                 table_records.append(
                     {
                         "Metric": key,

validmind/tests/model_validation/sklearn/ClusterPerformanceMetrics.py

@@ -123,7 +123,7 @@ class ClusterPerformanceMetrics(ClusterPerformance):
         """
         table_records = []
         for result in raw_results:
-            for key, value in result.items():
+            for key, _ in result.items():
                 table_records.append(
                     {
                         "Metric": key,

validmind/tests/model_validation/sklearn/ModelsPerformanceComparison.py

@@ -52,7 +52,7 @@ class ModelsPerformanceComparison(ClassifierPerformance):
     """
 
     name = "models_performance_comparison"
-    required_inputs = ["model", "models", "dataset"]
+    required_inputs = ["dataset", "models"]
     metadata = {
         "task_types": ["classification", "text_classification"],
         "tags": [
@@ -70,12 +70,12 @@ class ModelsPerformanceComparison(ClassifierPerformance):
         """
         results = []
         prf_table = []
-        classes = {str(i) for i in unique(self.y_true())}
+        classes = {str(i) for i in unique(self.inputs.dataset.y)}
 
         for class_name in classes:
             prf_dict = {}
             prf_dict["Class"] = class_name
-            for m, m_v in metric_value.items():
+            for m, _ in metric_value.items():
                 prf_dict[f"Precision- {m}"] = metric_value[m][class_name]["precision"]
                 prf_dict[f"Recall- {m}"] = metric_value[m][class_name]["recall"]
                 prf_dict[f"F1- {m}"] = metric_value[m][class_name]["f1-score"]
@@ -85,7 +85,7 @@ class ModelsPerformanceComparison(ClassifierPerformance):
         for class_name in avg_metrics:
             avg_dict = {}
             avg_dict["Class"] = class_name
-            for m, m_v in metric_value.items():
+            for m, _ in metric_value.items():
                 avg_dict[f"Precision- {m}"] = metric_value[m][class_name]["precision"]
                 avg_dict[f"Recall- {m}"] = metric_value[m][class_name]["recall"]
                 avg_dict[f"F1- {m}"] = metric_value[m][class_name]["f1-score"]
@@ -103,7 +103,7 @@ class ModelsPerformanceComparison(ClassifierPerformance):
         for metric_name in ["accuracy", "roc_auc"]:
             acc_roc_auc_dict = {}
             acc_roc_auc_dict["Metric"] = metric_name
-            for m, m_v in metric_value.items():
+            for m, _ in metric_value.items():
                 acc_roc_auc_dict[f"accuracy- {m}"] = metric_value[m]["accuracy"]
                 acc_roc_auc_dict[f"roc_auc- {m}"] = metric_value[m]["roc_auc"]
             acc_roc_auc_table.append(acc_roc_auc_dict)
@@ -122,10 +122,8 @@ class ModelsPerformanceComparison(ClassifierPerformance):
                 "List of models must be provided as a `models` parameter to compare performance"
             )
 
-        all_models = [self.inputs.model]
+        all_models = self.inputs.models
 
-        if self.inputs.models is not None:
-            all_models.extend(self.inputs.models)
         results = {}
         for idx, model in enumerate(all_models):
             y_true = self.inputs.dataset.y

validmind/tests/model_validation/sklearn/RegressionErrors.py

@@ -57,7 +57,7 @@ class RegressionErrors(Metric):
         """
         table_records = []
         for result in raw_results:
-            for key, value in result.items():
+            for key, _ in result.items():
                 table_records.append(
                     {
                         "Metric": key,

validmind/tests/model_validation/sklearn/RegressionModelsPerformanceComparison.py

@@ -9,8 +9,11 @@ import numpy as np
 from sklearn.metrics import mean_absolute_error, mean_squared_error
 
 from validmind.errors import SkipTestError
+from validmind.logging import get_logger
 from validmind.vm_models import Metric, ResultSummary, ResultTable, ResultTableMetadata
 
+logger = get_logger(__name__)
+
 
 @dataclass
 class RegressionModelsPerformanceComparison(Metric):
@@ -56,7 +59,7 @@ class RegressionModelsPerformanceComparison(Metric):
     """
 
     name = "models_performance_comparison"
-    required_inputs = ["model", "dataset"]
+    required_inputs = ["dataset", "models"]
 
     metadata = {
         "task_types": ["regression"],
@@ -76,8 +79,14 @@ class RegressionModelsPerformanceComparison(Metric):
         results["Mean Squared Error (MSE)"] = mse_test
         results["Root Mean Squared Error (RMSE)"] = np.sqrt(mse_test)
 
-        mape_test = np.mean(np.abs((y_true_test - y_pred_test) / y_true_test)) * 100
-        results["Mean Absolute Percentage Error (MAPE)"] = mape_test
+        if np.any(y_true_test == 0):
+            logger.warning(
+                "y_true_test contains zero values. Skipping MAPE calculation to avoid division by zero."
+            )
+            results["Mean Absolute Percentage Error (MAPE)"] = None
+        else:
+            mape_test = np.mean(np.abs((y_true_test - y_pred_test) / y_true_test)) * 100
+            results["Mean Absolute Percentage Error (MAPE)"] = mape_test
 
         mbd_test = np.mean(y_pred_test - y_true_test)
         results["Mean Bias Deviation (MBD)"] = mbd_test
@@ -94,7 +103,7 @@ class RegressionModelsPerformanceComparison(Metric):
         for metric_name in metrics:
             errors_dict = {}
             errors_dict["Errors"] = metric_name
-            for m, m_v in metric_value.items():
+            for m, _ in metric_value.items():
                 for metric in metrics:
                     res = re.findall(r"\(.*?\)", metric)
                     res[0][1:-1]
@@ -117,10 +126,7 @@ class RegressionModelsPerformanceComparison(Metric):
                 "List of models must be provided as a `models` parameter to compare performance"
             )
 
-        all_models = [self.inputs.model]
-
-        if self.inputs.models is not None:
-            all_models.extend(self.inputs.models)
+        all_models = self.inputs.models
 
         results = {}
 

validmind/tests/model_validation/sklearn/RegressionR2Square.py

@@ -57,7 +57,7 @@ class RegressionR2Square(Metric):
         """
         table_records = []
         for result in raw_results:
-            for key, value in result.items():
+            for key, _ in result.items():
                 table_records.append(
                     {
                         "Metric": key,

validmind/tests/model_validation/statsmodels/DurbinWatsonTest.py

@@ -53,7 +53,7 @@ class DurbinWatsonTest(Metric):
         """
         Calculates DB for each of the dataset features
         """
-        x_train = self.train_ds.df
+        x_train = self.inputs.dataset.df
         dw_values = {}
         for col in x_train.columns:
             dw_values[col] = durbin_watson(x_train[col].values)

validmind/tests/model_validation/statsmodels/GINITable.py

@@ -80,7 +80,7 @@ class GINITable(Metric):
         metrics_dict = {"Dataset": [], "AUC": [], "GINI": [], "KS": []}
 
         # Iterate over each dataset in the inputs
-        for i, dataset in enumerate(self.inputs.datasets):
+        for _, dataset in enumerate(self.inputs.datasets):
             dataset_label = (
                 dataset.input_id
             )  # Use input_id as the label for each dataset

validmind/tests/model_validation/statsmodels/JarqueBera.py

@@ -59,7 +59,7 @@ class JarqueBera(Metric):
         """
         Calculates JB for each of the dataset features
         """
-        x_train = self.inputs.dataset.df
+        x_train = self.inputs.dataset.df[self.inputs.dataset.feature_columns_numeric]
 
         jb_values = {}
         for col in x_train.columns:

validmind/tests/model_validation/statsmodels/KolmogorovSmirnov.py

@@ -87,7 +87,7 @@ class KolmogorovSmirnov(Metric):
         if data_distribution not in ["norm" or "exp"]:
             InvalidTestParametersError("Dist parameter must be either 'norm' or 'exp'")
 
-        x_train = self.inputs.dataset.df
+        x_train = self.inputs.dataset.df[self.inputs.dataset.feature_columns_numeric]
         ks_values = {}
         for col in x_train.columns:
             ks_stat, p_value = kstest_normal(x_train[col].values, data_distribution)

validmind/tests/model_validation/statsmodels/LJungBox.py

@@ -54,7 +54,7 @@ class LJungBox(Metric):
         """
         Calculates Ljung-Box test for each of the dataset features
         """
-        x_train = self.train_ds.df
+        x_train = self.inputs.dataset.df
 
         ljung_box_values = {}
         for col in x_train.columns:

validmind/tests/model_validation/statsmodels/Lilliefors.py

@@ -70,7 +70,7 @@ class Lilliefors(Metric):
         """
         Calculates Lilliefors test for each of the dataset features
         """
-        x_train = self.train_ds.df
+        x_train = self.inputs.dataset.df[self.inputs.dataset.feature_columns_numeric]
 
         lilliefors_values = {}
         for col in x_train.columns:

validmind/tests/model_validation/statsmodels/RegressionCoeffsPlot.py

@@ -8,6 +8,7 @@ import pandas as pd
 import plotly.graph_objects as go
 from scipy import stats
 
+from validmind.errors import SkipTestError
 from validmind.vm_models import Figure, Metric
 
 
@@ -115,6 +116,9 @@ class RegressionCoeffsPlot(Metric):
             all_models.extend(self.inputs.models)
 
         for i, model in enumerate(all_models):
+            if model.library != "statsmodels":
+                raise SkipTestError("Only statsmodels are supported for this metric")
+
             model_name = f"Model {i+1}"
 
             fig, metric_values = self.plot_coefficients_with_ci(model, model_name)

validmind/tests/model_validation/statsmodels/RegressionFeatureSignificance.py

@@ -7,6 +7,7 @@ from dataclasses import dataclass
 import matplotlib.pyplot as plt
 import seaborn as sns
 
+from validmind.errors import SkipTestError
 from validmind.logging import get_logger
 from validmind.vm_models import Figure, Metric
 
@@ -82,10 +83,14 @@ class RegressionFeatureSignificance(Metric):
         # Initialize a list to store figures
         figures = []
 
-        for i, fitted_model in enumerate(model_list):
+        for i, model in enumerate(model_list):
+
+            if model.library != "statsmodels":
+                raise SkipTestError("Only statsmodels are supported for this metric")
+
             # Get the coefficients and p-values from the model
-            coefficients = fitted_model.model.params
-            pvalues = fitted_model.model.pvalues
+            coefficients = model.model.params
+            pvalues = model.model.pvalues
 
             # Sort the variables by p-value in ascending order
             sorted_idx = pvalues.argsort()
@@ -122,7 +127,7 @@ class RegressionFeatureSignificance(Metric):
                     for_object=self,
                     key=f"{self.key}:{i}",
                     figure=fig,
-                    metadata={"model": str(fitted_model.model)},
+                    metadata={"model": str(model.model)},
                 )
             )
             plt.close("all")

validmind/tests/model_validation/statsmodels/RegressionModelsCoeffs.py

@@ -73,9 +73,9 @@ class RegressionModelsCoeffs(Metric):
             raise ValueError("List of models must be provided in the models parameter")
 
         for model in self.inputs.models:
-            if model.class_ != "statsmodels" and model.class_ != "R":
+            if model.library != "statsmodels":
                 raise SkipTestError(
-                    "Only statsmodels and R models are supported for this metric"
+                    "Only statsmodels models are supported for this metric"
                 )
 
         coefficients = [m.regression_coefficients() for m in self.inputs.models]

validmind/tests/model_validation/statsmodels/RunsTest.py

@@ -59,7 +59,7 @@ class RunsTest(Metric):
         """
         Calculates the run test for each of the dataset features
         """
-        x_train = self.inputs.dataset.df
+        x_train = self.inputs.dataset.df[self.inputs.dataset.feature_columns_numeric]
 
         runs_test_values = {}
         for col in x_train.columns:

validmind/tests/model_validation/statsmodels/ShapiroWilk.py

@@ -53,7 +53,7 @@ class ShapiroWilk(Metric):
         """
         Calculates Shapiro-Wilk test for each of the dataset features.
         """
-        x_train = self.inputs.dataset.df
+        x_train = self.inputs.dataset.df[self.inputs.dataset.feature_columns_numeric]
         sw_values = {}
         for col in x_train.columns:
             sw_stat, sw_pvalue = stats.shapiro(x_train[col].values)