xai

check_for_nans(data, layer_index)

Checks for NaN values in the tensor data.

Parameters:

Name	Type	Description	Default
data	Tensor	The tensor to check for NaN values.	required
layer_index	int	The index of the layer for logging purposes.	required

Returns:

Name	Type	Description
bool	bool	True if NaNs are found, False otherwise.

Source code in spotpython/plot/xai.py

def check_for_nans(data, layer_index) -> bool:
    """Checks for NaN values in the tensor data.

    Args:
        data (torch.Tensor): The tensor to check for NaN values.
        layer_index (int): The index of the layer for logging purposes.

    Returns:
        bool: True if NaNs are found, False otherwise.
    """
    if torch.isnan(data).any():
        print(f"NaN detected after layer {layer_index}")
        return True
    return False

get_activations(net, fun_control, batch_size, device='cpu', normalize=False)

Computes the activations for each layer of the network, the mean activations, and the sizes of the activations for each layer.

Parameters:

Name	Type	Description	Default
net	Module	The neural network model.	required
fun_control	dict	A dictionary containing the dataset.	required
batch_size	int	The batch size for the data loader.	required
device	str	The device to run the model on. Defaults to “cpu”.	'cpu'
normalize	bool	Whether to normalize the input data. Defaults to False.	False

Returns:

Name	Type	Description
tuple	tuple	A tuple containing the activations, mean activations, and layer sizes for each layer.

Examples:

>>> from spotpython.plot.xai import get_activations
    import torch
    import numpy as np
    import torch.nn as nn
    from spotpython.utils.init import fun_control_init
    from spotpython.data.diabetes import Diabetes
    from spotpython.light.regression.nn_linear_regressor import NNLinearRegressor
    from spotpython.hyperdict.light_hyper_dict import LightHyperDict
    from spotpython.hyperparameters.values import (
            get_default_hyperparameters_as_array, get_one_config_from_X)
    from spotpython.hyperdict.light_hyper_dict import LightHyperDict
    from spotpython.data.lightdatamodule import LightDataModule
    from spotpython.plot.xai import get_gradients
    fun_control = fun_control_init(
        _L_in=10, # 10: diabetes
        _L_out=1,
        _torchmetric="mean_squared_error",
        data_set=Diabetes(),
        core_model=NNLinearRegressor,
        hyperdict=LightHyperDict)
    X = get_default_hyperparameters_as_array(fun_control)
    config = get_one_config_from_X(X, fun_control)
    _L_in = fun_control["_L_in"]
    _L_out = fun_control["_L_out"]
    _torchmetric = fun_control["_torchmetric"]
    batch_size = 16
    model = fun_control["core_model"](**config, _L_in=_L_in, _L_out=_L_out, _torchmetric=_torchmetric)
    activations, mean_activations, layer_sizes = get_activations(net=model, fun_control=fun_control, batch_size=batch_size, device = "cpu")
    plot_nn_values_scatter(nn_values=activations, layer_sizes=layer_sizes, nn_values_names="Activations")

Source code in spotpython/plot/xai.py

def get_activations(net, fun_control, batch_size, device="cpu", normalize=False) -> tuple:
    """
    Computes the activations for each layer of the network, the mean activations,
    and the sizes of the activations for each layer.

    Args:
        net (nn.Module): The neural network model.
        fun_control (dict): A dictionary containing the dataset.
        batch_size (int): The batch size for the data loader.
        device (str): The device to run the model on. Defaults to "cpu".
        normalize (bool): Whether to normalize the input data. Defaults to False.

    Returns:
        tuple: A tuple containing the activations, mean activations, and layer sizes for each layer.

    Examples:
        >>> from spotpython.plot.xai import get_activations
            import torch
            import numpy as np
            import torch.nn as nn
            from spotpython.utils.init import fun_control_init
            from spotpython.data.diabetes import Diabetes
            from spotpython.light.regression.nn_linear_regressor import NNLinearRegressor
            from spotpython.hyperdict.light_hyper_dict import LightHyperDict
            from spotpython.hyperparameters.values import (
                    get_default_hyperparameters_as_array, get_one_config_from_X)
            from spotpython.hyperdict.light_hyper_dict import LightHyperDict
            from spotpython.data.lightdatamodule import LightDataModule
            from spotpython.plot.xai import get_gradients
            fun_control = fun_control_init(
                _L_in=10, # 10: diabetes
                _L_out=1,
                _torchmetric="mean_squared_error",
                data_set=Diabetes(),
                core_model=NNLinearRegressor,
                hyperdict=LightHyperDict)
            X = get_default_hyperparameters_as_array(fun_control)
            config = get_one_config_from_X(X, fun_control)
            _L_in = fun_control["_L_in"]
            _L_out = fun_control["_L_out"]
            _torchmetric = fun_control["_torchmetric"]
            batch_size = 16
            model = fun_control["core_model"](**config, _L_in=_L_in, _L_out=_L_out, _torchmetric=_torchmetric)
            activations, mean_activations, layer_sizes = get_activations(net=model, fun_control=fun_control, batch_size=batch_size, device = "cpu")
            plot_nn_values_scatter(nn_values=activations, layer_sizes=layer_sizes, nn_values_names="Activations")
    """
    activations = {}
    mean_activations = {}
    layer_sizes = {}
    net.eval()  # Set the model to evaluation mode

    dataset = fun_control["data_set"]
    data_module = LightDataModule(
        dataset=dataset,
        batch_size=batch_size,
        test_size=fun_control["test_size"],
        scaler=fun_control["scaler"],
        verbosity=10,
    )
    data_module.setup(stage="fit")
    train_loader = data_module.train_dataloader()
    inputs, _ = next(iter(train_loader))
    inputs = inputs.to(device)

    if normalize:
        inputs = (inputs - inputs.mean(dim=0, keepdim=True)) / inputs.std(dim=0, keepdim=True)

    with torch.no_grad():
        inputs = inputs.view(inputs.size(0), -1)
        # Loop through all layers
        for layer_index, layer in enumerate(net.layers[:-1]):
            inputs = layer(inputs)  # Forward pass through the layer

            # Check for NaNs
            if check_for_nans(inputs, layer_index):
                break

            # Collect activations for Linear layers
            if isinstance(layer, nn.Linear):
                activations[layer_index] = inputs.view(-1).cpu().numpy()
                mean_activations[layer_index] = inputs.mean(dim=0).cpu().numpy()
                # Record the size of the activations and set the first dimension to 1
                layer_size = np.array(inputs.size())
                layer_size[0] = 1  # Set the first dimension to 1
                layer_sizes[layer_index] = layer_size

    return activations, mean_activations, layer_sizes

get_all_layers_conductance(spot_tuner, fun_control, device='cpu', remove_spot_attributes=False)

Get the conductance of all layers.

Parameters:

