Bias & Explainability

class SageMakerClarifyProcessor:
    """
    SageMaker Clarify processor for bias and explainability.

    Parameters:
        role: str - IAM role ARN (required)
            - Needs: sagemaker:CreateProcessingJob, s3:GetObject, s3:PutObject
        instance_count: int - Number of instances (default: 1)
        instance_type: str - EC2 instance type (required)
        volume_size_in_gb: int - EBS volume size (default: 30)
        volume_kms_key: Optional[str] - KMS key for volume encryption
        output_kms_key: Optional[str] - KMS key for output encryption
        max_runtime_in_seconds: Optional[int] - Maximum runtime (default: 3600)
        sagemaker_session: Optional[Session] - SageMaker session
        env: Optional[Dict[str, str]] - Environment variables
        tags: Optional[List[Tag]] - Resource tags
        network_config: Optional[NetworkConfig] - Network configuration

    Methods:
        run_pre_training_bias(data_config, bias_config, output_config, methods="all", 
                              wait=True, logs=True, job_name=None) -> None
            Run pre-training bias analysis.
            
            Parameters:
                data_config: DataConfig - Data configuration (required)
                bias_config: BiasConfig - Bias configuration (required)
                output_config: DataConfig - Output configuration (required)
                methods: Union[str, List[str]] - Bias metrics (default: "all")
                    - "all": Run all applicable metrics
                    - List: ["CI", "DPL", "KL", "JS", "LP", "TVD", "KS", "CDDL"]
                wait: bool - Block until completion (default: True)
                logs: bool - Show logs (default: True)
                job_name: Optional[str] - Custom job name
            
            Raises:
                ValueError: Invalid configuration
                ClientError: AWS API errors
        
        run_post_training_bias(data_config, data_bias_config, model_config, 
                               model_predicted_label_config, output_config, 
                               methods="all", wait=True, logs=True, job_name=None) -> None
            Run post-training bias analysis.
            
            Parameters:
                data_config: DataConfig - Data configuration (required)
                data_bias_config: BiasConfig - Bias configuration (required)
                model_config: ModelConfig - Model configuration (required)
                model_predicted_label_config: ModelPredictedLabelConfig - Prediction config (required)
                output_config: DataConfig - Output configuration (required)
                methods: Union[str, List[str]] - Bias metrics (default: "all")
                    - "all": Run all applicable metrics
                    - List: ["DI", "DCR", "RD", "DAR", "DRR", "AD", "CDDL", "TE", "FT"]
                wait: bool - Block until completion (default: True)
                logs: bool - Show logs (default: True)
                job_name: Optional[str] - Custom job name
            
            Raises:
                ValueError: Invalid configuration
                ClientError: AWS API errors
        
        run_explainability(data_config, model_config, explainability_config, 
                          output_config, wait=True, logs=True, job_name=None) -> None
            Run explainability analysis.
            
            Parameters:
                data_config: DataConfig - Data configuration (required)
                model_config: ModelConfig - Model configuration (required)
                explainability_config: SHAPConfig - SHAP configuration (required)
                output_config: DataConfig - Output configuration (required)
                wait: bool - Block until completion (default: True)
                logs: bool - Show logs (default: True)
                job_name: Optional[str] - Custom job name
            
            Raises:
                ValueError: Invalid configuration
                ClientError: AWS API errors
        
        run_bias_and_explainability(data_config, bias_config, model_config, 
                                    explainability_config, model_predicted_label_config, 
                                    output_config, pre_training_methods=None, 
                                    post_training_methods=None, wait=True, logs=True, 
                                    job_name=None) -> None
            Run combined bias and explainability analysis.
            
            Parameters:
                data_config: DataConfig - Data configuration (required)
                bias_config: BiasConfig - Bias configuration (required)
                model_config: ModelConfig - Model configuration (required)
                explainability_config: SHAPConfig - SHAP config (required)
                model_predicted_label_config: ModelPredictedLabelConfig - Prediction config (required)
                output_config: DataConfig - Output configuration (required)
                pre_training_methods: Optional[List[str]] - Pre-training bias metrics
                post_training_methods: Optional[List[str]] - Post-training bias metrics
                wait: bool - Block until completion (default: True)
                logs: bool - Show logs (default: True)
                job_name: Optional[str] - Custom job name

    Usage:
        Analyze models for bias and generate explanations.
    
    Notes:
        - Pre-training bias: analyze training data for bias
        - Post-training bias: analyze model predictions for bias
        - Explainability: SHAP values for feature importance
        - Combined analysis more efficient than separate runs
        - Results in JSON and CSV formats
    """

