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

validmind/tests/model_validation/embeddings/CosineSimilarityDistribution.py

@@ -13,32 +13,34 @@ class CosineSimilarityDistribution(Metric):
     Assesses the similarity between predicted text embeddings from a model using a Cosine Similarity distribution
     histogram.
 
-    **Purpose:**
+    ### Purpose
+
     This metric is used to assess the degree of similarity between the embeddings produced by a text embedding model
     using Cosine Similarity. Cosine Similarity is a measure that calculates the cosine of the angle between two
     vectors. This metric is predominantly used in text analysis — in this case, to determine how closely the predicted
     text embeddings align with one another.
 
-    **Test Mechanism:**
+    ### Test Mechanism
+
     The implementation starts by computing the cosine similarity between the predicted values of the model's test
     dataset. These cosine similarity scores are then plotted on a histogram with 100 bins to visualize the distribution
     of the scores. The x-axis of the histogram represents the computed Cosine Similarity.
 
-    **Signs of High Risk:**
+    ### Signs of High Risk
 
     - If the cosine similarity scores cluster close to 1 or -1, it may indicate overfitting, as the model's predictions
     are almost perfectly aligned. This could suggest that the model is not generalizable.
     - A broad spread of cosine similarity scores across the histogram may indicate a potential issue with the model's
     ability to generate consistent embeddings.
 
-    **Strengths:**
+    ### Strengths
 
     - Provides a visual representation of the model's performance which is easily interpretable.
     - Can help identify patterns, trends, and outliers in the model's alignment of predicted text embeddings.
     - Useful in measuring the similarity between vectors in multi-dimensional space, important in the case of text
     embeddings.
 
-    **Limitations:**
+    ### Limitations
 
     - Only evaluates the similarity between outputs. It does not provide insight into the model's ability to correctly
     classify or predict.

validmind/tests/model_validation/embeddings/CosineSimilarityHeatmap.py

