validmind 2.5.8__py3-none-any.whl → 2.5.15__py3-none-any.whl

validmind/tests/data_validation/IQROutliersTable.py

@@ -12,42 +12,46 @@ from validmind.vm_models import Metric, ResultSummary, ResultTable, ResultTableM
 @dataclass
 class IQROutliersTable(Metric):
     """
-    Determines and summarizes outliers in numerical features using Interquartile Range method.
-
-    **Purpose**: The "Interquartile Range Outliers Table" (IQROutliersTable) metric has been designed for identifying
-    and summarizing outliers within numerical features of a dataset using the Interquartile Range (IQR) method. The
-    purpose of this exercise is crucial in the pre-processing of data as outliers can substantially distort the
-    statistical analysis and debilitate the performance of machine learning models.
-
-    **Test Mechanism**: The IQR, which is the range separating the first quartile (25th percentile) from the third
-    quartile (75th percentile), is calculated for each numerical feature within the dataset. An outlier is defined as a
-    data point falling below the "Q1 - 1.5 * IQR" or above "Q3 + 1.5 * IQR" range. The metric then computes the number
-    of outliers along with their minimum, 25th percentile, median, 75th percentile, and maximum values for each
-    numerical feature. If no specific features are chosen, the metric will apply to all numerical features in the
-    dataset. The default outlier threshold is set to 1.5, following the standard definition of outliers in statistical
-    analysis, although it can be customized by the user.
-
-    **Signs of High Risk**:
-    - High risk is indicated by a large number of outliers in multiple features.
-    - Outliers that are significantly distanced from the mean value of variables could potentially signal high risk.
-    - Data entry errors or other data quality issues could be manifested through extremely high or low outlier values.
-
-    **Strengths**:
-    - It yields a comprehensive summary of outliers for each numerical feature within the dataset. This enables the
-    user to pinpoint features with potential quality issues.
-    - The IQR method is not overly affected by extremely high or low outlier values as it is based on quartile
-    calculations.
-    - The versatility of this metric grants the ability to customize the method to work on selected features and set a
-    defined threshold for outliers.
-
-    **Limitations**:
-    - The metric might cause false positives if the variable of interest veers away from a normal or near-normal
-    distribution, notably in the case of skewed distributions.
-    - It does not extend to provide interpretation or recommendations for tackling outliers and relies on the user or a
-    data scientist to conduct further analysis of the results.
-    - As it only functions on numerical features, it cannot be used for categorical data.
-    - For data that has undergone heavy pre-processing, was manipulated, or inherently possesses a high kurtosis (heavy
-    tails), the pre-set threshold may not be optimal for outlier detection.
+    Determines and summarizes outliers in numerical features using the Interquartile Range method.
+
+    ### Purpose
+
+    The "Interquartile Range Outliers Table" (IQROutliersTable) metric is designed to identify and summarize outliers
+    within numerical features of a dataset using the Interquartile Range (IQR) method. This exercise is crucial in the
+    pre-processing of data because outliers can substantially distort statistical analysis and impact the performance
+    of machine learning models.
+
+    ### Test Mechanism
+
+    The IQR, which is the range separating the first quartile (25th percentile) from the third quartile (75th
+    percentile), is calculated for each numerical feature within the dataset. An outlier is defined as a data point
+    falling below the "Q1 - 1.5 * IQR" or above "Q3 + 1.5 * IQR" range. The test computes the number of outliers and
+    their summary statistics (minimum, 25th percentile, median, 75th percentile, and maximum values) for each numerical
+    feature. If no specific features are chosen, the test applies to all numerical features in the dataset. The default
+    outlier threshold is set to 1.5 but can be customized by the user.
+
+    ### Signs of High Risk
+
+    - A large number of outliers in multiple features.
+    - Outliers significantly distanced from the mean value of variables.
+    - Extremely high or low outlier values indicative of data entry errors or other data quality issues.
+
+    ### Strengths
+
+    - Provides a comprehensive summary of outliers for each numerical feature, helping pinpoint features with potential
+    quality issues.
+    - The IQR method is robust to extremely high or low outlier values as it is based on quartile calculations.
+    - Can be customized to work on selected features and set thresholds for outliers.
+
+    ### Limitations
+
+    - Might cause false positives if the variable deviates from a normal or near-normal distribution, especially for
+    skewed distributions.
+    - Does not provide interpretation or recommendations for addressing outliers, relying on further analysis by users
+    or data scientists.
+    - Only applicable to numerical features, not categorical data.
+    - Default thresholds may not be optimal for data with heavy pre-processing, manipulation, or inherently high
+    kurtosis (heavy tails).
     """
 
     name = "iqr_outliers_table"