from sagemaker.core.clarify import SageMakerClarifyProcessor

# Create Clarify processor
clarify_processor = SageMakerClarifyProcessor(
    role="arn:aws:iam::123456789012:role/SageMakerRole",
    instance_count=1,
    instance_type="ml.m5.xlarge",
    volume_size_in_gb=30
)

class DataConfig:
    """
    Data configuration for Clarify analysis.

    Parameters:
        s3_data_input_path: str - S3 URI for input data (required)
        s3_output_path: str - S3 URI for output (required)
        label: Optional[Union[str, int]] - Label column name or index
            - Column name (if headers provided)
            - Zero-based index (if no headers)
        headers: Optional[List[str]] - Column headers
            - Must match data columns
        features: Optional[str] - Features column name
            - For nested JSON structures
        dataset_type: str - Dataset type (required)
            - "text/csv": CSV data
            - "application/jsonlines": JSON Lines
            - "application/x-parquet": Parquet
        s3_data_distribution_type: str - Distribution type (default: "FullyReplicated")
            - "FullyReplicated": Copy to all instances
            - "ShardedByS3Key": Distribute across instances
        s3_compression_type: str - Compression type (default: "None")
            - "None" or "Gzip"
        joinsource: Optional[str] - Join source for predictions
            - "Input": Join predictions with input
        facet_dataset_uri: Optional[str] - Facet dataset S3 URI
            - Separate dataset with protected attributes

    Usage:
        Configure input/output data for Clarify analysis.
        Supports CSV, JSON Lines, and Parquet formats.
    
    Notes:
        - Headers required for named column access
        - Label column needed for supervised bias metrics
        - Facet dataset for privacy-preserving analysis
    """

from sagemaker.core.clarify import DataConfig

# CSV data configuration
data_config = DataConfig(
    s3_data_input_path="s3://my-bucket/input-data.csv",
    s3_output_path="s3://my-bucket/clarify-output",
    label="target",  # Label column name
    headers=[
        "age", "workclass", "education", "marital_status",
        "occupation", "race", "gender", "target"
    ],
    dataset_type="text/csv"
)

# JSON Lines configuration
json_config = DataConfig(
    s3_data_input_path="s3://bucket/data.jsonl",
    s3_output_path="s3://bucket/output",
    features="features",  # Nested features field
    label="label",
    dataset_type="application/jsonlines"
)

class BiasConfig:
    """
    Bias configuration for fairness analysis.

    Parameters:
        label_values_or_threshold: Union[List, float] - Positive label values or threshold (required)
            - List: Positive label values (classification)
            - Float: Threshold for positive class (regression/probability)
        facet_name: Union[str, int, List] - Facet column name(s) or index (required)
            - Column name(s): Protected attribute(s)
            - Index: Zero-based column index
            - List: Multiple facets
        facet_values_or_threshold: Optional[Union[List, float]] - Facet values or threshold
            - List: Reference group values
            - Float: Threshold for facet binarization
        group_name: Optional[str] - Group column name
            - For grouped analysis

    Pre-Training Metrics:
        - CI (Class Imbalance): Imbalance in positive outcomes
        - DPL (Difference in Positive Proportions in Labels): Facet vs reference group
        - KL (Kullback-Leibler Divergence): Distribution divergence
        - JS (Jensen-Shannon Divergence): Symmetric distribution divergence
        - LP (Lp-norm): Distance between distributions
        - TVD (Total Variation Distance): Statistical distance
        - KS (Kolmogorov-Smirnov): Distribution difference
        - CDDL (Conditional Demographic Disparity in Labels): Conditional disparity

    Post-Training Metrics:
        - DI (Disparate Impact): Ratio of positive prediction rates
        - DCR (Difference in Conditional Rejection): Rejection rate difference
        - RD (Recall Difference): Recall difference between facets
        - DAR (Difference in Acceptance Rates): Acceptance rate difference
        - DRR (Difference in Rejection Rates): Rejection rate difference
        - AD (Accuracy Difference): Accuracy difference
        - CDDL (Conditional Demographic Disparity in Labels): Conditional disparity
        - TE (Treatment Equality): False positive/negative rate difference
        - FT (Flip Test): Prediction stability under facet change

    Usage:
        Define sensitive attributes and fairness criteria.
        Reference group compared against disadvantaged group.
    
    Notes:
        - Facet: protected attribute (gender, race, age, etc.)
        - Reference group: typically privileged group
        - Positive outcome: favorable prediction (hire, approve, etc.)
        - Multiple facets enable intersectional analysis
    """