@@ -23,33 +23,42 @@ def CosineSimilarityHeatmap(
     """
     Generates an interactive heatmap to visualize the cosine similarities among embeddings derived from a given model.
 
-    **Purpose:**
-    This function is designed to visually analyze the cosine similarities of embeddings from a specific model.
-    Cosine similarity, a measure of the cosine of the angle between two vectors, aids in understanding the
-    orientation and similarity of vectors in multi-dimensional space. This is particularly valuable for exploring
-    text embeddings and their relative similarities among documents, words, or phrases.
-
-    **Test Mechanism:**
-    The function operates through a sequence of steps to visualize cosine similarities. Initially,
-    embeddings are extracted for each dataset entry using the designated model. Following this,
-    the function computes the pairwise cosine similarities among these embeddings. The computed similarities
-    are then displayed in an interactive heatmap.
-
-    **Signs of High Risk:**
-    - High similarity values (close to 1) across the heatmap might not always be indicative of a risk;
-    however, in contexts where diverse perspectives or features are desired, this could suggest a lack of
-    diversity in the model's learning process or potential redundancy.
+    ### Purpose
+
+    This function is designed to visually analyze the cosine similarities of embeddings from a specific model. Cosine
+    similarity, a measure of the cosine of the angle between two vectors, aids in understanding the orientation and
+    similarity of vectors in multi-dimensional space. This is particularly valuable for exploring text embeddings and
+    their relative similarities among documents, words, or phrases.
+
+    ### Test Mechanism
+
+    The function operates through a sequence of steps to visualize cosine similarities. Initially, embeddings are
+    extracted for each dataset entry using the designated model. Following this, the function computes the pairwise
+    cosine similarities among these embeddings. The computed similarities are then displayed in an interactive heatmap.
+
+    ### Signs of High Risk
+
+    - High similarity values (close to 1) across the heatmap might not always be indicative of a risk; however, in
+    contexts where diverse perspectives or features are desired, this could suggest a lack of diversity in the model's
+    learning process or potential redundancy.
     - Similarly, low similarity values (close to -1) indicate strong dissimilarity, which could be beneficial in
     scenarios demanding diverse outputs. However, in cases where consistency is needed, these low values might
-    highlight that the model is unable to capture a coherent set of features from the data, potentially leading to poor performance on related tasks.
+    highlight that the model is unable to capture a coherent set of features from the data, potentially leading to poor
+    performance on related tasks.
+
+    ### Strengths
+
+    - Provides an interactive and intuitive visual representation of embedding similarities, facilitating easy
+    exploration and analysis.
+    - Allows customization of visual elements such as title, axis labels, and color scale to suit specific analytical
+    needs and preferences.
 
-    **Strengths:**
-    - Provides an interactive and intuitive visual representation of embedding similarities, facilitating easy exploration and analysis.
-    - Allows customization of visual elements such as title, axis labels, and color scale to suit specific analytical needs and preferences.
+    ### Limitations
 
-    **Limitations:**
-    - As the number of embeddings increases, the effectiveness of the heatmap might diminish due to overcrowding, making it hard to discern detailed similarities.
-    - The interpretation of the heatmap heavily relies on the appropriate setting of the color scale, as incorrect settings can lead to misleading visual interpretations.
+    - As the number of embeddings increases, the effectiveness of the heatmap might diminish due to overcrowding,
+    making it hard to discern detailed similarities.
+    - The interpretation of the heatmap heavily relies on the appropriate setting of the color scale, as incorrect
+    settings can lead to misleading visual interpretations.
     """
 
     embeddings = np.stack(dataset.y_pred(model))

validmind/tests/model_validation/embeddings/DescriptiveAnalytics.py

@@ -13,26 +13,28 @@ class DescriptiveAnalytics(Metric):
     Evaluates statistical properties of text embeddings in an ML model via mean, median, and standard deviation
     histograms.
 
-    **1. Purpose:**
+    ### Purpose
+
     This metric, Descriptive Analytics for Text Embeddings Models, is employed to comprehend the fundamental properties
     and statistical characteristics of the embeddings in a Machine Learning model. It measures the dimensionality as
     well as the statistical distributions of embedding values including the mean, median, and standard deviation.
 
-    **2. Test Mechanism:**
+    ### Test Mechanism
+
     The test mechanism involves using the 'DescriptiveAnalytics' class provided in the code which includes the 'run'
     function. This function computes three statistical measures - mean, median, and standard deviation of the test
     predictions from the model. It generates and caches three separate histograms showing the distribution of these
     measures. Each histogram visualizes the measure's distribution across the embedding values. Therefore, the method
     does not utilize a grading scale or threshold; it is fundamentally a visual exploration and data exploration tool.
 
-    **3. Signs of High Risk:**
+    ### Signs of High Risk
 
     - Abnormal patterns or values in the distributions of the statistical measures. This may include skewed
     distributions or a significant amount of outliers.
     - Very high standard deviation values which indicate a high degree of variability in the data.
     - The mean and median values are vastly different, suggesting skewed data.
 
-    **4. Strengths:**
+    ### Strengths
 
     - Provides a visual and quantifiable understanding of the embeddings' statistical characteristics, allowing for a
     comprehensive evaluation.
@@ -41,7 +43,7 @@ class DescriptiveAnalytics(Metric):
     - It considers three key statistical measures (mean, median, and standard deviation), offering a more well-rounded
     understanding of the data.
 
-    **5. Limitations:**
+    ### Limitations
 
     - The method does not offer an explicit measure of model performance or accuracy, as it mainly focuses on
     understanding data properties.

validmind/tests/model_validation/embeddings/EmbeddingsVisualization2D.py

@@ -12,24 +12,28 @@ class EmbeddingsVisualization2D(Metric):
     """
     Visualizes 2D representation of text embeddings generated by a model using t-SNE technique.
 
-    **1. Purpose:** The objective of this metric is to provide a visual 2D representation of the embeddings created by
-    a text embedding machine learning model. By doing so, it aids in analyzing the embedding space created by the model
-    and helps in understanding how the learned embeddings are distributed and how they relate to each other.
+    ### Purpose
 
-    **2. Test Mechanism:** This metric uses the t-Distributed Stochastic Neighbor Embedding (t-SNE) technique, which is
-    a tool for visualizing high-dimensional data by reducing the dimensionality to 2. The perplexity parameter for
-    t-SNE is set to the value provided by the user. If the input perplexity value is greater than the number of
-    samples, the perplexity is adjusted to be one less than the number of samples. Following the reduction of
-    dimensionality, a scatter plot is produced depicting each embedding as a data point in the visualized 2D plane.
+    The objective of this metric is to provide a visual 2D representation of the embeddings created by a text embedding
+    machine learning model. By doing so, it aids in analyzing the embedding space created by the model and helps in
+    understanding how the learned embeddings are distributed and how they relate to each other.
 
-    **3. Signs of High Risk:**
+    ### Test Mechanism
+
+    This metric uses the t-Distributed Stochastic Neighbor Embedding (t-SNE) technique, which is a tool for visualizing
+    high-dimensional data by reducing the dimensionality to 2. The perplexity parameter for t-SNE is set to the value
+    provided by the user. If the input perplexity value is greater than the number of samples, the perplexity is
+    adjusted to be one less than the number of samples. Following the reduction of dimensionality, a scatter plot is
+    produced depicting each embedding as a data point in the visualized 2D plane.
+
+    ### Signs of High Risk
 
     - If the embeddings are highly concentrated in a specific region of the plane, it might indicate that the model is
     not learning diverse representations of the text.
     - Wide gaps or partitions in the visualization could suggest that the model is over-segmenting in the embedding
     space and may lead to poor generalization.
 
-    **4. Strengths:**
+    ### Strengths
 
     - Offers a powerful visual tool that can assist in understanding and interpreting high-dimensional embeddings,
     which could otherwise be difficult to visualize.
@@ -37,7 +41,7 @@ class EmbeddingsVisualization2D(Metric):
     - t-SNE visualization helps in focusing on local structures and preserves the proximity of points that are close
     together in the original high-dimensional space.
 
-    **5. Limitations:**
+    ### Limitations
 
     - The reduction of high-dimensional data to 2D can result in loss of some information, which may lead to
     misinterpretation.

validmind/tests/model_validation/embeddings/EuclideanDistanceComparison.py

@@ -16,41 +16,41 @@ from validmind import tags, tasks
 @tasks("text_qa", "text_generation", "text_summarization")
 def EuclideanDistanceComparison(dataset, models):
     """
-    Computes pairwise Euclidean distances between model embeddings and visualizes the results through bar charts,
-    alongside compiling a comprehensive table of descriptive statistics for each model pair.
-
-    **Purpose:**
-    This function is designed to analyze and compare the embeddings produced by different models using Euclidean Distance.
-    Euclidean Distance measures the "ordinary" straight-line distance between two points in Euclidean space, providing a
-    straightforward metric to assess the absolute differences between vectors. This analysis helps in understanding the
-    magnitude of dissimilarity between the embeddings generated by different models, which is crucial for tasks that require
-    distinctive model responses or feature separations.
-
-    **Test Mechanism:**
-    The function begins by computing the embeddings for each model using the provided dataset. It then calculates the
-    Euclidean distance for every possible pair of models, generating a distance matrix. Each element of this matrix
-    represents the Euclidean distance between two model embeddings. The function flattens this matrix and uses it to
-    create a bar chart for each model pair, visualizing their distance distribution. Additionally, it compiles a table
-    with descriptive statistics (mean, median, standard deviation, minimum, and maximum) for the distances of each
-    pair, including a reference to the compared models.
-
-    **Signs of High Risk:**
-
-    - Very high distance values could suggest that the models are focusing on completely different features or aspects
-      of the data, which might be undesirable for ensemble methods or similar applications where some degree of
-      consensus is expected.
-    - Extremely low distances across different models might indicate redundancy, suggesting that the models are not
-      providing diverse enough perspectives on the data.
-
-    **Strengths:**
+    Assesses and visualizes the dissimilarity between model embeddings using Euclidean distance, providing insights
+    into model behavior and potential redundancy or diversity.
+
+    ### Purpose
+
+    The Euclidean Distance Comparison test aims to analyze and compare the embeddings produced by different models. By
+    measuring the Euclidean distance between vectors in Euclidean space, it provides a metric to assess the magnitude
+    of dissimilarity between embeddings created by different models. This is crucial for tasks that require models to
+    produce distinct responses or feature separations.
+
+    ### Test Mechanism
+
+    The test computes the embeddings for each model using the provided dataset and calculates the Euclidean distance
+    for every possible pair of models. It generates a distance matrix where each element represents the Euclidean
+    distance between two model embeddings. This matrix is then visualized through bar charts, showing the distance
+    distribution for each model pair. Additionally, it compiles a table with descriptive statistics such as mean,
+    median, standard deviation, minimum, and maximum distances for each model pair, including references to the
+    compared models.
+
+    ### Signs of High Risk
+
+    - Very high distance values could suggest that models are focusing on entirely different features or aspects of the
+    data, which might be undesirable for ensemble methods or when a consensus is required.
+    - Extremely low distances across different models might indicate redundancy, suggesting that models are not
+    providing diverse enough perspectives on the data.
+
+    ### Strengths
 
     - Provides a clear and quantifiable measure of how different the embeddings from various models are.
     - Useful for identifying outlier models or those that behave significantly differently from others in a group.
 
-    **Limitations:**
+    ### Limitations
 
     - Euclidean distance can be sensitive to the scale of the data, meaning that preprocessing steps like normalization
-      might be necessary to ensure meaningful comparisons.
+    might be necessary to ensure meaningful comparisons.
     - Does not consider the orientation or angle between vectors, focusing purely on magnitude differences.
     """
 

validmind/tests/model_validation/embeddings/EuclideanDistanceHeatmap.py

@@ -23,31 +23,40 @@ def EuclideanDistanceHeatmap(
     """
     Generates an interactive heatmap to visualize the Euclidean distances among embeddings derived from a given model.
 
-    **Purpose:**
-    This function visualizes the Euclidean distances between embeddings generated by a model, offering insights into the
-    absolute differences between data points. Euclidean distance, a fundamental metric in data analysis, measures the
-    straight-line distance between two points in Euclidean space. It is particularly useful for understanding spatial
-    relationships and clustering tendencies in high-dimensional data.
-
-    **Test Mechanism:**
-    The function operates through a streamlined process: firstly, embeddings are extracted for each dataset entry using the specified model.
-    Subsequently, it computes the pairwise Euclidean distances among these embeddings. The results are then visualized in an interactive heatmap format,
-    where each cell's color intensity correlates with the distance magnitude between pairs of embeddings, providing a visual assessment of these distances.
-
-    **Signs of High Risk:**
-    - Uniform Distances: Uniformly low distances across the heatmap might suggest a lack of variability in the data or
-    model overfitting, where the model fails to distinguish between distinct data points effectively.
-    - High Variability: Conversely, excessive variability in distances could indicate inconsistent data representation,
-    potentially leading to unreliable model predictions.
-
-    **Strengths:**
-    - Provides a direct, intuitive visual representation of distances between embeddings, aiding in the detection of patterns or anomalies.
-    - Allows customization of visual aspects such as the heatmap's title, axis labels, and color scale, adapting to various analytical needs.
-
-    **Limitations:**
-    - The interpretation of distances can be sensitive to the scale of data; normalization might be necessary for meaningful analysis.
-    - Large datasets may lead to dense, cluttered heatmaps, making it difficult to discern individual distances, potentially requiring
-    techniques like data sampling or dimensionality reduction for clearer visualization.
+    ### Purpose
+
+    This function visualizes the Euclidean distances between embeddings generated by a model, offering insights into
+    the absolute differences between data points. Euclidean distance, a fundamental metric in data analysis, measures
+    the straight-line distance between two points in Euclidean space. It is particularly useful for understanding
+    spatial relationships and clustering tendencies in high-dimensional data.
+
+    ### Test Mechanism
+
+    The function operates through a streamlined process: firstly, embeddings are extracted for each dataset entry using
+    the specified model. Subsequently, it computes the pairwise Euclidean distances among these embeddings. The results
+    are then visualized in an interactive heatmap format, where each cell's color intensity correlates with the
+    distance magnitude between pairs of embeddings, providing a visual assessment of these distances.
+
+    ### Signs of High Risk
+
+    - Uniformly low distances across the heatmap might suggest a lack of variability in the data or model overfitting,
+    where the model fails to distinguish between distinct data points effectively.
+    - Excessive variability in distances could indicate inconsistent data representation, potentially leading to
+    unreliable model predictions.
+
+    ### Strengths
+
+    - Provides a direct, intuitive visual representation of distances between embeddings, aiding in the detection of
+    patterns or anomalies.
+    - Allows customization of visual aspects such as the heatmap's title, axis labels, and color scale, adapting to
+    various analytical needs.
+
+    ### Limitations
+
+    - The interpretation of distances can be sensitive to the scale of data; normalization might be necessary for
+    meaningful analysis.
+    - Large datasets may lead to dense, cluttered heatmaps, making it difficult to discern individual distances,
+    potentially requiring techniques like data sampling or dimensionality reduction for clearer visualization.
     """
 
     embeddings = np.stack(dataset.y_pred(model))

validmind/tests/model_validation/embeddings/PCAComponentsPairwisePlots.py

@@ -17,32 +17,44 @@ from validmind import tags, tasks
 @tasks("text_qa", "text_generation", "text_summarization")
 def PCAComponentsPairwisePlots(dataset, model, n_components=3):
     """
-    Generates scatter plots for pairwise combinations of principal component analysis (PCA) components of model embeddings.
-
-    **Purpose:**
-    This function visualizes the principal components of embeddings derived from a specified model. Principal Component Analysis (PCA)
-    is a statistical technique that emphasizes variation and uncovers strong patterns in a dataset.
-    It transforms the original variables into new, uncorrelated variables (principal components) that maximize variance.
-
-    **Test Mechanism:**
-    The function follows a sequential process to visualize PCA components effectively.
-    It starts by extracting embeddings from the dataset, utilizing the model specified by the user.
-    These embeddings are then standardized to ensure zero mean and unit variance, which is crucial to prevent
-    any single feature from dominating due to scale—this standardization is a critical preprocessing step for PCA.
-    Following this, the function calculates the specified number of principal components.
-    The core of the visualization process involves creating scatter plots for each pairwise combination of these principal components.
-
-    **Signs of High Risk:**
-    - If the principal components do not account for a significant portion of the variance, it may suggest that PCA is not capturing the essential structures of the data.
-    - Similarity in scatter plots across different pairs of components could indicate redundancy in the components, suggesting that fewer dimensions might be sufficient to represent the data.
-
-    **Strengths:**
-    - Enables a simplified visualization of multivariate data, helping to identify patterns across many variables effectively.
-    - Provides a clear depiction of the directions of maximum variance in the data, which is valuable for feature selection and dimensionality reduction.
-
-    **Limitations:**
-    - PCA's effectiveness hinges on the scaling of the variables; improper standardization can lead to misleading interpretations.
-    - The interpretation of principal components can be challenging, especially if they capture less significant variances or are difficult to relate back to the original features.
+    Generates scatter plots for pairwise combinations of principal component analysis (PCA) components of model
+    embeddings.
+
+    ### Purpose
+
+    This function visualizes the principal components of embeddings derived from a specified model. Principal Component
+    Analysis (PCA) is a statistical technique that emphasizes variation and uncovers strong patterns in a dataset. It
+    transforms the original variables into new, uncorrelated variables (principal components) that maximize variance.
+
+    ### Test Mechanism
+
+    The function follows a sequential process to visualize PCA components effectively. It starts by extracting
+    embeddings from the dataset, utilizing the model specified by the user. These embeddings are then standardized to
+    ensure zero mean and unit variance, which is crucial to prevent any single feature from dominating due to
+    scale—this standardization is a critical preprocessing step for PCA. Following this, the function calculates the
+    specified number of principal components. The core of the visualization process involves creating scatter plots for
+    each pairwise combination of these principal components.
+
+    ### Signs of High Risk
+
+    - If the principal components do not account for a significant portion of the variance, it may suggest that PCA is
+    not capturing the essential structures of the data.
+    - Similarity in scatter plots across different pairs of components could indicate redundancy in the components,
+    suggesting that fewer dimensions might be sufficient to represent the data.
+
+    ### Strengths
+
+    - Enables a simplified visualization of multivariate data, helping to identify patterns across many variables
+    effectively.
+    - Provides a clear depiction of the directions of maximum variance in the data, which is valuable for feature
+    selection and dimensionality reduction.
+
+    ### Limitations
+
+    - PCA's effectiveness hinges on the scaling of the variables; improper standardization can lead to misleading
+    interpretations.
+    - The interpretation of principal components can be challenging, especially if they capture less significant
+    variances or are difficult to relate back to the original features.
     """
 
     # Get embeddings from the dataset using the model

validmind/tests/model_validation/embeddings/StabilityAnalysis.py

@@ -23,7 +23,46 @@ logger = get_logger(__name__)
 
 
 class StabilityAnalysis(ThresholdTest):
-    """Base class for embeddings stability analysis tests"""
+    """
+     Assesses the stability of embeddings generated by a model when faced with perturbed input data to ensure robustness
+    and consistency.
+
+    ### Purpose
+
+    The Embedding Stability test evaluates the robustness of the embeddings generated by a model when the input text is
+    perturbed. By comparing the cosine similarities between the original and perturbed embeddings, it gauges the
+    model's ability to maintain consistent semantic representations under slight variations in the input data.
+
+    ### Test Mechanism
+
+    This test works by:
+
+    - Perturbing the original text data.
+    - Generating embeddings for both the original and perturbed datasets using the model.
+    - Calculating the cosine similarities between the original and perturbed embeddings.
+    - Analyzing the distribution of these similarities (mean, min, max, median, and standard deviation).
+    - Determining the test result based on whether the mean similarity exceeds a predefined threshold (default is 0.7).
+
+    ### Signs of High Risk
+
+    - Mean cosine similarity below the threshold (default is 0.7).
+    - Large standard deviation of cosine similarities, indicating inconsistency.
+    - Minimum similarity score significantly lower than expected.
+    - Failure to pass the threshold test based on the mean similarity.
+
+    ### Strengths
+
+    - Provides a quantitative measure of embedding stability.
+    - Helps in identifying weaknesses in the model's ability to handle minor input variations.
+    - Visualization of similarity distributions aids in comprehensive analysis.
+    - Easy to interpret results with clear pass/fail criteria.
+
+    ### Limitations
+
+    - Relies on the chosen perturbation method, which may not cover all possible variations in real-world data.
+    - Thresholds for similarity might need adjustment based on specific application requirements.
+    - Cosine similarity, while useful, may not capture all aspects of semantic stability.
+    """
 
     required_inputs = ["model", "dataset"]
     default_params = {

validmind/tests/model_validation/embeddings/StabilityAnalysisKeyword.py

@@ -9,37 +9,38 @@ from .StabilityAnalysis import StabilityAnalysis
 
 class StabilityAnalysisKeyword(StabilityAnalysis):
     """
-    Evaluate robustness of embeddings models to keyword swaps on the test dataset
+    Evaluates robustness of embedding models to keyword swaps in the test dataset.
 
-    This tests expects a parameter `keyword_dict` that maps words to other words
-    so that any instances of the key words in the test dataset will be replaced
-    with the corresponding value.
+    ### Purpose
 
-    **Purpose:**
-    This test metric is used to evaluate the robustness of text embedding machine learning models to
-    keyword swaps. A keyword swap is a scenario where instances of certain specified keywords in the dataset are
-    replaced with other specified words (usually synonyms). The purpose of this metric is to ensure that these models
-    maintain performance stability even when the input data slightly deviates, imitating real-world variability.
+    This test metric is used to evaluate the robustness of text embedding machine learning models to keyword swaps. A
+    keyword swap is a scenario where instances of certain specified keywords in the dataset are replaced with other
+    specified words (usually synonyms). The purpose of this metric is to ensure that these models maintain performance
+    stability even when the input data slightly deviates, imitating real-world variability.
 
-    **Test Mechanism:**
-    The test mechanism involves perturbation of the dataset used in testing the model. Each
-    instance of a specific word found in the dataset is replaced with the corresponding word as specified in a
-    'keyword_dict' mapping. The model is then re-run with the perturbed dataset and the results are compared with the
-    non-perturbed dataset. This comparison quantifies the extent to which keyword swaps impact the model's performance.
+    ### Test Mechanism
+
+    The test mechanism involves a perturbation of the dataset used in testing the model. Each instance of a specific
+    word found in the dataset is replaced with the corresponding word as specified in a 'keyword_dict' mapping. The
+    model is then re-run with the perturbed dataset and the results are compared with the non-perturbed dataset. This
+    comparison quantifies the extent to which keyword swaps impact the model's performance.
+
+    ### Signs of High Risk
 
-    **Signs of High Risk:**
     - A significant drop in model performance after keyword swaps indicates a high risk of model failure in real-world
     scenarios.
     - The model results being heavily reliant on specific word choices instead of capturing the context properly.
 
-    **Strengths:**
+    ### Strengths
+
     - This test provides a way to measure model robustness to small changes in input data, which reinforces its
     applicability and reliability in real-world scenarios.
     - This test encourages a model to understand the context of a sentence rather than memorizing specific words.
     - It helps to detect overfitting - a situation where a model performs well on training data but poorly on new or
     slightly altered data.
 
-    **Limitations:**
+    ### Limitations
+
     - It may not fully address semantic differences that can be introduced through keyword swaps. That is, the
     replacement words might not preserve the exact semantic meaning of the original words.
     - It only tests for changes in keywords (word-level alterations) and might not expose model limitations related to