Name	Type	Description	Default
spot_tuner	object	The spot tuner object.	required
fun_control	dict	A dictionary with the function control.	required
device	str	The device to use. Defaults to “cpu”.	'cpu'
remove_spot_attributes	bool	Whether to remove the spot attributes. Defaults to False.	False

Source code in spotpython/plot/xai.py

def get_all_layers_conductance(spot_tuner, fun_control, device="cpu", remove_spot_attributes=False) -> dict:
    """
    Get the conductance of all layers.

    Args:
        spot_tuner (object):
            The spot tuner object.
        fun_control (dict):
            A dictionary with the function control.
        device (str, optional):
            The device to use. Defaults to "cpu".
        remove_spot_attributes (bool, optional):
            Whether to remove the spot attributes. Defaults to False.
    """
    config = get_tuned_architecture(spot_tuner, fun_control)
    train_model(config, fun_control, timestamp=False)
    model_loaded = load_light_from_checkpoint(config, fun_control, postfix="_TRAIN")
    if remove_spot_attributes:
        removed_attributes, model = get_removed_attributes_and_base_net(net=model_loaded)
    else:
        model = model_loaded
    model = model.to(device)
    model.eval()
    _, index, _ = get_weights(model, return_index=True)
    layer_conductance = {}
    for i in index:
        layer_conductance[i] = get_layer_conductance(spot_tuner, fun_control, layer_idx=i)
    return layer_conductance

get_attributions(spot_tuner, fun_control, attr_method='IntegratedGradients', baseline=None, abs_attr=True, n_rel=5, device='cpu', normalize=True, remove_spot_attributes=False)

Get the attributions of a neural network.

Parameters:

Name	Type	Description	Default
spot_tuner	object	The spot tuner object.	required
fun_control	dict	A dictionary with the function control.	required
attr_method	str	The attribution method. Defaults to “IntegratedGradients”.	'IntegratedGradients'
baseline	Tensor	The baseline for the attribution methods. Defaults to None.	None
abs_attr	bool	Whether the method should sort by the absolute attribution values. Defaults to True.	True
n_rel	int	The number of relevant features. Defaults to 5.	5
device	str	The device to use. Defaults to “cpu”.	'cpu'
normalize	bool	Whether to normalize the input data. Defaults to True.	True
remove_spot_attributes	bool	Whether to remove the spot attributes. If True, a torch model is created via get_removed_attributes. Defaults to False.	False

Returns:

Type	Description
DataFrame	pd.DataFrame (object): A DataFrame with the attributions.

Source code in spotpython/plot/xai.py

def get_attributions(
    spot_tuner,
    fun_control,
    attr_method="IntegratedGradients",
    baseline=None,
    abs_attr=True,
    n_rel=5,
    device="cpu",
    normalize=True,
    remove_spot_attributes=False,
) -> pd.DataFrame:
    """Get the attributions of a neural network.

    Args:
        spot_tuner (object):
            The spot tuner object.
        fun_control (dict):
            A dictionary with the function control.
        attr_method (str, optional):
            The attribution method. Defaults to "IntegratedGradients".
        baseline (torch.Tensor, optional):
            The baseline for the attribution methods. Defaults to None.
        abs_attr (bool, optional):
            Whether the method should sort by the absolute attribution values. Defaults to True.
        n_rel (int, optional):
            The number of relevant features. Defaults to 5.
        device (str, optional):
            The device to use. Defaults to "cpu".
        normalize (bool, optional):
            Whether to normalize the input data. Defaults to True.
        remove_spot_attributes (bool, optional):
            Whether to remove the spot attributes.
            If True, a torch model is created via `get_removed_attributes`. Defaults to False.

    Returns:
        pd.DataFrame (object): A DataFrame with the attributions.
    """
    try:
        fun_control["data_set"].names
    except AttributeError:
        fun_control["data_set"].names = None
    feature_names = fun_control["data_set"].names
    total_attributions = None
    config = get_tuned_architecture(spot_tuner, fun_control)
    train_model(config, fun_control, timestamp=False)
    model_loaded = load_light_from_checkpoint(config, fun_control, postfix="_TRAIN")
    if remove_spot_attributes:
        removed_attributes, model = get_removed_attributes_and_base_net(net=model_loaded)
    else:
        model = model_loaded
    model = model.to(device)
    model.eval()
    # get feature names
    dataset = fun_control["data_set"]
    try:
        n_features = dataset.data.shape[1]
    except AttributeError:
        n_features = dataset.tensors[0].shape[1]
    if feature_names is None:
        feature_names = [f"x{i}" for i in range(n_features)]
    # get batch size
    batch_size = config["batch_size"]
    # test_loader = DataLoader(dataset, batch_size=batch_size, shuffle=False)

    data_module = LightDataModule(
        dataset=dataset,
        batch_size=batch_size,
        test_size=fun_control["test_size"],
        scaler=fun_control["scaler"],
        verbosity=10,
    )
    data_module.setup(stage="test")
    test_loader = data_module.test_dataloader()

    if attr_method == "IntegratedGradients":
        attr = IntegratedGradients(model)
    elif attr_method == "DeepLift":
        attr = DeepLift(model)
    elif attr_method == "GradientShap":  # Todo: would need a baseline
        if baseline is None:
            raise ValueError("baseline cannot be 'None' for GradientShap")
        attr = GradientShap(model)
    elif attr_method == "FeatureAblation":
        attr = FeatureAblation(model)
    else:
        raise ValueError(
            """
            Unsupported attribution method.
            Please choose from 'IntegratedGradients', 'DeepLift', 'GradientShap', or 'FeatureAblation'.
            """
        )
    for inputs, _ in test_loader:
        if normalize:
            inputs = (inputs - inputs.mean()) / inputs.std()
        inputs.requires_grad_()
        attributions = attr.attribute(inputs, return_convergence_delta=False, baselines=baseline)
        if total_attributions is None:
            total_attributions = attributions
        else:
            if len(attributions) == len(total_attributions):
                total_attributions += attributions

    # Calculation of average attribution across all batches
    avg_attributions = total_attributions.mean(dim=0).detach().numpy()

    # Transformation to the absolute attribution values if abs_attr is True
    # Get indices of the n most important features
    if abs_attr is True:
        abs_avg_attributions = abs(avg_attributions)
        top_n_indices = abs_avg_attributions.argsort()[-n_rel:][::-1]
    else:
        top_n_indices = avg_attributions.argsort()[-n_rel:][::-1]

    # Get the importance values for the top n features
    top_n_importances = avg_attributions[top_n_indices]

    df = pd.DataFrame(
        {
            "Feature Index": top_n_indices,
            "Feature": [feature_names[i] for i in top_n_indices],
            attr_method + "Attribution": top_n_importances,
        }
    )
    return df

get_gradients(net, fun_control, batch_size, device='cpu', normalize=False)

Get the gradients of a neural network and the size of each layer.

Parameters:

Name	Type	Description	Default
net	object	A neural network.	required
fun_control	dict	A dictionary with the function control.	required
batch_size	int	The batch size.	required
device	str	The device to use. Defaults to “cpu”.	'cpu'
normalize	bool	Whether to normalize the input data. Defaults to False.	False

Returns:

Name	Type	Description
tuple	tuple	A tuple containing: - grads: A dictionary with the gradients of the neural network. - layer_sizes: A dictionary with layer names as keys and their sizes as entries in NumPy array format.

Examples:

>>> from spotpython.plot.xai import get_gradients
    import torch
    import numpy as np
    import torch.nn as nn
    from spotpython.utils.init import fun_control_init
    from spotpython.data.diabetes import Diabetes
    from spotpython.light.regression.nn_linear_regressor import NNLinearRegressor
    from spotpython.hyperdict.light_hyper_dict import LightHyperDict
    from spotpython.hyperparameters.values import (
            get_default_hyperparameters_as_array, get_one_config_from_X)
    from spotpython.hyperdict.light_hyper_dict import LightHyperDict
    from spotpython.data.lightdatamodule import LightDataModule
    # from spotpython.plot.xai import get_gradients
    fun_control = fun_control_init(
        _L_in=10, # 10: diabetes
        _L_out=1,
        _torchmetric="mean_squared_error",
        data_set=Diabetes(),
        core_model=NNLinearRegressor,
        hyperdict=LightHyperDict)
    X = get_default_hyperparameters_as_array(fun_control)
    config = get_one_config_from_X(X, fun_control)
    _L_in = fun_control["_L_in"]
    _L_out = fun_control["_L_out"]
    _torchmetric = fun_control["_torchmetric"]
    batch_size = 16
    model = fun_control["core_model"](**config, _L_in=_L_in, _L_out=_L_out, _torchmetric=_torchmetric)
    gradients, layer_sizes = get_gradients(net=model)
    gradients, layer_sizes

Source code in spotpython/plot/xai.py

def get_gradients(net, fun_control, batch_size, device="cpu", normalize=False) -> tuple:
    """
    Get the gradients of a neural network and the size of each layer.

    Args:
        net (object):
            A neural network.
        fun_control (dict):
            A dictionary with the function control.
        batch_size (int, optional):
            The batch size.
        device (str, optional):
            The device to use. Defaults to "cpu".
        normalize (bool, optional):
            Whether to normalize the input data. Defaults to False.

    Returns:
        tuple: A tuple containing:
            - grads: A dictionary with the gradients of the neural network.
            - layer_sizes: A dictionary with layer names as keys and their sizes as entries in NumPy array format.

    Examples:
        >>> from spotpython.plot.xai import get_gradients
            import torch
            import numpy as np
            import torch.nn as nn
            from spotpython.utils.init import fun_control_init
            from spotpython.data.diabetes import Diabetes
            from spotpython.light.regression.nn_linear_regressor import NNLinearRegressor
            from spotpython.hyperdict.light_hyper_dict import LightHyperDict
            from spotpython.hyperparameters.values import (
                    get_default_hyperparameters_as_array, get_one_config_from_X)
            from spotpython.hyperdict.light_hyper_dict import LightHyperDict
            from spotpython.data.lightdatamodule import LightDataModule
            # from spotpython.plot.xai import get_gradients
            fun_control = fun_control_init(
                _L_in=10, # 10: diabetes
                _L_out=1,
                _torchmetric="mean_squared_error",
                data_set=Diabetes(),
                core_model=NNLinearRegressor,
                hyperdict=LightHyperDict)
            X = get_default_hyperparameters_as_array(fun_control)
            config = get_one_config_from_X(X, fun_control)
            _L_in = fun_control["_L_in"]
            _L_out = fun_control["_L_out"]
            _torchmetric = fun_control["_torchmetric"]
            batch_size = 16
            model = fun_control["core_model"](**config, _L_in=_L_in, _L_out=_L_out, _torchmetric=_torchmetric)
            gradients, layer_sizes = get_gradients(net=model)
            gradients, layer_sizes
    """
    net.eval()
    dataset = fun_control["data_set"]
    data_module = LightDataModule(
        dataset=dataset,
        batch_size=batch_size,
        test_size=fun_control["test_size"],
        scaler=fun_control["scaler"],
        verbosity=10,
    )
    data_module.setup(stage="fit")
    train_loader = data_module.train_dataloader()
    inputs, targets = next(iter(train_loader))
    if normalize:
        inputs = (inputs - inputs.mean(dim=0, keepdim=True)) / inputs.std(dim=0, keepdim=True)
    inputs, targets = inputs.to(device), targets.to(device)

    # Pass one batch through the network, and calculate the gradients for the weights
    net.zero_grad()
    preds = net(inputs)
    preds = preds.squeeze(-1)  # Remove the last dimension if it's 1
    loss = F.mse_loss(preds, targets)
    loss.backward()

    grads = {}
    layer_sizes = {}
    for name, params in net.named_parameters():
        if "weight" in name:
            # Collect gradient information
            grads[name] = params.grad.view(-1).cpu().clone().numpy()
            # Collect size information
            layer_sizes[name] = np.array(params.size())

    net.zero_grad()
    return grads, layer_sizes

get_layer_conductance(spot_tuner, fun_control, layer_idx, device='cpu', normalize=True, remove_spot_attributes=False)

Compute the average layer conductance attributions for a specified layer in the model.

Parameters:

Name	Type	Description	Default
spot_tuner	Spot	The spot tuner object containing the trained model.	required
fun_control	dict	The fun_control dictionary containing the hyperparameters used to train the model.	required
layer_idx	int	Index of the layer for which to compute layer conductance attributions.	required
device	str	The device to use. Defaults to “cpu”.	'cpu'
normalize	bool	Whether to normalize the input data. Defaults to True.	True
remove_spot_attributes	bool	Whether to remove the spot attributes. Defaults to False.	False

Returns:

Type	Description
ndarray	numpy.ndarray: An array containing the average layer conductance attributions for the specified layer. The shape of the array corresponds to the shape of the attributions.

Source code in spotpython/plot/xai.py

