Skip to content

Recommender

XaiRecommender

Recommender class that suggests explainers and evaluation metrics based on the user's input. The recommender analyzes the model architecture and the selected modality to provide the most suitable explainers and detected architecture.

Source code in pnpxai/core/recommender/recommender.py 
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
class XaiRecommender:
    """
    Recommender class that suggests explainers and evaluation metrics based on the user's input. The recommender
    analyzes the model architecture and the selected modality to provide the most suitable explainers and detected architecture.        
    """

    def __init__(self):
        self.architecture_to_explainers_map = self._build_architecture_to_explainers_map()

    def _build_architecture_to_explainers_map(self):
        map_data = {}
        for explainer_type in AVAILABLE_EXPLAINERS:
            for arch in explainer_type.SUPPORTED_MODULES:
                if arch not in map_data:
                    map_data[arch] = set()
                map_data[arch].add(explainer_type)
        return RecommendationMap(map_data, ["architecture", "explainers"])

    def _filter_explainers(
        self,
        modality: Union[Modality, Tuple[Modality]],
        arch: Set[ModuleType],
    ) -> List[Type[Explainer]]:
        """
        Filters explainers based on the user's question, task, and model architecture.

        Args:
        - modaltiy (Union[Modality, Tuple[Modality]]): Modality of the input data (e.g., ImageModality, TextModality, TabularModality).
        - arch (Set[ModuleType]): Set of neural network module types (e.g., nn.Linear, nn.Conv2d).

        Returns:
        - List[Set[Type[Explainer]]]: List of compatible explainers based on the given inputs.
        """
        # question_to_method = QUESTION_TO_EXPLAINERS.get(question, set())
        explainers = []
        for mod in format_into_tuple(modality):
            modality_to_explainers = set(mod.EXPLAINERS)
            arch_to_explainers = set.union(*(
                self.architecture_to_explainers_map.data.get(
                    module_type, set())
                for module_type in arch
            ))
            explainers_mod = set.intersection(
                modality_to_explainers, arch_to_explainers)
            if arch.difference({Convolution, Linear}):
                explainers_mod = explainers_mod.difference(
                    CAM_BASED_EXPLAINERS)
            explainers.append(explainers_mod)
        explainers = set.intersection(*explainers)
        return list(explainers)

    def recommend(self, modality: Union[Modality, Tuple[Modality]], model: Model) -> RecommenderOutput:
        """
        Recommends explainers and evaluation metrics based on the user's input.

        Args:
        - modality (Union[Modality], Tuple[Modality]): Modality of the input data (e.g., ImageModality, TextModality, TabularModality).
        - model (Model): Neural network module, used for the architecture-based filtering.

        Returns:
        - RecommenderOutput: An object containing recommended explainers.
        """
        arch = detect_model_architecture(model)
        explainers = self._filter_explainers(modality, arch)
        # metrics = self._suggest_metrics(explainers)
        return RecommenderOutput(
            detected_architectures=arch,
            explainers=_sort_by_name(explainers),
            # metrics=_sort_by_name(metrics),
        )

recommend(modality, model)

Recommends explainers and evaluation metrics based on the user's input.

Args: - modality (Union[Modality], Tuple[Modality]): Modality of the input data (e.g., ImageModality, TextModality, TabularModality). - model (Model): Neural network module, used for the architecture-based filtering.

Returns: - RecommenderOutput: An object containing recommended explainers.

Source code in pnpxai/core/recommender/recommender.py 
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
def recommend(self, modality: Union[Modality, Tuple[Modality]], model: Model) -> RecommenderOutput:
    """
    Recommends explainers and evaluation metrics based on the user's input.

    Args:
    - modality (Union[Modality], Tuple[Modality]): Modality of the input data (e.g., ImageModality, TextModality, TabularModality).
    - model (Model): Neural network module, used for the architecture-based filtering.

    Returns:
    - RecommenderOutput: An object containing recommended explainers.
    """
    arch = detect_model_architecture(model)
    explainers = self._filter_explainers(modality, arch)
    # metrics = self._suggest_metrics(explainers)
    return RecommenderOutput(
        detected_architectures=arch,
        explainers=_sort_by_name(explainers),
        # metrics=_sort_by_name(metrics),
    )