validmind/tests/data_validation/IsolationForestOutliers.py

@@ -17,24 +17,30 @@ class IsolationForestOutliers(Metric):
     """
     Detects outliers in a dataset using the Isolation Forest algorithm and visualizes results through scatter plots.
 
-    **Purpose**: The `IsolationForestOutliers` test is designed to identify anomalies or outliers in the model's
-    dataset using the isolation forest algorithm. This algorithm assumes that anomalous data points can be isolated
-    more quickly due to their distinctive properties. By creating isolation trees and identifying instances with
-    shorter average path lengths, the test is able to pick out data points that differ from the majority.
-
-    **Test Mechanism**: The test uses the isolation forest algorithm, which builds an ensemble of isolation trees by
-    randomly selecting features and splitting the data based on random thresholds. It isolates anomalies rather than
-    focusing on normal data points. For each pair of variables, a scatter plot is generated which distinguishes the
-    identified outliers from the inliers. The results of the test can be visualized using these scatter plots,
-    illustrating the distinction between outliers and inliers.
-
-    **Signs of High Risk**:
+    ### Purpose
+
+    The IsolationForestOutliers test is designed to identify anomalies or outliers in the model's dataset using the
+    isolation forest algorithm. This algorithm assumes that anomalous data points can be isolated more quickly due to
+    their distinctive properties. By creating isolation trees and identifying instances with shorter average path
+    lengths, the test is able to pick out data points that differ from the majority.
+
+    ### Test Mechanism
+
+    The test uses the isolation forest algorithm, which builds an ensemble of isolation trees by randomly selecting
+    features and splitting the data based on random thresholds. It isolates anomalies rather than focusing on normal
+    data points. For each pair of variables, a scatter plot is generated which distinguishes the identified outliers
+    from the inliers. The results of the test can be visualized using these scatter plots, illustrating the distinction
+    between outliers and inliers.
+
+    ### Signs of High Risk
+
     - The presence of high contamination, indicating a large number of anomalies
     - Inability to detect clusters of anomalies that are close in the feature space
     - Misclassifying normal instances as anomalies
     - Failure to detect actual anomalies
 
-    **Strengths**:
+    ### Strengths
+
     - Ability to handle large, high-dimensional datasets
     - Efficiency in isolating anomalies instead of normal instances
     - Insensitivity to the underlying distribution of data
@@ -42,7 +48,8 @@ class IsolationForestOutliers(Metric):
     distinctive properties
     - Visually presents the test results for better understanding and interpretability
 
-    **Limitations**:
+    ### Limitations
+
     - Difficult to detect anomalies that are close to each other or prevalent in datasets
     - Dependency on the contamination parameter which may need fine-tuning to be effective
     - Potential failure in detecting collective anomalies if they behave similarly to normal data

validmind/tests/data_validation/KPSS.py

@@ -16,35 +16,40 @@ logger = get_logger(__name__)
 @dataclass
 class KPSS(Metric):
     """