def get_layer_conductance(
    spot_tuner, fun_control, layer_idx, device="cpu", normalize=True, remove_spot_attributes=False
) -> np.ndarray:
    """
    Compute the average layer conductance attributions for a specified layer in the model.

    Args:
        spot_tuner (spot.Spot):
            The spot tuner object containing the trained model.
        fun_control (dict):
            The fun_control dictionary containing the hyperparameters used to train the model.
        layer_idx (int):
            Index of the layer for which to compute layer conductance attributions.
        device (str, optional):
            The device to use. Defaults to "cpu".
        normalize (bool, optional):
            Whether to normalize the input data. Defaults to True.
        remove_spot_attributes (bool, optional):
            Whether to remove the spot attributes. Defaults to False.

    Returns:
        numpy.ndarray:
            An array containing the average layer conductance attributions for the specified layer.
            The shape of the array corresponds to the shape of the attributions.
    """
    try:
        fun_control["data_set"].names
    except AttributeError:
        fun_control["data_set"].names = None
    feature_names = fun_control["data_set"].names

    config = get_tuned_architecture(spot_tuner, fun_control)
    train_model(config, fun_control, timestamp=False)
    model_loaded = load_light_from_checkpoint(config, fun_control, postfix="_TRAIN")
    if remove_spot_attributes:
        removed_attributes, model = get_removed_attributes_and_base_net(net=model_loaded)
    else:
        model = model_loaded
    model = model.to(device)
    model.eval()

    dataset = fun_control["data_set"]
    try:
        n_features = dataset.data.shape[1]
    except AttributeError:
        n_features = dataset.tensors[0].shape[1]
    if feature_names is None:
        feature_names = [f"x{i}" for i in range(n_features)]
    batch_size = config["batch_size"]
    test_loader = DataLoader(dataset, batch_size=batch_size)
    total_layer_attributions = None
    layers = model.layers
    print("Conductance analysis for layer: ", layers[layer_idx])
    lc = LayerConductance(model, layers[layer_idx])

    for inputs, labels in test_loader:
        if normalize:
            inputs = (inputs - inputs.mean()) / inputs.std()
        lc_attr_test = lc.attribute(inputs, n_steps=10, attribute_to_layer_input=True)
        if total_layer_attributions is None:
            total_layer_attributions = lc_attr_test
        else:
            if len(lc_attr_test) == len(total_layer_attributions):
                total_layer_attributions += lc_attr_test

    avg_layer_attributions = total_layer_attributions.mean(dim=0).detach().numpy()

    return avg_layer_attributions

get_weights(net, return_index=False)

Get the weights of a neural network and the size of each layer.

Parameters:

Name	Type	Description	Default
net	object	A neural network.	required
return_index	bool	Whether to return the index. Defaults to False.	False

Returns:

Name	Type	Description
tuple	tuple	A tuple containing: - weights: A dictionary with the weights of the neural network. - index: The layer index list (only if return_index is True). - layer_sizes: A dictionary with layer names as keys and their sizes as entries in NumPy array format.

Examples:

>>> from spotpython.plot.xai import get_weights
    import torch
    import numpy as np
    import torch.nn as nn
    from spotpython.utils.init import fun_control_init
    from spotpython.data.diabetes import Diabetes
    from spotpython.light.regression.nn_linear_regressor import NNLinearRegressor
    from spotpython.hyperdict.light_hyper_dict import LightHyperDict
    from spotpython.hyperparameters.values import (
            get_default_hyperparameters_as_array, get_one_config_from_X)
    from spotpython.hyperdict.light_hyper_dict import LightHyperDict
    from spotpython.data.lightdatamodule import LightDataModule
    from spotpython.plot.xai import get_gradients
    fun_control = fun_control_init(
        _L_in=10, # 10: diabetes
        _L_out=1,
        _torchmetric="mean_squared_error",
        data_set=Diabetes(),
        core_model=NNLinearRegressor,
        hyperdict=LightHyperDict)
    X = get_default_hyperparameters_as_array(fun_control)
    config = get_one_config_from_X(X, fun_control)
    _L_in = fun_control["_L_in"]
    _L_out = fun_control["_L_out"]
    _torchmetric = fun_control["_torchmetric"]
    batch_size = 16
    model = fun_control["core_model"](**config, _L_in=_L_in, _L_out=_L_out, _torchmetric=_torchmetric)
    weights, layer_sizes = get_weights(net=model)
    weights, layer_sizes

Source code in spotpython/plot/xai.py

def get_weights(net, return_index=False) -> tuple:
    """
    Get the weights of a neural network and the size of each layer.

    Args:
        net (object):
            A neural network.
        return_index (bool, optional):
            Whether to return the index. Defaults to False.

    Returns:
        tuple:
            A tuple containing:
            - weights: A dictionary with the weights of the neural network.
            - index: The layer index list (only if return_index is True).
            - layer_sizes: A dictionary with layer names as keys and their sizes as entries in NumPy array format.

    Examples:
        >>> from spotpython.plot.xai import get_weights
            import torch
            import numpy as np
            import torch.nn as nn
            from spotpython.utils.init import fun_control_init
            from spotpython.data.diabetes import Diabetes
            from spotpython.light.regression.nn_linear_regressor import NNLinearRegressor
            from spotpython.hyperdict.light_hyper_dict import LightHyperDict
            from spotpython.hyperparameters.values import (
                    get_default_hyperparameters_as_array, get_one_config_from_X)
            from spotpython.hyperdict.light_hyper_dict import LightHyperDict
            from spotpython.data.lightdatamodule import LightDataModule
            from spotpython.plot.xai import get_gradients
            fun_control = fun_control_init(
                _L_in=10, # 10: diabetes
                _L_out=1,
                _torchmetric="mean_squared_error",
                data_set=Diabetes(),
                core_model=NNLinearRegressor,
                hyperdict=LightHyperDict)
            X = get_default_hyperparameters_as_array(fun_control)
            config = get_one_config_from_X(X, fun_control)
            _L_in = fun_control["_L_in"]
            _L_out = fun_control["_L_out"]
            _torchmetric = fun_control["_torchmetric"]
            batch_size = 16
            model = fun_control["core_model"](**config, _L_in=_L_in, _L_out=_L_out, _torchmetric=_torchmetric)
            weights, layer_sizes = get_weights(net=model)
            weights, layer_sizes
    """
    weights = {}
    index = []
    layer_sizes = {}

    for name, param in net.named_parameters():
        if name.endswith(".bias"):
            continue

        # Extract layer number
        layer_number = int(name.split(".")[1])
        index.append(layer_number)

        # Create dictionary key for this layer
        key_name = f"Layer {layer_number}"

        # Store weight information
        weights[key_name] = param.detach().view(-1).cpu().numpy()

        # Store layer size as a NumPy array
        layer_sizes[key_name] = np.array(param.size())

    if return_index:
        return weights, index, layer_sizes
    else:
        return weights, layer_sizes

get_weights_conductance_last_layer(spot_tuner, fun_control, device='cpu', remove_spot_attributes=False)

Get the weights and the conductance of the last layer.

Parameters:

Name	Type	Description	Default
spot_tuner	object	The spot tuner object.	required
fun_control	dict	A dictionary with the function control.	required
device	str	The device to use. Defaults to “cpu”.	'cpu'
remove_spot_attributes	bool	Whether to remove the spot attributes. Defaults to False.	False

Source code in spotpython/plot/xai.py