from sagemaker.core.clarify import BiasConfig

# Binary classification bias config
bias_config = BiasConfig(
    label_values_or_threshold=[1],  # 1 is positive outcome
    facet_name="gender",  # Protected attribute
    facet_values_or_threshold=[0],  # 0 is reference group (e.g., male)
    group_name="age_group"  # Optional grouping
)

# Regression with threshold
regression_bias_config = BiasConfig(
    label_values_or_threshold=0.5,  # Threshold for positive
    facet_name="race",
    facet_values_or_threshold=[0, 1]  # Multiple reference groups
)

# Multiple facets (intersectional bias)
intersectional_config = BiasConfig(
    label_values_or_threshold=[1],
    facet_name=["gender", "race"],  # Intersectional analysis
    facet_values_or_threshold=[[0], [0]]  # Reference for each facet
)

class ModelConfig:
    """
    Model configuration for Clarify analysis.

    Parameters:
        model_name: str - SageMaker model name (required)
        instance_type: str - Instance type for model (required)
        instance_count: int - Number of instances (default: 1)
        content_type: str - Request content type (required)
            - Example: "text/csv", "application/json"
        accept_type: str - Response accept type (required)
            - Example: "application/json"
        endpoint_name_prefix: Optional[str] - Prefix for temporary endpoint
            - Clarify creates temporary endpoint for analysis
        content_template: Optional[str] - Content template for requests
            - JSON template with $features placeholder
        record_template: Optional[str] - Record template
        label_headers: Optional[List[str]] - Label headers in response
            - For multiclass classification

    Usage:
        Configure model for inference during Clarify analysis.
        Temporary endpoint created and deleted automatically.
    
    Notes:
        - Temporary endpoint incurs inference costs
        - Instance type should match production for accurate analysis
        - Content template for custom input format
    """

from sagemaker.core.clarify import ModelConfig

# Simple model config
model_config = ModelConfig(
    model_name="my-model",
    instance_type="ml.m5.xlarge",
    instance_count=1,
    content_type="text/csv",
    accept_type="application/json"
)

# Multiclass classification
multiclass_config = ModelConfig(
    model_name="multiclass-model",
    instance_type="ml.m5.xlarge",
    instance_count=1,
    content_type="application/json",
    accept_type="application/json",
    label_headers=["class_0", "class_1", "class_2", "class_3"]
)

# Custom content template for JSON
json_model_config = ModelConfig(
    model_name="json-model",
    instance_type="ml.m5.xlarge",
    instance_count=1,
    content_type="application/json",
    accept_type="application/json",
    content_template='{"features": $features}'  # $features replaced with data
)

class ModelPredictedLabelConfig:
    """
    Configuration for extracting predicted labels from model responses.

    Parameters:
        label: Optional[Union[str, int]] - Label name or index in response
            - String: JSON key name
            - Integer: Array/CSV index
        probability: Optional[Union[str, int]] - Probability name or index
            - For classification probabilities
        probability_threshold: Optional[float] - Threshold for classification
            - Range: 0.0-1.0
            - Predictions >= threshold classified as positive
        label_headers: Optional[List[str]] - Label headers
            - For multiclass: names corresponding to class indices

    Usage:
        Extract predictions from model responses for bias analysis.
        Handles various model output formats.
    
    Notes:
        - For binary classification: provide probability and threshold
        - For multiclass: provide label_headers
        - For regression: provide label index/name
        - Flexible parsing supports most model output formats
    """

from sagemaker.core.clarify import ModelPredictedLabelConfig

# Binary classification with probability
predicted_label_config = ModelPredictedLabelConfig(
    probability="probability",  # Field name in JSON response
    probability_threshold=0.5
)

# Multiclass classification
multiclass_label_config = ModelPredictedLabelConfig(
    label="predicted_class",
    label_headers=["negative", "neutral", "positive"]
)

# CSV output (index-based)
csv_label_config = ModelPredictedLabelConfig(
    label=0,  # First column
    probability=1  # Second column
)