-    Executes KPSS unit root test to validate stationarity of time-series data in machine learning model.
-
-    **Purpose**: The Kwiatkowski-Phillips-Schmidt-Shin (KPSS) unit root test is utilized to ensure the stationarity of
-    data within the machine learning model. It specifically works on time-series data to establish the order of
-    integration, which is a prime requirement for accurate forecasting, given the fundamental condition for any time
-    series model is that the series should be stationary.
-
-    **Test Mechanism**: This metric evaluates the KPSS score for every feature present in the dataset. Within the KPSS
-    score, there are various components, namely: a statistic, a p-value, a used lag, and critical values. The core
-    scheme behind the KPSS score is to test the hypothesis that an observable time series is stationary around a
-    deterministic trend. If the computed statistic surpasses the critical value, the null hypothesis is dismissed,
-    inferring the series is non-stationary.
-
-    **Signs of High Risk**:
-    - High KPSS score represents a considerable risk, particularly if the calculated statistic is higher than the
-    critical value.
-    - If the null hypothesis is rejected and the series is recognized as non-stationary, it heavily influences the
-    model's forecasting capability rendering it less effective.
-
-    **Strengths**:
-    - The KPSS test directly measures the stationarity of a series, allowing it to fulfill a key prerequisite for many
-    time-series models, making it a valuable tool for model validation.
-    - The logics underpinning the test are intuitive and simple, making it understandable and accessible for developers
-    and risk management teams.
-
-    **Limitations**:
-    - The KPSS test presumes the absence of a unit root in the series and does not differentiate between series that
-    are stationary and those border-lining stationarity.
-    - The test might show restricted power against specific alternatives.
+    Assesses the stationarity of time-series data in a machine learning model using the KPSS unit root test.
+
+    ### Purpose
+
+    The KPSS (Kwiatkowski-Phillips-Schmidt-Shin) unit root test is utilized to ensure the stationarity of data within a
+    machine learning model. It specifically works on time-series data to establish the order of integration, which is
+    essential for accurate forecasting. A fundamental requirement for any time series model is that the series should
+    be stationary.
+
+    ### Test Mechanism
+
+    This test calculates the KPSS score for each feature in the dataset. The KPSS score includes a statistic, a
+    p-value, a used lag, and critical values. The core principle behind the KPSS test is to evaluate the hypothesis
+    that an observable time series is stationary around a deterministic trend. If the computed statistic exceeds the
+    critical value, the null hypothesis (that the series is stationary) is rejected, indicating that the series is
+    non-stationary.
+
+    ### Signs of High Risk
+
+    - High KPSS score, particularly if the calculated statistic is higher than the critical value.
+    - Rejection of the null hypothesis, indicating that the series is recognized as non-stationary, can severely affect
+    the model's forecasting capability.
+
+    ### Strengths
+
+    - Directly measures the stationarity of a series, fulfilling a key prerequisite for many time-series models.
+    - The underlying logic of the test is intuitive and simple, making it easy to understand and accessible for both
+    developers and risk management teams.
+
+    ### Limitations
+
+    - Assumes the absence of a unit root in the series and doesn't differentiate between series that are stationary and
+    those border-lining stationarity.
+    - The test may have restricted power against certain alternatives.
     - The reliability of the test is contingent on the number of lags selected, which introduces potential bias in the
     measurement.
     """

validmind/tests/data_validation/LaggedCorrelationHeatmap.py

@@ -17,30 +17,37 @@ class LaggedCorrelationHeatmap(Metric):
     Assesses and visualizes correlation between target variable and lagged independent variables in a time-series
     dataset.
 
-    **Purpose**: The LaggedCorrelationHeatmap metric is utilized to appraise and illustrate the correlation between the
-    target variable and delayed copies (lags) of independent variables in a time-series dataset. It assists in
-    revealing relationships in time-series data where the influence of an independent variable on the dependent
-    variable is not immediate but occurs after a period (lags).
-
-    **Test Mechanism**: To execute this test, Python's Pandas library pairs with Plotly to perform computations and
-    present the visualization in the form of a heatmap. The test begins by extracting the target variable and
-    corresponding independent variables from the dataset. Then, generation of lags of independent variables takes
-    place, followed by the calculation of correlation between these lagged variables and the target variable. The
-    outcome is a correlation matrix that gets recorded and illustrated as a heatmap, where different color intensities
-    represent the strength of the correlation, making patterns easier to identify.
-
-    **Signs of High Risk**:
+    ### Purpose
+
+    The LaggedCorrelationHeatmap metric is utilized to appraise and illustrate the correlation between the target
+    variable and delayed copies (lags) of independent variables in a time-series dataset. It assists in revealing
+    relationships in time-series data where the influence of an independent variable on the dependent variable is not
+    immediate but occurs after a period (lags).
+
+    ### Test Mechanism
+
+    To execute this test, Python's Pandas library pairs with Plotly to perform computations and present the
+    visualization in the form of a heatmap. The test begins by extracting the target variable and corresponding
+    independent variables from the dataset. Then, generation of lags of independent variables takes place, followed by
+    the calculation of correlation between these lagged variables and the target variable. The outcome is a correlation
+    matrix that gets recorded and illustrated as a heatmap, where different color intensities represent the strength of
+    the correlation, making patterns easier to identify.
+
+    ### Signs of High Risk
+
     - Insignificant correlations across the heatmap, indicating a lack of noteworthy relationships between variables.
     - Correlations that break intuition or previous understanding, suggesting potential issues with the dataset or the
     model.
 
-    **Strengths**:
+    ### Strengths
+
     - This metric serves as an exceptional tool for exploring and visualizing time-dependent relationships between
     features and the target variable in a time-series dataset.
     - It aids in identifying delayed effects that might go unnoticed with other correlation measures.
     - The heatmap offers an intuitive visual representation of time-dependent correlations and influences.
 
-    **Limitations**:
+    ### Limitations
+
     - The metric presumes linear relationships between variables, potentially ignoring non-linear relationships.
     - The correlation considered is linear; therefore, intricate non-linear interactions might be overlooked.
     - The metric is only applicable for time-series data, limiting its utility outside of this context.

validmind/tests/data_validation/MissingValues.py

@@ -19,34 +19,39 @@ class MissingValues(ThresholdTest):
     """
     Evaluates dataset quality by ensuring missing value ratio across all features does not exceed a set threshold.
 