def get_weights_conductance_last_layer(spot_tuner, fun_control, device="cpu", remove_spot_attributes=False) -> tuple:
    """
    Get the weights and the conductance of the last layer.

    Args:
        spot_tuner (object):
            The spot tuner object.
        fun_control (dict):
            A dictionary with the function control.
        device (str, optional):
            The device to use. Defaults to "cpu".
        remove_spot_attributes (bool, optional):
            Whether to remove the spot attributes. Defaults to False.
    """
    config = get_tuned_architecture(spot_tuner, fun_control)
    train_model(config, fun_control, timestamp=False)
    model_loaded = load_light_from_checkpoint(config, fun_control, postfix="_TRAIN")
    if remove_spot_attributes:
        removed_attributes, model = get_removed_attributes_and_base_net(net=model_loaded)
    else:
        model = model_loaded
    model = model.to(device)
    model.eval()

    weights, index, _ = get_weights(model, return_index=True)
    layer_idx = index[-1]
    weights_last = weights[f"Layer {layer_idx}"]
    weights_last
    layer_conductance_last = get_layer_conductance(spot_tuner, fun_control, layer_idx=layer_idx)

    return weights_last, layer_conductance_last

is_square(n)

Check if a number is a square number.

Parameters:

Name	Type	Description	Default
n	int	The number to check.	required

Returns:

Name	Type	Description
bool	bool	True if the number is a square number, False otherwise.

Examples:

>>> is_square(4)
True
>>> is_square(5)
False

Source code in spotpython/plot/xai.py

def is_square(n) -> bool:
    """Check if a number is a square number.

    Args:
        n (int): The number to check.

    Returns:
        bool: True if the number is a square number, False otherwise.

    Examples:
        >>> is_square(4)
        True
        >>> is_square(5)
        False
    """
    return n == int(math.sqrt(n)) ** 2

plot_attributions(df, attr_method='IntegratedGradients')

Plot the attributions of a neural network.

Parameters:

Name	Type	Description	Default
df	DataFrame	A DataFrame with the attributions.	required
attr_method	str	The attribution method. Defaults to “IntegratedGradients”.	'IntegratedGradients'

Returns:

Type	Description
None	None

Source code in spotpython/plot/xai.py

def plot_attributions(df, attr_method="IntegratedGradients") -> None:
    """
    Plot the attributions of a neural network.

    Args:
        df (pd.DataFrame):
            A DataFrame with the attributions.
        attr_method (str, optional):
            The attribution method. Defaults to "IntegratedGradients".

    Returns:
        None

    """
    sns.set_theme(style="whitegrid")
    plt.figure(figsize=(10, 6))
    sns.barplot(x=attr_method + "Attribution", y="Feature", data=df, palette="viridis", hue="Feature")
    plt.title(f"Top {df.shape[0]} Features by {attr_method} Attribution")
    plt.xlabel(f"{attr_method} Attribution Value")
    plt.ylabel("Feature")
    plt.show()

plot_conductance_last_layer(weights_last, layer_conductance_last, figsize=(12, 6), show=True)

Plot the conductance of the last layer.

Parameters:

Name	Type	Description	Default
weights_last	ndarray	The weights of the last layer.	required
layer_conductance_last	ndarray	The conductance of the last layer.	required
figsize	tuple	The figure size. Defaults to (12, 6).	(12, 6)
show	bool	Whether to show the plot. Defaults	True

Examples:

>>> import numpy as np
    from spotpython.plot.xai import plot_conductance_last_layer
    weights_last = np.random.rand(10)
    layer_conductance_last = np.random.rand(10)
    plot_conductance_last_layer(weights_last, layer_conductance_last, show=True)

Source code in spotpython/plot/xai.py

def plot_conductance_last_layer(weights_last, layer_conductance_last, figsize=(12, 6), show=True) -> None:
    """
    Plot the conductance of the last layer.

    Args:
        weights_last (np.ndarray):
            The weights of the last layer.
        layer_conductance_last (np.ndarray):
            The conductance of the last layer.
        figsize (tuple, optional):
            The figure size. Defaults to (12, 6).
        show (bool, optional):
            Whether to show the plot. Defaults

    Examples:
        >>> import numpy as np
            from spotpython.plot.xai import plot_conductance_last_layer
            weights_last = np.random.rand(10)
            layer_conductance_last = np.random.rand(10)
            plot_conductance_last_layer(weights_last, layer_conductance_last, show=True)
    """
    fig, ax = plt.subplots(figsize=figsize)
    ax.bar(range(len(weights_last)), weights_last / weights_last.max(), label="Weights", alpha=0.5)
    ax.bar(
        range(len(layer_conductance_last)),
        layer_conductance_last / layer_conductance_last.max(),
        label="Layer Conductance",
        alpha=0.5,
    )
    ax.set_xlabel("Weight Index")
    ax.set_ylabel("Normalized Value")
    ax.set_title("Layer Conductance vs. Weights")
    ax.legend()
    ax.xaxis.set_major_locator(MaxNLocator(integer=True))
    if show:
        plt.show()

plot_nn_values_hist(nn_values, net, nn_values_names='', color='C0', columns=2)

Plot the values of a neural network. Can be used to plot the weights, gradients, or activations of a neural network.

Parameters:

Name	Type	Description	Default
nn_values	dict	A dictionary with the values of the neural network. For example, the weights, gradients, or activations.	required
net	object	A neural network.	required
color	str	The color to use. Defaults to “C0”.	'C0'
columns	int	The number of columns. Defaults to 2.	2

Source code in spotpython/plot/xai.py