class SHAPConfig:
    """
    SHAP (SHapley Additive exPlanations) configuration.

    Parameters:
        baseline: Union[str, List] - Baseline for SHAP (required)
            - S3 URI: "s3://bucket/baseline.csv"
            - List: Baseline instances [[val1, val2, ...], ...]
        num_samples: int - Number of samples for SHAP (default: 100)
            - Range: 1-10000
            - More samples = better accuracy, longer runtime
        agg_method: str - Aggregation method (default: "mean_abs")
            - "mean_abs": Mean absolute SHAP values
            - "median": Median SHAP values
            - "mean_sq": Mean squared SHAP values
        use_logit: bool - Use logit for probability models (default: False)
            - Convert probabilities to log-odds
        save_local_shap_values: bool - Save local SHAP values (default: True)
            - Per-instance SHAP values
        seed: Optional[int] - Random seed for reproducibility
            - Range: 0-2147483647
        num_clusters: Optional[int] - Number of clusters for summarization
            - Reduces baseline size via clustering
        text_config: Optional[TextConfig] - Text data configuration
        image_config: Optional[ImageConfig] - Image data configuration

    Usage:
        Configure SHAP explainability analysis.
        Kernel SHAP for model-agnostic explanations.
    
    Notes:
        - Baseline represents "typical" or "neutral" instances
        - num_samples trades off accuracy vs runtime
        - agg_method determines global feature importance
        - Local SHAP values show per-instance explanations
        - Text/image configs for specialized data types
    """

from sagemaker.core.clarify import SHAPConfig

# Tabular data SHAP config
shap_config = SHAPConfig(
    baseline=[
        [25, 1, 9, 0, 0, 0, 0],  # Baseline instance 1
        [35, 2, 12, 1, 1, 0, 1],  # Baseline instance 2
        [45, 3, 14, 0, 1, 1, 0]   # Baseline instance 3
    ],
    num_samples=500,  # More samples for accuracy
    agg_method="mean_abs",
    save_local_shap_values=True,
    seed=42
)

# With clustering to reduce baseline
large_dataset_config = SHAPConfig(
    baseline="s3://bucket/large-baseline.csv",  # 10000 instances
    num_clusters=10,  # Cluster to 10 representative instances
    num_samples=200,
    agg_method="median"
)

class PDPConfig:
    """
    Partial Dependence Plot configuration.

    Parameters:
        features: Optional[List[str]] - Features to analyze
            - Specific feature names
            - If not provided: analyzes all features
        grid_resolution: int - Grid resolution for PDP (default: 15)
            - Range: 5-50
            - Number of points along feature axis
        top_k_features: Optional[int] - Number of top features
            - Analyze only top K important features
            - Based on feature importance

    Usage:
        Configure Partial Dependence Plot analysis for feature effects.
    
    Notes:
        - Shows marginal effect of features on predictions
        - Grid resolution affects granularity and runtime
        - Use top_k_features to focus on important features
    """

class AsymmetricShapleyValueConfig:
    """
    Asymmetric Shapley value configuration for time series.

    Parameters:
        direction: str - Direction (required)
            - "chronological": Past influences future
            - "anti_chronological": Future influences past
        granularity: str - Granularity (required)
            - "timewise": Time-step level
            - "fine_grained": Feature level within timesteps

    Usage:
        Configure asymmetric Shapley values for time series models.
        Accounts for temporal dependencies.
    
    Notes:
        - Specific to time series data
        - chronological: most common (causal)
        - Use for LSTM, GRU, Transformer models on sequences
    """

class TextConfig:
    """
    Text data configuration for NLP models.

    Parameters:
        granularity: str - Granularity level (required)
            - "token": Token-level explanations
            - "sentence": Sentence-level explanations
            - "paragraph": Paragraph-level explanations
        language: str - Language code (required)
            - ISO 639-1 (e.g., "en", "es", "fr")
            - ISO 639-3 for less common languages

    Usage:
        Configure text-specific explainability.
        Determines how text is segmented for SHAP analysis.
    
    Notes:
        - Token: Most granular, longest runtime
        - Sentence: Good balance
        - Paragraph: Fastest, less granular
        - Language affects tokenization
    """