-    **Purpose**: This test is designed to evaluate the quality of a dataset by measuring the number of missing values
+    ### Purpose
+
+    The Missing Values test is designed to evaluate the quality of a dataset by measuring the number of missing values
     across all features. The objective is to ensure that the ratio of missing data to total data is less than a
-    predefined threshold, defaulting to 1, to maintain the data quality necessary for reliable predictive strength in a
-    machine learning model.
-
-    **Test Mechanism**: The mechanism for this test involves iterating through each column of the dataset, counting
-    missing values (represented as NaNs), and calculating the percentage they represent against the total number of
-    rows. The test then checks if these missing value counts are less than the predefined `min_threshold`. The results
-    are shown in a table summarizing each column, the number of missing values, the percentage of missing values in
-    each column, and a Pass/Fail status based on the threshold comparison.
-
-    **Signs of High Risk**:
-    - When the number of missing values in any column exceeds the `min_threshold` value, it indicates a high risk.
-    - A high risk is also flagged when missing values are present across many columns. In both instances, the test
-    would return a "Fail" mark.
-
-    **Strengths**:
-    - The test offers a quick and granular identification of missing data across each feature in the dataset.
-    - It provides an effective, straightforward means of maintaining data quality, which is vital for constructing
-    efficient machine learning models.
-
-    **Limitations**:
-    - Even though the test can efficiently identify missing values, it does not suggest the root causes of these
-    missing values or recommend ways to impute or handle them.
-    - The test might overlook features with a significant amount of missing data, but still less than the
-    `min_threshold`. This could impact the model, especially if `min_threshold` is set too high.
-    - The test does not account for data encoded as values (like "-999" or "None"), which might not technically
-    classify as missing but could bear similar implications.
+    predefined threshold, defaulting to 1, in order to maintain the data quality necessary for reliable predictive
+    strength in a machine learning model.
+
+    ### Test Mechanism
+
+    The mechanism for this test involves iterating through each column of the dataset, counting missing values
+    (represented as NaNs), and calculating the percentage they represent against the total number of rows. The test
+    then checks if these missing value counts are less than the predefined `min_threshold`. The results are shown in a
+    table summarizing each column, the number of missing values, the percentage of missing values in each column, and a
+    Pass/Fail status based on the threshold comparison.
+
+    ### Signs of High Risk
+
+    - When the number of missing values in any column exceeds the `min_threshold` value.
+    - Presence of missing values across many columns, leading to multiple instances of failing the threshold.
+
+    ### Strengths
+
+    - Quick and granular identification of missing data across each feature in the dataset.
+    - Provides an effective and straightforward means of maintaining data quality, essential for constructing efficient
+    machine learning models.
+
+    ### Limitations
+
+    - Does not suggest the root causes of the missing values or recommend ways to impute or handle them.
+    - May overlook features with significant missing data but still less than the `min_threshold`, potentially
+    impacting the model.
+    - Does not account for data encoded as values like "-999" or "None," which might not technically classify as
+    missing but could bear similar implications.
     """
 
     name = "missing"

validmind/tests/data_validation/MissingValuesBarPlot.py

@@ -12,37 +12,41 @@ from validmind.vm_models import Figure, Metric
 @dataclass
 class MissingValuesBarPlot(Metric):
     """