def plot_nn_values_hist(nn_values, net, nn_values_names="", color="C0", columns=2) -> None:
    """
    Plot the values of a neural network.
    Can be used to plot the weights, gradients, or activations of a neural network.

    Args:
        nn_values (dict):
            A dictionary with the values of the neural network. For example,
            the weights, gradients, or activations.
        net (object):
            A neural network.
        color (str, optional):
            The color to use. Defaults to "C0".
        columns (int, optional):
            The number of columns. Defaults to 2.

    """
    n = len(nn_values)
    print(f"n:{n}")
    rows = n // columns + int(n % columns > 0)
    fig, ax = plt.subplots(rows, columns, figsize=(columns * 2.7, rows * 2.5))
    fig_index = 0
    for key in nn_values:
        key_ax = ax[fig_index // columns][fig_index % columns]
        sns.histplot(data=nn_values[key], bins=50, ax=key_ax, color=color, kde=True, stat="density")
        hidden_dim_str = (
            r"(%i $\to$ %i)" % (nn_values[key].shape[1], nn_values[key].shape[0])
            if len(nn_values[key].shape) > 1
            else ""
        )
        key_ax.set_title(f"{key} {hidden_dim_str}")
        # key_ax.set_title(f"Layer {key} - {net.layers[key].__class__.__name__}")
        fig_index += 1
    fig.suptitle(f"{nn_values_names} distribution for activation function {net.hparams.act_fn}", fontsize=14)
    fig.subplots_adjust(hspace=0.4, wspace=0.4)
    plt.show()

plot_nn_values_scatter(nn_values, layer_sizes, nn_values_names='', absolute=True, cmap='gray', figsize=(6, 6), return_reshaped=False, show=True)

Plot the values of a neural network including a marker for padding values. For simplicity, this example will annotate ‘P’ directly on the plot for padding values using a unique marker value approach.

Parameters:

Name	Type	Description	Default
nn_values	dict	A dictionary with the values of the neural network. For example, the weights, gradients, or activations.	required
layer_sizes	dict	A dictionary with layer names as keys and their sizes as entries in NumPy array format.	required
nn_values_names	str	The name of the values. Defaults to “”.	''
absolute	bool	Whether to use the absolute values. Defaults to True.	True
cmap	str	The colormap to use. Defaults to “gray”.	'gray'
figsize	tuple	The figure size. Defaults to (6, 6).	(6, 6)
return_reshaped	bool	Whether to return the reshaped values. Defaults to False.	False
show	bool	Whether to show the plot. Defaults to True.	True

Returns:

Name	Type	Description
dict	dict	A dictionary with the reshaped values.

Examples:

>>> from spotpython.utils.init import fun_control_init
    from spotpython.data.diabetes import Diabetes
    from spotpython.light.regression.nn_linear_regressor import NNLinearRegressor
    from spotpython.hyperdict.light_hyper_dict import LightHyperDict
    from spotpython.hyperparameters.values import (
            get_default_hyperparameters_as_array, get_one_config_from_X)
    from spotpython.hyperdict.light_hyper_dict import LightHyperDict
    # from spotpython.plot.xai import get_gradients
    fun_control = fun_control_init(
        _L_in=10, # 10: diabetes
        _L_out=1,
        _torchmetric="mean_squared_error",
        data_set=Diabetes(),
        core_model=NNLinearRegressor,
        hyperdict=LightHyperDict)
    X = get_default_hyperparameters_as_array(fun_control)
    config = get_one_config_from_X(X, fun_control)
    _L_in = fun_control["_L_in"]
    _L_out = fun_control["_L_out"]
    _torchmetric = fun_control["_torchmetric"]
    batch_size = 16
    model = fun_control["core_model"](**config, _L_in=_L_in, _L_out=_L_out, _torchmetric=_torchmetric)
    gradients, layer_sizes = get_gradients(model, fun_control=fun_control, batch_size=batch_size, device = "cpu")
    plot_nn_values_scatter(nn_values=gradients, layer_sizes=layer_sizes, nn_values_names="Weights")

Source code in spotpython/plot/xai.py

def plot_nn_values_scatter(
    nn_values,
    layer_sizes,
    nn_values_names="",
    absolute=True,
    cmap="gray",
    figsize=(6, 6),
    return_reshaped=False,
    show=True,
) -> dict:
    """
    Plot the values of a neural network including a marker for padding values.
    For simplicity, this example will annotate 'P' directly on the plot for padding values
    using a unique marker value approach.

    Args:
        nn_values (dict):
            A dictionary with the values of the neural network. For example,
            the weights, gradients, or activations.
        layer_sizes (dict):
            A dictionary with layer names as keys and their sizes as entries in NumPy array format.
        nn_values_names (str, optional):
            The name of the values. Defaults to "".
        absolute (bool, optional):
            Whether to use the absolute values. Defaults to True.
        cmap (str, optional):
            The colormap to use. Defaults to "gray".
        figsize (tuple, optional):
            The figure size. Defaults to (6, 6).
        return_reshaped (bool, optional):
            Whether to return the reshaped values. Defaults to False.
        show (bool, optional):
            Whether to show the plot. Defaults to True.

    Returns:
        dict: A dictionary with the reshaped values.

    Examples:
        >>> from spotpython.utils.init import fun_control_init
            from spotpython.data.diabetes import Diabetes
            from spotpython.light.regression.nn_linear_regressor import NNLinearRegressor
            from spotpython.hyperdict.light_hyper_dict import LightHyperDict
            from spotpython.hyperparameters.values import (
                    get_default_hyperparameters_as_array, get_one_config_from_X)
            from spotpython.hyperdict.light_hyper_dict import LightHyperDict
            # from spotpython.plot.xai import get_gradients
            fun_control = fun_control_init(
                _L_in=10, # 10: diabetes
                _L_out=1,
                _torchmetric="mean_squared_error",
                data_set=Diabetes(),
                core_model=NNLinearRegressor,
                hyperdict=LightHyperDict)
            X = get_default_hyperparameters_as_array(fun_control)
            config = get_one_config_from_X(X, fun_control)
            _L_in = fun_control["_L_in"]
            _L_out = fun_control["_L_out"]
            _torchmetric = fun_control["_torchmetric"]
            batch_size = 16
            model = fun_control["core_model"](**config, _L_in=_L_in, _L_out=_L_out, _torchmetric=_torchmetric)
            gradients, layer_sizes = get_gradients(model, fun_control=fun_control, batch_size=batch_size, device = "cpu")
            plot_nn_values_scatter(nn_values=gradients, layer_sizes=layer_sizes, nn_values_names="Weights")
    """
    if cmap == "gray":
        cmap = "gray"
    elif cmap == "BlueWhiteRed":
        cmap = colors.LinearSegmentedColormap.from_list("", ["blue", "white", "red"])
    elif cmap == "GreenYellowRed":
        cmap = colors.LinearSegmentedColormap.from_list("", ["green", "yellow", "red"])
    else:
        cmap = "viridis"

    res = {}
    padding_marker = np.nan  # Use NaN as a special marker for padding
    for layer, values in nn_values.items():
        if layer not in layer_sizes:
            print(f"Layer {layer} size not defined, skipping.")
            continue

        layer_shape = layer_sizes[layer]
        height, width = layer_shape if len(layer_shape) == 2 else (layer_shape[0], 1)  # Support linear layers

        print(f"{len(values)} values in Layer {layer}. Geometry: ({height}, {width})")

        total_size = height * width
        if len(values) < total_size:
            padding_needed = total_size - len(values)
            print(f"{padding_needed} padding values added to Layer {layer}.")
            values = np.append(values, [padding_marker] * padding_needed)  # Append padding values

        if absolute:
            reshaped_values = np.abs(values).reshape((height, width))
            # Mark padding values distinctly by setting them back to NaN
            reshaped_values[reshaped_values == np.abs(padding_marker)] = np.nan
        else:
            reshaped_values = values.reshape((height, width))

        _, ax = plt.subplots(figsize=figsize)
        cax = ax.imshow(reshaped_values, cmap=cmap, interpolation="nearest")

        for i in range(height):
            for j in range(width):
                if np.isnan(reshaped_values[i, j]):
                    ax.text(j, i, "P", ha="center", va="center", color="red")

        plt.colorbar(cax, label="Value")
        plt.title(f"{nn_values_names} Plot for {layer}")
        if show:
            plt.show()

        # Add reshaped_values to the dictionary res
        res[layer] = reshaped_values
    if return_reshaped:
        return res

sort_layers(data_dict)

Sorts a dictionary with keys in the format “Layer X” based on the numerical value X.

Parameters:

Name	Type	Description	Default
data_dict	dict	A dictionary with keys in the format “Layer X”.	required

Returns:

Name	Type	Description
dict	dict	A dictionary with the keys sorted based on the numerical value X.

Examples:

>>> data_dict = {
...     "Layer 1": [1, 2, 3],
...     "Layer 3": [4, 5, 6],
...     "Layer 2": [7, 8, 9]
... }
>>> sort_layers(data_dict)
{'Layer 1': [1, 2, 3], 'Layer 2': [7, 8, 9], 'Layer 3': [4,

Source code in spotpython/plot/xai.py

def sort_layers(data_dict) -> dict:
    """
    Sorts a dictionary with keys in the format "Layer X" based on the numerical value X.

    Args:
        data_dict (dict): A dictionary with keys in the format "Layer X".

    Returns:
        dict: A dictionary with the keys sorted based on the numerical value X.

    Examples:
        >>> data_dict = {
        ...     "Layer 1": [1, 2, 3],
        ...     "Layer 3": [4, 5, 6],
        ...     "Layer 2": [7, 8, 9]
        ... }
        >>> sort_layers(data_dict)
        {'Layer 1': [1, 2, 3], 'Layer 2': [7, 8, 9], 'Layer 3': [4,

    """
    # Use a lambda function to extract the number X from "Layer X" and sort based on that number
    sorted_items = sorted(data_dict.items(), key=lambda item: int(item[0].split()[1]))
    # Create a new dictionary from the sorted items
    sorted_dict = dict(sorted_items)
    return sorted_dict

visualize_activations_distributions(activations, net, color='C0', columns=4, bins=50, show=True)

Plots the distribution of activations for each layer that were determined via the get_activations function.

Parameters:

Name	Type	Description	Default
activations	dict	A dictionary containing activations for each layer.	required
net	Module	The neural network model.	required
color	str	The color for the plot histogram. Defaults to “C0”.	'C0'
columns	int	The number of columns for the subplots. Defaults to 4.	4
bins	int	The number of bins for the histogram. Defaults to 50.	50
show	bool	Whether to show the plot. Defaults to True.	True

Returns:

Type	Description
None	None

Source code in spotpython/plot/xai.py

def visualize_activations_distributions(activations, net, color="C0", columns=4, bins=50, show=True) -> None:
    """Plots the distribution of activations for each layer
        that were determined via the get_activations function.

    Args:
        activations (dict): A dictionary containing activations for each layer.
        net (nn.Module): The neural network model.
        color (str): The color for the plot histogram. Defaults to "C0".
        columns (int): The number of columns for the subplots. Defaults to 4.
        bins (int): The number of bins for the histogram. Defaults to 50.
        show (bool): Whether to show the plot. Defaults to True.

    Returns:
        None
    """
    rows = math.ceil(len(activations) / columns)
    fig, ax = plt.subplots(rows, columns, figsize=(columns * 2.7, rows * 2.5))
    fig_index = 0
    for key in activations:
        key_ax = ax[fig_index // columns][fig_index % columns]
        sns.histplot(data=activations[key], bins=bins, ax=key_ax, color=color, kde=True, stat="density")
        key_ax.set_title(f"Layer {key} - {net.layers[key].__class__.__name__}")
        fig_index += 1
    fig.suptitle("Activation distribution", fontsize=14)
    fig.subplots_adjust(hspace=0.4, wspace=0.4)
    if show:
        plt.show()
    plt.close()

visualize_gradient_distributions(net, fun_control, batch_size, device='cpu', color='C0', xlabel=None, stat='count', use_kde=True, columns=2, normalize=True)

Plot the gradients distributions of a neural network.

Parameters:

Name	Type	Description	Default
net	object	A neural network.	required
fun_control	dict	A dictionary with the function control.	required
batch_size	int	The batch size.	required
device	str	The device to use. Defaults to “cpu”.	'cpu'
color	str	The color to use. Defaults to “C0”.	'C0'
xlabel	str	The x label. Defaults to None.	None
stat	str	The stat. Defaults to “count”.	'count'
use_kde	bool	Whether to use kde. Defaults to True.	True
columns	int	The number of columns. Defaults to 2.	2
normalize	bool	Whether to normalize the input data. Defaults to True.	True

Returns:

Type	Description
None	None

Source code in spotpython/plot/xai.py

def visualize_gradient_distributions(
    net,
    fun_control,
    batch_size,
    device="cpu",
    color="C0",
    xlabel=None,
    stat="count",
    use_kde=True,
    columns=2,
    normalize=True,
) -> None:
    """
    Plot the gradients distributions of a neural network.

    Args:
        net (object):
            A neural network.
        fun_control (dict):
            A dictionary with the function control.
        batch_size (int, optional):
            The batch size.
        device (str, optional):
            The device to use. Defaults to "cpu".
        color (str, optional):
            The color to use. Defaults to "C0".
        xlabel (str, optional):
            The x label. Defaults to None.
        stat (str, optional):
            The stat. Defaults to "count".
        use_kde (bool, optional):
            Whether to use kde. Defaults to True.
        columns (int, optional):
            The number of columns. Defaults to 2.
        normalize (bool, optional):
            Whether to normalize the input data. Defaults to True.

    Returns:
        None

    """
    grads, _ = get_gradients(net, fun_control, batch_size, device, normalize=normalize)
    plot_nn_values_hist(grads, net, nn_values_names="Gradients", color=color, columns=columns)

visualize_gradients(net, fun_control, batch_size, absolute=True, cmap='gray', figsize=(6, 6), device='cpu', normalize=True)

Scatter plots the gradients of a neural network.

Parameters:

Name	Type	Description	Default
net	object	A neural network.	required
fun_control	dict	A dictionary with the function control.	required
batch_size	int	The batch size.	required
absolute	bool	Whether to use the absolute values. Defaults to True.	True
cmap	str	The colormap to use. Defaults to “gray”.	'gray'
figsize	tuple	The figure size. Defaults to (6, 6).	(6, 6)
device	str	The device to use. Defaults to “cpu”.	'cpu'
normalize	bool	Whether to normalize the input data. Defaults to True.	True

Returns:

Type	Description
None	None

Source code in spotpython/plot/xai.py

def visualize_gradients(
    net, fun_control, batch_size, absolute=True, cmap="gray", figsize=(6, 6), device="cpu", normalize=True
) -> None:
    """
    Scatter plots the gradients of a neural network.

    Args:
        net (object):
            A neural network.
        fun_control (dict):
            A dictionary with the function control.
        batch_size (int, optional):
            The batch size.
        absolute (bool, optional):
            Whether to use the absolute values. Defaults to True.
        cmap (str, optional):
            The colormap to use. Defaults to "gray".
        figsize (tuple, optional):
            The figure size. Defaults to (6, 6).
        device (str, optional):
            The device to use. Defaults to "cpu".
        normalize (bool, optional):
            Whether to normalize the input data. Defaults to True.

    Returns:
        None
    """
    grads, layer_sizes = get_gradients(
        net=net,
        fun_control=fun_control,
        batch_size=batch_size,
        device=device,
        normalize=normalize,
    )
    plot_nn_values_scatter(
        nn_values=grads,
        layer_sizes=layer_sizes,
        nn_values_names="Gradients",
        absolute=absolute,
        cmap=cmap,
        figsize=figsize,
    )

visualize_mean_activations(mean_activations, layer_sizes, absolute=True, cmap='gray', figsize=(6, 6))

Scatter plots the mean activations of a neural network for each layer. means_activations is a dictionary with the mean activations of the neural network computed via the get_activations function.

Parameters:

Name	Type	Description	Default
mean_activations	dict	A dictionary with the mean activations of the neural network.	required
layer_sizes	dict	A dictionary with layer names as keys and their sizes as entries in NumPy array format.	required
absolute	bool	Whether to use the absolute values. Defaults to True.	True
cmap	str	The colormap to use. Defaults to “gray”.	'gray'
figsize	tuple	The figure size. Defaults to (6, 6).	(6, 6)

Returns:

Type	Description
None	None

Examples:

>>> from spotpython.plot.xai import get_activations
    activations, mean_activations, layer_sizes = get_activations(net, fun_control)
    visualize_mean_activations(mean_activations, layer_sizes)

Source code in spotpython/plot/xai.py

def visualize_mean_activations(mean_activations, layer_sizes, absolute=True, cmap="gray", figsize=(6, 6)) -> None:
    """
    Scatter plots the mean activations of a neural network for each layer.
    means_activations is a dictionary with the mean activations of the neural network computed via
    the get_activations function.

    Args:
        mean_activations (dict):
            A dictionary with the mean activations of the neural network.
        layer_sizes (dict):
            A dictionary with layer names as keys and their sizes as entries in NumPy array format.
        absolute (bool, optional):
            Whether to use the absolute values. Defaults to True.
        cmap (str, optional):
            The colormap to use. Defaults to "gray".
        figsize (tuple, optional):
            The figure size. Defaults to (6, 6).

    Returns:
        None

    Examples:
        >>> from spotpython.plot.xai import get_activations
            activations, mean_activations, layer_sizes = get_activations(net, fun_control)
            visualize_mean_activations(mean_activations, layer_sizes)

    """
    plot_nn_values_scatter(
        nn_values=mean_activations,
        layer_sizes=layer_sizes,
        nn_values_names="Average Activations",
        absolute=absolute,
        cmap=cmap,
        figsize=figsize,
    )

visualize_weights(net, absolute=True, cmap='gray', figsize=(6, 6))

Scatter plots the weights of a neural network.

Parameters:

Name	Type	Description	Default
net	object	A neural network.	required
absolute	bool	Whether to use the absolute values. Defaults to True.	True
cmap	str	The colormap to use. Defaults to “gray”.	'gray'
figsize	tuple	The figure size. Defaults to (6, 6).	(6, 6)

Returns:

Type	Description
None	None

Examples:

>>> from spotpython.utils.init import fun_control_init
    from spotpython.data.diabetes import Diabetes
    from spotpython.light.regression.nn_linear_regressor import NNLinearRegressor
    from spotpython.hyperdict.light_hyper_dict import LightHyperDict
    from spotpython.hyperparameters.values import (
            get_default_hyperparameters_as_array, get_one_config_from_X)
    from spotpython.plot.xai import visualize_weights
    fun_control = fun_control_init(
        _L_in=10, # 10: diabetes
        _L_out=1,
        _torchmetric="mean_squared_error",
        data_set=Diabetes(),
        core_model=NNLinearRegressor,
        hyperdict=LightHyperDict)
    X = get_default_hyperparameters_as_array(fun_control)
    config = get_one_config_from_X(X, fun_control)
    _L_in = fun_control["_L_in"]
    _L_out = fun_control["_L_out"]
    _torchmetric = fun_control["_torchmetric"]
    batch_size = 16
    model = fun_control["core_model"](**config, _L_in=_L_in, _L_out=_L_out, _torchmetric=_torchmetric)
    visualize_weights(net=model, absolute=True, cmap="gray", figsize=(6, 6))

Source code in spotpython/plot/xai.py

def visualize_weights(net, absolute=True, cmap="gray", figsize=(6, 6)) -> None:
    """
    Scatter plots the weights of a neural network.

    Args:
        net (object):
            A neural network.
        absolute (bool, optional):
            Whether to use the absolute values. Defaults to True.
        cmap (str, optional):
            The colormap to use. Defaults to "gray".
        figsize (tuple, optional):
            The figure size. Defaults to (6, 6).

    Returns:
        None

    Examples:
        >>> from spotpython.utils.init import fun_control_init
            from spotpython.data.diabetes import Diabetes
            from spotpython.light.regression.nn_linear_regressor import NNLinearRegressor
            from spotpython.hyperdict.light_hyper_dict import LightHyperDict
            from spotpython.hyperparameters.values import (
                    get_default_hyperparameters_as_array, get_one_config_from_X)
            from spotpython.plot.xai import visualize_weights
            fun_control = fun_control_init(
                _L_in=10, # 10: diabetes
                _L_out=1,
                _torchmetric="mean_squared_error",
                data_set=Diabetes(),
                core_model=NNLinearRegressor,
                hyperdict=LightHyperDict)
            X = get_default_hyperparameters_as_array(fun_control)
            config = get_one_config_from_X(X, fun_control)
            _L_in = fun_control["_L_in"]
            _L_out = fun_control["_L_out"]
            _torchmetric = fun_control["_torchmetric"]
            batch_size = 16
            model = fun_control["core_model"](**config, _L_in=_L_in, _L_out=_L_out, _torchmetric=_torchmetric)
            visualize_weights(net=model, absolute=True, cmap="gray", figsize=(6, 6))
    """
    weights, layer_sizes = get_weights(net)
    plot_nn_values_scatter(
        nn_values=weights,
        layer_sizes=layer_sizes,
        nn_values_names="Weights",
        absolute=absolute,
        cmap=cmap,
        figsize=figsize,
    )

visualize_weights_distributions(net, color='C0', columns=2)

Plot the weights distributions of a neural network.

Parameters:

Name	Type	Description	Default
net	object	A neural network.	required
color	str	The color to use. Defaults to “C0”.	'C0'
columns	int	The number of columns. Defaults to 2.	2

Returns:

Type	Description
None	None

Source code in spotpython/plot/xai.py

def visualize_weights_distributions(net, color="C0", columns=2) -> None:
    """
    Plot the weights distributions of a neural network.

    Args:
        net (object):
            A neural network.
        color (str, optional):
            The color to use. Defaults to "C0".
        columns (int, optional):
            The number of columns. Defaults to 2.

    Returns:
        None

    """
    weights, _ = get_weights(net)
    plot_nn_values_hist(weights, net, nn_values_names="Weights", color=color, columns=columns)