class ImageConfig:
    """
    Image data configuration for computer vision models.

    Parameters:
        model_type: str - Model type (required)
            - "OBJECT_DETECTION": Object detection models
            - "IMAGE_CLASSIFICATION": Classification models
        num_segments: Optional[int] - Number of image segments
            - Range: 2-1000
            - More segments = more granular explanations
            - Default: model-dependent
        feature_extraction_method: Optional[str] - Feature extraction method
            - "segmentation": Image segmentation
        segment_compactness: Optional[float] - Segment compactness
            - Range: 0.0-1.0
            - Higher = more compact segments
        max_objects: Optional[int] - Maximum objects to detect
            - For object detection models
            - Default: 10

    Usage:
        Configure image-specific explainability.
        Segments image into superpixels for SHAP analysis.
    
    Notes:
        - Segments are regions of similar pixels
        - SHAP values indicate segment importance
        - num_segments trades off granularity vs performance
    """

class SegmentationConfig:
    """
    Segmentation configuration for images.

    Parameters:
        num_segments: int - Number of segments (required)
            - Range: 2-1000
        compactness: float - Compactness parameter (required)
            - Range: 0.0-1.0
            - Controls segment regularity

    Usage:
        Configure image segmentation for explainability.
        Uses SLIC (Simple Linear Iterative Clustering) algorithm.
    """

from sagemaker.core.clarify import (
    SageMakerClarifyProcessor,
    DataConfig,
    BiasConfig
)

# Configure processor
clarify_processor = SageMakerClarifyProcessor(
    role=role,
    instance_count=1,
    instance_type="ml.m5.xlarge"
)

# Configure data
data_config = DataConfig(
    s3_data_input_path="s3://my-bucket/training-data.csv",
    s3_output_path="s3://my-bucket/clarify-output",
    label="income",
    headers=["age", "workclass", "education", "gender", "income"],
    dataset_type="text/csv"
)

# Configure bias
bias_config = BiasConfig(
    label_values_or_threshold=[1],  # High income = 1
    facet_name="gender",
    facet_values_or_threshold=[0]  # Male = 0 (reference)
)

# Run pre-training bias analysis
try:
    clarify_processor.run_pre_training_bias(
        data_config=data_config,
        bias_config=bias_config,
        output_config=data_config,  # Reuse for output
        methods=["CI", "DPL", "KL", "JS", "LP"],
        wait=True,
        logs=True
    )
    
    print("Pre-training bias analysis completed")
    print("Check s3://my-bucket/clarify-output/analysis.json for results")
    
except ValueError as e:
    print(f"Configuration error: {e}")

from sagemaker.core.clarify import ModelConfig, ModelPredictedLabelConfig

# Configure model
model_config = ModelConfig(
    model_name="income-predictor",
    instance_type="ml.m5.xlarge",
    instance_count=1,
    content_type="text/csv",
    accept_type="application/json"
)

# Configure predicted labels
predicted_label_config = ModelPredictedLabelConfig(
    probability_threshold=0.5
)

# Run post-training bias analysis
clarify_processor.run_post_training_bias(
    data_config=data_config,
    data_bias_config=bias_config,
    model_config=model_config,
    model_predicted_label_config=predicted_label_config,
    output_config=data_config,
    methods=["DI", "DCR", "RD", "AD", "CDDL"],
    wait=True,
    logs=True
)

from sagemaker.core.clarify import SHAPConfig

# Configure SHAP
shap_config = SHAPConfig(
    baseline=[[25, 1, 9, 0]],  # Typical instance
    num_samples=100,
    agg_method="mean_abs",
    save_local_shap_values=True,
    seed=42
)

# Run explainability analysis
clarify_processor.run_explainability(
    data_config=data_config,
    model_config=model_config,
    explainability_config=shap_config,
    output_config=data_config,
    wait=True,
    logs=True
)

# Results include:
# - Global feature importance
# - Local SHAP values per instance
# - Partial dependence plots

# Run both analyses together (more efficient)
clarify_processor.run_bias_and_explainability(
    data_config=data_config,
    bias_config=bias_config,
    model_config=model_config,
    explainability_config=shap_config,
    model_predicted_label_config=predicted_label_config,
    output_config=data_config,
    pre_training_methods=["CI", "DPL"],
    post_training_methods=["DI", "DCR"],
    wait=True,
    logs=True
)

# Single job produces:
# - Pre-training bias report
# - Post-training bias report
# - Explainability report with SHAP values

from sagemaker.core.clarify import TextConfig

# Configure for text data
text_config = TextConfig(
    granularity="token",  # Token-level importance
    language="english"
)

shap_config = SHAPConfig(
    baseline=["This is a neutral baseline text."],
    num_samples=50,
    agg_method="mean_abs",
    text_config=text_config
)