-    Creates a bar plot showcasing the percentage of missing values in each column of the dataset with risk
-    categorization based on a user-defined threshold.
-
-    **Purpose:** The 'MissingValuesBarPlot' metric provides a color-coded visual representation of the percentage of
-    missing values for each column in an ML model's dataset. The primary purpose of this metric is to easily identify
-    and quantify missing data, which are essential steps in data preprocessing. The presence of missing data can
-    potentially skew the model's predictions and decrease its accuracy. Additionally, this metric uses a pre-set
-    threshold to categorize various columns into ones that contain missing data above the threshold (high risk) and
-    below the threshold (less risky).
-
-    **Test Mechanism:** The test mechanism involves scanning each column in the input dataset and calculating the
-    percentage of missing values. It then compares each column's missing data percentage with the predefined threshold,
-    categorizing columns with missing data above the threshold as high-risk. The test generates a bar plot in which
-    columns with missing data are represented on the y-axis and their corresponding missing data percentages are
-    displayed on the x-axis. The color of each bar reflects the missing data percentage in relation to the threshold:
-    grey for values below the threshold and light coral for those exceeding it. The user-defined threshold is
-    represented by a red dashed line on the plot.
-
-    **Signs of High Risk:**
+    Assesses the percentage and distribution of missing values in the dataset via a bar plot, with emphasis on
+    identifying high-risk columns based on a user-defined threshold.
+
+    ### Purpose
+
+    The 'MissingValuesBarPlot' metric provides a color-coded visual representation of the percentage of missing values
+    for each column in an ML model's dataset. The primary purpose of this metric is to easily identify and quantify
+    missing data, which are essential steps in data preprocessing. The presence of missing data can potentially skew
+    the model's predictions and decrease its accuracy. Additionally, this metric uses a pre-set threshold to categorize
+    various columns into ones that contain missing data above the threshold (high risk) and below the threshold (less
+    risky).
+
+    ### Test Mechanism
+
+    The test mechanism involves scanning each column in the input dataset and calculating the percentage of missing
+    values. It then compares each column's missing data percentage with the predefined threshold, categorizing columns
+    with missing data above the threshold as high-risk. The test generates a bar plot in which columns with missing
+    data are represented on the y-axis and their corresponding missing data percentages are displayed on the x-axis.
+    The color of each bar reflects the missing data percentage in relation to the threshold: grey for values below the
+    threshold and light coral for those exceeding it. The user-defined threshold is represented by a red dashed line on
+    the plot.
+
+    ### Signs of High Risk
 
     - Columns with higher percentages of missing values beyond the threshold are high-risk. These are visually
     represented by light coral bars on the bar plot.
 
-    **Strengths:**
+    ### Strengths
 
     - Helps in quickly identifying and quantifying missing data across all columns of the dataset.
     - Facilitates pattern recognition through visual representation.
     - Enables customization of the level of risk tolerance via a user-defined threshold.
     - Supports both classification and regression tasks, sharing its versatility.
 
-    **Limitations:**
+    ### Limitations
 
     - It only considers the quantity of missing values, not differentiating between different types of missingness
     (Missing completely at random - MCAR, Missing at random - MAR, Not Missing at random - NMAR).

validmind/tests/data_validation/PearsonCorrelationMatrix.py

@@ -2,103 +2,90 @@
 # See the LICENSE file in the root of this repository for details.
 # SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
 
-from dataclasses import dataclass
 
 import plotly.graph_objects as go
 
-from validmind.vm_models import Figure, Metric
+from validmind import tags, tasks
 
 
-@dataclass
-class PearsonCorrelationMatrix(Metric):
+@tags("tabular_data", "numerical_data", "correlation")
+@tasks("classification", "regression")
+def PearsonCorrelationMatrix(dataset):
     """
     Evaluates linear dependency between numerical variables in a dataset via a Pearson Correlation coefficient heat map.
 
-    **Purpose**: This test is intended to evaluate the extent of linear dependency between all pairs of numerical
-    variables in the given dataset. It provides the Pearson Correlation coefficient, which reveals any high
-    correlations present. The purpose of doing this is to identify potential redundancy, as variables that are highly
-    correlated can often be removed to reduce the dimensionality of the dataset without significantly impacting the
-    model's performance.
+    ### Purpose
 
-    **Test Mechanism**: This metric test generates a correlation matrix for all numerical variables in the dataset
-    using the Pearson correlation formula. A heat map is subsequently created to visualize this matrix effectively. The
-    color of each point on the heat map corresponds to the magnitude and direction (positive or negative) of the
-    correlation, with a range from -1 (perfect negative correlation) to 1 (perfect positive correlation). Any
-    correlation coefficients higher than 0.7 (in absolute terms) are indicated in white in the heat map, suggesting a
-    high degree of correlation.
+    This test is intended to evaluate the extent of linear dependency between all pairs of numerical variables in the
+    given dataset. It provides the Pearson Correlation coefficient, which reveals any high correlations present. The
+    purpose of doing this is to identify potential redundancy, as variables that are highly correlated can often be
+    removed to reduce the dimensionality of the dataset without significantly impacting the model's performance.
+
+    ### Test Mechanism
+
+    This metric test generates a correlation matrix for all numerical variables in the dataset using the Pearson
+    correlation formula. A heat map is subsequently created to visualize this matrix effectively. The color of each
+    point on the heat map corresponds to the magnitude and direction (positive or negative) of the correlation, with a
+    range from -1 (perfect negative correlation) to 1 (perfect positive correlation). Any correlation coefficients
+    higher than 0.7 (in absolute terms) are indicated in white in the heat map, suggesting a high degree of correlation.
+
+    ### Signs of High Risk
 
-    **Signs of High Risk**:
     - A large number of variables in the dataset showing a high degree of correlation (coefficients approaching ±1).
     This indicates redundancy within the dataset, suggesting that some variables may not be contributing new
     information to the model.
-    - This could potentially lead to overfitting.
-
-    **Strengths**:
-    - The primary strength of this metric test is its ability to detect and quantify the linearity of relationships
-    between variables. This allows for the identification of redundant variables, which in turn can help in simplifying
-    models and potentially improving their performance.
-    - The visualization aspect (heatmap) is another strength as it offers an easy-to-understand overview of the
-    correlations, beneficial for those not comfortable navigating numerical matrices.
-
-    **Limitations**:
-    - The primary limitation of Pearson Correlation is its inability to detect non-linear relationships between
-    variables, which can lead to missed opportunities for dimensionality reduction.
-    - It only measures the degree of linear relationship and not the strength of effect of one variable on the other.
-    - The cutoff value of 0.7 for high correlation is a somewhat arbitrary choice and some valid dependencies might be
-    missed if they have a correlation coefficient less than this value.
-    """
+    - Potential risk of overfitting.
 