data_config = DataConfig(
    s3_data_input_path="s3://my-bucket/text-data.jsonl",
    s3_output_path="s3://my-bucket/clarify-output",
    dataset_type="application/jsonlines"
)

clarify_processor.run_explainability(
    data_config=data_config,
    model_config=model_config,
    explainability_config=shap_config,
    output_config=data_config
)

# Results show token importance for predictions

from sagemaker.core.clarify import ImageConfig

# Configure for image data
image_config = ImageConfig(
    model_type="IMAGE_CLASSIFICATION",
    num_segments=20,  # 20 superpixel segments
    segment_compactness=0.5
)

shap_config = SHAPConfig(
    baseline="s3://my-bucket/baseline-images/",
    num_samples=50,
    image_config=image_config
)

data_config = DataConfig(
    s3_data_input_path="s3://my-bucket/images/",
    s3_output_path="s3://my-bucket/clarify-output",
    dataset_type="application/x-image"
)

clarify_processor.run_explainability(
    data_config=data_config,
    model_config=model_config,
    explainability_config=shap_config,
    output_config=data_config
)

# Results include segmented images with SHAP values

from sagemaker.core.clarify import (
    TimeSeriesDataConfig,
    TimeSeriesModelConfig,
    AsymmetricShapleyValueConfig
)

# Time series specific configs
ts_data_config = TimeSeriesDataConfig(
    s3_data_input_path="s3://my-bucket/timeseries-data.csv",
    s3_output_path="s3://my-bucket/clarify-output",
    dataset_type="text/csv",
    headers=["timestamp", "feature1", "feature2", "target"]
)

ts_model_config = TimeSeriesModelConfig(
    model_name="timeseries-model",
    instance_type="ml.m5.xlarge",
    instance_count=1
)

asym_config = AsymmetricShapleyValueConfig(
    direction="chronological",  # Past influences future
    granularity="timewise"
)

clarify_processor.run_explainability(
    data_config=ts_data_config,
    model_config=ts_model_config,
    explainability_config=asym_config,
    output_config=ts_data_config
)

from sagemaker.core.s3 import S3Downloader
import json

# Download analysis results
output_path = "s3://my-bucket/clarify-output"

# Pre-training bias metrics
pre_bias = json.loads(
    S3Downloader.read_file(f"{output_path}/analysis.json")
)

print("Pre-training Bias Metrics:")
for metric_name, metric_value in pre_bias['pre_training_bias_metrics'].items():
    print(f"  {metric_name}: {metric_value}")
    if abs(metric_value) > 0.25:
        print(f"    WARNING: Significant bias detected!")

# Post-training bias metrics
post_bias = json.loads(
    S3Downloader.read_file(f"{output_path}/analysis.json")
)

print("\nPost-training Bias Metrics:")
for metric_name, metric_value in post_bias['post_training_bias_metrics'].items():
    print(f"  {metric_name}: {metric_value}")

# SHAP values
shap_values = json.loads(
    S3Downloader.read_file(f"{output_path}/explanations_shap/out.json")
)

# Global feature importance
print("\nGlobal Feature Importance:")
for feature, importance in shap_values['feature_importance'].items():
    print(f"  {feature}: {importance}")

# Local explanations for specific instance
instance_id = 0
local_shap = shap_values['explanations'][instance_id]
print(f"\nInstance {instance_id} SHAP values:")
for feature, shap_value in local_shap.items():
    print(f"  {feature}: {shap_value:+.4f}")

# 1. Pre-training bias check
clarify_processor.run_pre_training_bias(
    data_config=data_config,
    bias_config=bias_config,
    output_config=data_config,
    methods="all"
)

# 2. Review results and mitigate if needed
# - Rebalance dataset
# - Add fairness constraints
# - Resample protected groups

# 3. Train model
trainer.train(input_data_config=[train_data])

# 4. Post-training bias check
clarify_processor.run_post_training_bias(
    data_config=data_config,
    data_bias_config=bias_config,
    model_config=model_config,
    model_predicted_label_config=predicted_label_config,
    output_config=data_config,
    methods="all"
)

# 5. Compare pre vs post metrics
# If post-training bias worse: adjust training or use post-processing

# 6. Explainability for understanding
clarify_processor.run_explainability(
    data_config=data_config,
    model_config=model_config,
    explainability_config=shap_config,
    output_config=data_config
)

# Use SHAP to understand which features drive bias