-    name = "pearson_correlation_matrix"
-    required_inputs = ["dataset"]
-    tasks = ["classification", "regression"]
-    tags = ["tabular_data", "numerical_data", "correlation"]
-
-    def run(self):
-        columns = self.params.get("columns", list(self.inputs.dataset.df.columns))
-
-        corr_matrix = self.inputs.dataset.df[columns].corr(numeric_only=True)
-        heatmap = go.Heatmap(
-            z=corr_matrix.values,
-            x=list(corr_matrix.columns),
-            y=list(corr_matrix.index),
-            colorscale="rdbu",
-            zmin=-1,
-            zmax=1,
-        )
-
-        annotations = []
-        for i, row in enumerate(corr_matrix.values):
-            for j, value in enumerate(row):
-                color = "#ffffff" if abs(value) > 0.7 else "#000000"
-                annotations.append(
-                    go.layout.Annotation(
-                        text=str(round(value, 2)),
-                        x=corr_matrix.columns[j],
-                        y=corr_matrix.index[i],
-                        showarrow=False,
-                        font=dict(color=color),
-                    )
-                )
+    ### Strengths
+
+    - Detects and quantifies the linearity of relationships between variables, aiding in identifying redundant
+    variables to simplify models and potentially improve performance.
+    - The heatmap visualization provides an easy-to-understand overview of correlations, beneficial for users not
+    comfortable with numerical matrices.
+
+    ### Limitations
+
+    - Limited to detecting linear relationships, potentially missing non-linear relationships which impede
+    opportunities for dimensionality reduction.
+    - Measures only the degree of linear relationship, not the strength of one variable's effect on another.
+    - The 0.7 correlation threshold is arbitrary and might exclude valid dependencies with lower coefficients.
+    """
 
-        layout = go.Layout(
-            annotations=annotations,
-            xaxis=dict(side="top"),
-            yaxis=dict(scaleanchor="x", scaleratio=1),
-            width=800,
-            height=800,
-            autosize=True,
-            paper_bgcolor="rgba(0,0,0,0)",
-            plot_bgcolor="rgba(0,0,0,0)",
-        )
-
-        fig = go.Figure(data=[heatmap], layout=layout)
-
-        return self.cache_results(
-            figures=[
-                Figure(
-                    for_object=self,
-                    key=self.key,
-                    figure=fig,
+    corr_matrix = dataset.df.corr(numeric_only=True)
+    heatmap = go.Heatmap(
+        z=corr_matrix.values,
+        x=list(corr_matrix.columns),
+        y=list(corr_matrix.index),
+        colorscale="rdbu",
+        zmin=-1,
+        zmax=1,
+    )
+
+    annotations = []
+    for i, row in enumerate(corr_matrix.values):
+        for j, value in enumerate(row):
+            color = "#ffffff" if abs(value) > 0.7 else "#000000"
+            annotations.append(
+                go.layout.Annotation(
+                    text=str(round(value, 2)),
+                    x=corr_matrix.columns[j],
+                    y=corr_matrix.index[i],
+                    showarrow=False,
+                    font=dict(color=color),
                 )
-            ]
-        )
+            )
+
+    layout = go.Layout(
+        annotations=annotations,
+        xaxis=dict(side="top"),
+        yaxis=dict(scaleanchor="x", scaleratio=1),
+        width=800,
+        height=800,
+        autosize=True,
+        paper_bgcolor="rgba(0,0,0,0)",
+        plot_bgcolor="rgba(0,0,0,0)",
+    )
+
+    fig = go.Figure(data=[heatmap], layout=layout)
+
+    return fig