Module fri

View Source
import logging

# noinspection PyUnresolvedReferences

from fri._version import __version__

logging.basicConfig(level=logging.INFO)

from enum import Enum

import fri.model

import arfs_gen

class ProblemName(Enum):

    """

    Enum which contains usable models for which feature relevance intervals can be computed in :func:`~FRI`.

    Values of enums contains class of model and data generation method found in external library `arfs_gen`.

    """

    CLASSIFICATION = [fri.model.Classification, arfs_gen.ProblemName.CLASSIFICATION]

    REGRESSION = [fri.model.Regression, arfs_gen.ProblemName.REGRESSION]

    ORDINALREGRESSION = [

        fri.model.OrdinalRegression,

        arfs_gen.ProblemName.ORDINALREGRESSION,

    ]

    LUPI_CLASSIFICATION = [

        fri.model.LUPI_Classification,

        arfs_gen.ProblemName.LUPI_CLASSIFICATION,

    ]

    LUPI_REGRESSION = [fri.model.LUPI_Regression, arfs_gen.ProblemName.LUPI_REGRESSION]

    LUPI_ORDREGRESSION = [

        fri.model.LUPI_OrdinalRegression,

        arfs_gen.ProblemName.LUPI_ORDREGRESSION,

    ]

NORMAL_MODELS = [

    ProblemName.CLASSIFICATION,

    ProblemName.REGRESSION,

    ProblemName.ORDINALREGRESSION,

]

LUPI_MODELS = [

    ProblemName.LUPI_CLASSIFICATION,

    ProblemName.LUPI_REGRESSION,

    ProblemName.LUPI_ORDREGRESSION,

]

from arfs_gen import genRegressionData, genClassificationData, genOrdinalRegressionData

def quick_generate(problemtype, **kwargs):

    "Overwrite arfs_gen method to handle different format of problemtype in fri"

    return arfs_gen.quick_generate(problemtype.value[1], **kwargs)

def genLupiData(problemname, **kwargs):

    "Overwrite arfs_gen method to handle different format of problemtype in fri"

    return arfs_gen.genLupiData(problemname.value[1], **kwargs)

from fri.main import FRIBase

from fri.plot import plot_intervals

class FRI(FRIBase):

    def __init__(

        self,

        problemName: object,

        random_state: object = None,

        n_jobs: int = 1,

        verbose: int = 0,

        n_param_search: int = 10,

        n_probe_features: int = 20,

        w_l1_slack: float = 0.001,

        loss_slack: float = 0.001,

        normalize: bool = True,

        **kwargs,

    ):

        """

        Main class to use `FRI` in programatic fashion following the scikit-learn paradigm.

        Parameters

        ----------

        problemName: `ProblemName` or str

            Type of Problem as enum value or explicit string (e.g. "classification")

        random_state: object or int

            Random state object or int

        n_jobs: int or None

            Number of threads or -1 for automatic.

        verbose: int

            Verbosity if > 0

        n_param_search: int

            Number of parameter samples in random search for hyperparameters.

        n_probe_features: int

            Number of probes to generate to improve feature selection.

        w_l1_slack: float

            Allow deviation from optimal L1 norm.

        loss_slack: float

            Allow deviation of loss.

        normalize: boolean

            Normalize relevace bounds to range of [0,1] depending on L1 norm.

        """

        self.problemName = problemName

        if isinstance(problemName, ProblemName):

            problemtype = problemName.value

        else:

            if problemName == "classification" or problemName == "class":

                problemtype = ProblemName.CLASSIFICATION

            elif problemName == "regression" or problemName == "reg":

                problemtype = ProblemName.REGRESSION

            elif problemName == "ordinalregression" or problemName == "ordreg":

                problemtype = ProblemName.ORDINALREGRESSION

            elif problemName == "lupi_classification" or problemName == "lupi_class":

                problemtype = ProblemName.LUPI_CLASSIFICATION

        if problemtype is None:

            names = [enum.name.lower() for enum in ProblemName]

            print(

                f"Parameter 'problemName' was not recognized or unset. Try one of {names}."

            )

        else:

            problem_class = problemtype[0]

            super().__init__(

                problem_class,

                random_state=random_state,

                n_jobs=n_jobs,

                verbose=verbose,

                n_param_search=n_param_search,

                n_probe_features=n_probe_features,

                w_l1_slack=w_l1_slack,

                loss_slack=loss_slack,

                normalize=normalize,

                **kwargs,

            )

__all__ = [

    "genRegressionData",

    "genClassificationData",

    "genOrdinalRegressionData",

    "quick_generate",

    "plot_intervals",

    "ProblemName",

    "FRI",

    "LUPI_MODELS",

    "NORMAL_MODELS",

    "genLupiData",

]

Sub-modules

Variables

LUPI_MODELS
NORMAL_MODELS

Functions

genClassificationData

def genClassificationData(
    n_samples: int = 100,
    n_features: int = 2,
    n_redundant: int = 0,
    n_strel: int = 1,
    n_repeated: int = 0,
    noise: float = 0.1,
    flip_y: float = 0,
    random_state: object = None,
    partition=None
)

Generate synthetic classification data

Parameters

n_samples : int, optional Number of samples n_features : int, optional Number of features n_redundant : int, optional Number of features which are part of redundant subsets (weakly relevant) n_strel : int, optional Number of features which are mandatory for the underlying model (strongly relevant) n_repeated : int, optional Number of features which are clones of existing ones. noise : float Added gaussian noise to data. Parameter scales Std of normal distribution. flip_y : float, optional Ratio of samples randomly switched to wrong class. random_state : object, optional Randomstate object used for generation.

Returns

X : array of shape [n_samples, n_features] The generated samples. y : array of shape [n_samples] The output classes.

Raises

ValueError Description ValueError Wrong parameters for specified amonut of features/samples.

Examples

X,y = genClassificationData(n_samples=200) Generating dataset with d=2,n=200,strongly=1,weakly=0, partition of weakly=None X.shape (200, 2) y.shape (200,)

View Source
def genClassificationData(

    n_samples: int = 100,

    n_features: int = 2,

    n_redundant: int = 0,

    n_strel: int = 1,

    n_repeated: int = 0,

    noise: float = 0.1,

    flip_y: float = 0,

    random_state: object = None,

    partition=None,

):

    """Generate synthetic classification data

    Parameters

    ----------

    n_samples : int, optional

        Number of samples

    n_features : int, optional

        Number of features

    n_redundant : int, optional

        Number of features which are part of redundant subsets (weakly relevant)

    n_strel : int, optional

        Number of features which are mandatory for the underlying model (strongly relevant)

    n_repeated : int, optional

        Number of features which are clones of existing ones.

    noise : float

        Added gaussian noise to data. Parameter scales Std of normal distribution.

    flip_y : float, optional

        Ratio of samples randomly switched to wrong class.

    random_state : object, optional

        Randomstate object used for generation.

    Returns

    -------

    X : array of shape [n_samples, n_features]

        The generated samples.

    y : array of shape [n_samples]

        The output classes.

    Raises

    ------

    ValueError

        Description

    ValueError

    Wrong parameters for specified amonut of features/samples.

    Examples

    ---------

    >>> X,y = genClassificationData(n_samples=200)

    Generating dataset with d=2,n=200,strongly=1,weakly=0, partition of weakly=None

    >>> X.shape

    (200, 2)

    >>> y.shape

    (200,)

    """

    _checkParam(**locals())

    random_state = check_random_state(random_state)

    X = np.zeros((n_samples, n_features))

    # Find partitions which defíne the weakly relevant subsets

    if partition is None and n_redundant > 0:

        partition = [n_redundant]

        part_size = 1

    elif partition is not None:

        part_size = len(partition)

    else:

        part_size = 0

    X_informative, Y = generate_binary_classification_problem(

        n_samples, n_strel + part_size, random_state

    )

    X = _fillVariableSpace(

        X_informative,

        random_state,

        n_features=n_features,

        n_redundant=n_redundant,

        n_strel=n_strel,

        n_repeated=n_repeated,

        partition=partition,

    )

    # Add target noise

    if flip_y > 0:

        n_flip = int(flip_y * n_samples)

        Y[random_state.choice(n_samples, n_flip)] *= -1

    # Add gaussian noise to data

    X = X + random_state.normal(size=(n_samples, n_features), scale=noise / X.std())

    return X, Y

genLupiData

def genLupiData(
    problemname,
    **kwargs
)

Overwrite arfs_gen method to handle different format of problemtype in fri

View Source
def genLupiData(problemname, **kwargs):

    "Overwrite arfs_gen method to handle different format of problemtype in fri"

    return arfs_gen.genLupiData(problemname.value[1], **kwargs)

genOrdinalRegressionData

def genOrdinalRegressionData(
    n_samples: int = 100,
    n_features: int = 2,
    n_redundant: int = 0,
    n_strel: int = 1,
    n_repeated: int = 0,
    noise: float = 0.0,
    random_state: object = None,
    partition=None,
    n_target_bins: int = 3
)

Generate ordinal regression data

Parameters

n_samples : int, optional Number of samples n_features : int, optional Number of features n_redundant : int, optional Number of features which are part of redundant subsets (weakly relevant) n_strel : int, optional Number of features which are mandatory for the underlying model (strongly relevant) n_repeated : int, optional Number of features which are clones of existing ones. noise : float, optional Noise of the created samples around ground truth. random_state : object, optional Randomstate object used for generation. n_target_bins : int, optional Number of bins in which the regressional target variable is split to form the ordinal classes

Returns

X : array of shape [n_samples, n_features] The generated samples. y : array of shape [n_samples] The output values (target).

Raises

ValueError Wrong parameters for specified amonut of features/samples.

View Source
def genOrdinalRegressionData(

    n_samples: int = 100,

    n_features: int = 2,

    n_redundant: int = 0,

    n_strel: int = 1,

    n_repeated: int = 0,

    noise: float = 0.0,

    random_state: object = None,

    partition=None,

    n_target_bins: int = 3,

):

    """

    Generate ordinal regression data

    Parameters

    ----------

    n_samples : int, optional

        Number of samples

    n_features : int, optional

        Number of features

    n_redundant : int, optional

        Number of features which are part of redundant subsets (weakly relevant)

    n_strel : int, optional

        Number of features which are mandatory for the underlying model (strongly relevant)

    n_repeated : int, optional

        Number of features which are clones of existing ones.

    noise : float, optional

        Noise of the created samples around ground truth.

    random_state : object, optional

        Randomstate object used for generation.

    n_target_bins : int, optional

        Number of bins in which the regressional target variable is split to form the ordinal classes

    Returns

    -------

    X : array of shape [n_samples, n_features]

        The generated samples.

    y : array of shape [n_samples]

        The output values (target).

    Raises

    ------

    ValueError

    Wrong parameters for specified amonut of features/samples.

    """

    _checkParam(**locals())

    random_state = check_random_state(random_state)

    if not n_target_bins > 1:

        raise ValueError("At least 2 target bins needed")

    # Use normal regression data as starting point

    X_regression, Y_regression = genRegressionData(

        n_samples=int(n_samples),

        n_features=int(n_features),

        n_redundant=int(n_redundant),

        n_strel=int(n_strel),

        n_repeated=int(n_repeated),

        noise=0,

        random_state=random_state,

        partition=partition,

    )

    bin_size = int(np.floor(n_samples / n_target_bins))

    rest = int(n_samples - (bin_size * n_target_bins))

    # Sort the target values and rearange the data accordingly

    sort_indices = np.argsort(Y_regression)

    X = X_regression[sort_indices]

    Y = Y_regression[sort_indices]

    # Assign ordinal classes as target values

    for i in range(n_target_bins):

        Y[bin_size * i : bin_size * (i + 1)] = i

    # Put non divisable rest into last bin

    if rest > 0:

        Y[-rest:] = n_target_bins - 1

    X, Y = shuffle(X, Y, random_state=random_state)

    # Add gaussian noise to data

    X = X + random_state.normal(size=(n_samples, n_features), scale=noise)

    return X, Y

genRegressionData

def genRegressionData(
    n_samples: int = 100,
    n_features: int = 2,
    n_redundant: int = 0,
    n_strel: int = 1,
    n_repeated: int = 0,
    noise: float = 0.0,
    random_state: object = None,
    partition=None
) -> object

Generate synthetic regression data

Parameters

n_samples : int, optional Number of samples n_features : int, optional Number of features n_redundant : int, optional Number of features which are part of redundant subsets (weakly relevant) n_strel : int, optional Number of features which are mandatory for the underlying model (strongly relevant) n_repeated : int, optional Number of features which are clones of existing ones. noise : float, optional Noise of the created samples around ground truth. random_state : object, optional Randomstate object used for generation.

Returns

X : array of shape [n_samples, n_features] The generated samples. y : array of shape [n_samples] The output values (target).

Raises

ValueError Wrong parameters for specified amonut of features/samples.

View Source
def genRegressionData(

    n_samples: int = 100,

    n_features: int = 2,

    n_redundant: int = 0,

    n_strel: int = 1,

    n_repeated: int = 0,

    noise: float = 0.0,

    random_state: object = None,

    partition=None,

) -> object:

    """Generate synthetic regression data

    Parameters

    ----------

    n_samples : int, optional

        Number of samples

    n_features : int, optional

        Number of features

    n_redundant : int, optional

        Number of features which are part of redundant subsets (weakly relevant)

    n_strel : int, optional

        Number of features which are mandatory for the underlying model (strongly relevant)

    n_repeated : int, optional

        Number of features which are clones of existing ones.

    noise : float, optional

        Noise of the created samples around ground truth.

    random_state : object, optional

        Randomstate object used for generation.

    Returns

    -------

    X : array of shape [n_samples, n_features]

        The generated samples.

    y : array of shape [n_samples]

        The output values (target).

    Raises

    ------

    ValueError

    Wrong parameters for specified amonut of features/samples.

    """

    _checkParam(**locals())

    random_state = check_random_state(random_state)

    # Find partitions which defíne the weakly relevant subsets

    if partition is None and n_redundant > 0:

        partition = [n_redundant]

        part_size = 1

    elif partition is not None:

        part_size = len(partition)

    else:

        part_size = 0

    n_informative = n_strel + part_size

    X = random_state.randn(n_samples, n_informative)

    ground_truth = np.zeros((n_informative, 1))

    ground_truth[:n_informative, :] = 0.3

    bias = 0

    y = np.dot(X, ground_truth) + bias

    # Add noise

    if noise > 0.0:

        y += random_state.normal(scale=noise, size=y.shape)

    X = _fillVariableSpace(

        X,

        random_state,

        n_features=n_features,

        n_redundant=n_redundant,

        n_strel=n_strel,

        n_repeated=n_repeated,

        partition=partition,

    )

    y = np.squeeze(y)

    return X, y

plot_intervals

def plot_intervals(
    model,
    ticklabels=None
)

Plot the relevance intervals.

Parameters

model : FRI model Needs to be fitted before. ticklabels : list of str, optional Strs for ticklabels on x-axis (features)

View Source
def plot_intervals(model, ticklabels=None):

    """Plot the relevance intervals.

    Parameters

    ----------

    model : FRI model

        Needs to be fitted before.

    ticklabels : list of str, optional

        Strs for ticklabels on x-axis (features)

    """

    if model.interval_ is not None:

        plotIntervals(

            model.interval_, ticklabels=ticklabels, classes=model.relevance_classes_

        )

    else:

        print("Intervals not computed. Try running fit() function first.")

quick_generate

def quick_generate(
    problemtype,
    **kwargs
)

Overwrite arfs_gen method to handle different format of problemtype in fri

View Source
def quick_generate(problemtype, **kwargs):

    "Overwrite arfs_gen method to handle different format of problemtype in fri"

    return arfs_gen.quick_generate(problemtype.value[1], **kwargs)

Classes

FRI

class FRI(
    problemName: object,
    random_state: object = None,
    n_jobs: int = 1,
    verbose: int = 0,
    n_param_search: int = 10,
    n_probe_features: int = 20,
    w_l1_slack: float = 0.001,
    loss_slack: float = 0.001,
    normalize: bool = True,
    **kwargs
)

Base class for all estimators in scikit-learn

Notes

All estimators should specify all the parameters that can be set at the class level in their __init__ as explicit keyword arguments (no *args or **kwargs).

View Source
class FRI(FRIBase):

    def __init__(

        self,

        problemName: object,

        random_state: object = None,

        n_jobs: int = 1,

        verbose: int = 0,

        n_param_search: int = 10,

        n_probe_features: int = 20,

        w_l1_slack: float = 0.001,

        loss_slack: float = 0.001,

        normalize: bool = True,

        **kwargs,

    ):

        """

        Main class to use `FRI` in programatic fashion following the scikit-learn paradigm.

        Parameters

        ----------

        problemName: `ProblemName` or str

            Type of Problem as enum value or explicit string (e.g. "classification")

        random_state: object or int

            Random state object or int

        n_jobs: int or None

            Number of threads or -1 for automatic.

        verbose: int

            Verbosity if > 0

        n_param_search: int

            Number of parameter samples in random search for hyperparameters.

        n_probe_features: int

            Number of probes to generate to improve feature selection.

        w_l1_slack: float

            Allow deviation from optimal L1 norm.

        loss_slack: float

            Allow deviation of loss.

        normalize: boolean

            Normalize relevace bounds to range of [0,1] depending on L1 norm.

        """

        self.problemName = problemName

        if isinstance(problemName, ProblemName):

            problemtype = problemName.value

        else:

            if problemName == "classification" or problemName == "class":

                problemtype = ProblemName.CLASSIFICATION

            elif problemName == "regression" or problemName == "reg":

                problemtype = ProblemName.REGRESSION

            elif problemName == "ordinalregression" or problemName == "ordreg":

                problemtype = ProblemName.ORDINALREGRESSION

            elif problemName == "lupi_classification" or problemName == "lupi_class":

                problemtype = ProblemName.LUPI_CLASSIFICATION

        if problemtype is None:

            names = [enum.name.lower() for enum in ProblemName]

            print(

                f"Parameter 'problemName' was not recognized or unset. Try one of {names}."

            )

        else:

            problem_class = problemtype[0]

            super().__init__(

                problem_class,

                random_state=random_state,

                n_jobs=n_jobs,

                verbose=verbose,

                n_param_search=n_param_search,

                n_probe_features=n_probe_features,

                w_l1_slack=w_l1_slack,

                loss_slack=loss_slack,

                normalize=normalize,

                **kwargs,

            )

Ancestors (in MRO)

  • fri.main.FRIBase
  • sklearn.base.BaseEstimator
  • sklearn.feature_selection._base.SelectorMixin
  • sklearn.base.TransformerMixin

Methods

constrained_intervals
def constrained_intervals(
    self,
    preset: dict
)

Method to return relevance intervals which are constrained using preset ranges or values.

Parameters

preset : dict like, {i:float} or {i:[float,float]} Keys denote feature index, values represent a fixed single value (float) or a range of allowed values (lower and upper bound).

Example: To set  feature 0 to a fixed value use

>>> preset = {0: 0.1}

or to use the minimum relevance bound

>>> preset[1] = self.interval_[1, 0]

Returns

array like Relevance bounds with user constraints

View Source
    def constrained_intervals(self, preset: dict):

        """

        Method to return relevance intervals which are constrained using preset ranges or values.

        Parameters

        ----------

        preset : dict like, {i:float} or {i:[float,float]}

            Keys denote feature index, values represent a fixed single value (float) or a range of allowed values (lower and upper bound).

            Example: To set  feature 0 to a fixed value use

            >>> preset = {0: 0.1}

            or to use the minimum relevance bound

            >>> preset[1] = self.interval_[1, 0]

        Returns

        -------

        array like

            Relevance bounds with user constraints

        """

        # Do we have intervals?

        check_is_fitted(self, "interval_")

        return self._relevance_bounds_computer.compute_multi_preset_relevance_bounds(

            preset=preset, lupi_features=self.lupi_features_

        )
fit
def fit(
    self,
    X,
    y,
    lupi_features=0,
    **kwargs
)

Method to fit model on data.

Parameters

X : numpy.ndarray y : numpy.ndarray lupi_features : int Amount of features which are considered privileged information in X. The data is expected to be structured in a way that all lupi features are at the end of the set. For example lupi_features=1 would denote the last column of X to be privileged. kwargs : dict Dictionary of additional keyword arguments depending on the model.

Returns

FRIBase

View Source
    def fit(self, X, y, lupi_features=0, **kwargs):

        """

        Method to fit model on data.

        Parameters

        ----------

        X : numpy.ndarray

        y : numpy.ndarray

        lupi_features : int

            Amount of features which are considered privileged information in `X`.

            The data is expected to be structured in a way that all lupi features are at the end of the set.

            For example `lupi_features=1` would denote the last column of `X` to be privileged.

        kwargs : dict

            Dictionary of additional keyword arguments depending on the `model`.

        Returns

        -------

        `FRIBase`

        """

        self.problem_object_ = self.problem_type(**self.other_args)

        self.lupi_features_ = lupi_features

        self.n_samples_ = X.shape[0]

        self.n_features_ = X.shape[1] - lupi_features

        self.optim_model_, best_score = self._fit_baseline(

            X, y, lupi_features, **kwargs

        )

        data = self.problem_object_.preprocessing((X, y), lupi_features=lupi_features)

        self._relevance_bounds_computer = RelevanceBoundsIntervals(

            data,

            self.problem_object_,

            self.optim_model_,

            self.random_state,

            self.n_probe_features,

            self.n_jobs,

            self.verbose,

            normalize=self.normalize,

        )

        if lupi_features == 0:

            (

                self.interval_,

                feature_classes,

            ) = self._relevance_bounds_computer.get_normalized_intervals()

        else:

            (

                self.interval_,

                feature_classes,

            ) = self._relevance_bounds_computer.get_normalized_lupi_intervals(

                lupi_features=lupi_features

            )

        self._get_relevance_mask(feature_classes)

        # Return the classifier

        return self
fit_transform
def fit_transform(
    self,
    X,
    y=None,
    **fit_params
)

Fit to data, then transform it.

Fits transformer to X and y with optional parameters fit_params and returns a transformed version of X.

Parameters

X : numpy array of shape [n_samples, n_features] Training set.

y : numpy array of shape [n_samples] Target values.

**fit_params : dict Additional fit parameters.

Returns

X_new : numpy array of shape [n_samples, n_features_new] Transformed array.

View Source
    def fit_transform(self, X, y=None, **fit_params):

        """

        Fit to data, then transform it.

        Fits transformer to X and y with optional parameters fit_params

        and returns a transformed version of X.

        Parameters

        ----------

        X : numpy array of shape [n_samples, n_features]

            Training set.

        y : numpy array of shape [n_samples]

            Target values.

        **fit_params : dict

            Additional fit parameters.

        Returns

        -------

        X_new : numpy array of shape [n_samples, n_features_new]

            Transformed array.

        """

        # non-optimized default implementation; override when a better

        # method is possible for a given clustering algorithm

        if y is None:

            # fit method of arity 1 (unsupervised transformation)

            return self.fit(X, **fit_params).transform(X)

        else:

            # fit method of arity 2 (supervised transformation)

            return self.fit(X, y, **fit_params).transform(X)
get_params
def get_params(
    self,
    deep=True
)

Get parameters for this estimator.

Parameters

deep : bool, default=True If True, will return the parameters for this estimator and contained subobjects that are estimators.

Returns

params : mapping of string to any Parameter names mapped to their values.

View Source
    def get_params(self, deep=True):

        """

        Get parameters for this estimator.

        Parameters

        ----------

        deep : bool, default=True

            If True, will return the parameters for this estimator and

            contained subobjects that are estimators.

        Returns

        -------

        params : mapping of string to any

            Parameter names mapped to their values.

        """

        out = dict()

        for key in self._get_param_names():

            try:

                value = getattr(self, key)

            except AttributeError:

                warnings.warn('From version 0.24, get_params will raise an '

                              'AttributeError if a parameter cannot be '

                              'retrieved as an instance attribute. Previously '

                              'it would return None.',

                              FutureWarning)

                value = None

            if deep and hasattr(value, 'get_params'):

                deep_items = value.get_params().items()

                out.update((key + '__' + k, val) for k, val in deep_items)

            out[key] = value

        return out
get_support
def get_support(
    self,
    indices=False
)

Get a mask, or integer index, of the features selected

Parameters

indices : boolean (default False) If True, the return value will be an array of integers, rather than a boolean mask.

Returns

support : array An index that selects the retained features from a feature vector. If indices is False, this is a boolean array of shape [# input features], in which an element is True iff its corresponding feature is selected for retention. If indices is True, this is an integer array of shape [# output features] whose values are indices into the input feature vector.

View Source
    def get_support(self, indices=False):

        """

        Get a mask, or integer index, of the features selected

        Parameters

        ----------

        indices : boolean (default False)

            If True, the return value will be an array of integers, rather

            than a boolean mask.

        Returns

        -------

        support : array

            An index that selects the retained features from a feature vector.

            If `indices` is False, this is a boolean array of shape

            [# input features], in which an element is True iff its

            corresponding feature is selected for retention. If `indices` is

            True, this is an integer array of shape [# output features] whose

            values are indices into the input feature vector.

        """

        mask = self._get_support_mask()

        return mask if not indices else np.where(mask)[0]
inverse_transform
def inverse_transform(
    self,
    X
)

Reverse the transformation operation

Parameters

X : array of shape [n_samples, n_selected_features] The input samples.

Returns

X_r : array of shape [n_samples, n_original_features] X with columns of zeros inserted where features would have been removed by :meth:transform.

View Source
    def inverse_transform(self, X):

        """

        Reverse the transformation operation

        Parameters

        ----------

        X : array of shape [n_samples, n_selected_features]

            The input samples.

        Returns

        -------

        X_r : array of shape [n_samples, n_original_features]

            `X` with columns of zeros inserted where features would have

            been removed by :meth:`transform`.

        """

        if issparse(X):

            X = X.tocsc()

            # insert additional entries in indptr:

            # e.g. if transform changed indptr from [0 2 6 7] to [0 2 3]

            # col_nonzeros here will be [2 0 1] so indptr becomes [0 2 2 3]

            it = self.inverse_transform(np.diff(X.indptr).reshape(1, -1))

            col_nonzeros = it.ravel()

            indptr = np.concatenate([[0], np.cumsum(col_nonzeros)])

            Xt = csc_matrix((X.data, X.indices, indptr),

                            shape=(X.shape[0], len(indptr) - 1), dtype=X.dtype)

            return Xt

        support = self.get_support()

        X = check_array(X, dtype=None)

        if support.sum() != X.shape[1]:

            raise ValueError("X has a different shape than during fitting.")

        if X.ndim == 1:

            X = X[None, :]

        Xt = np.zeros((X.shape[0], support.size), dtype=X.dtype)

        Xt[:, support] = X

        return Xt
def print_interval_with_class(
    self
)

Pretty print the relevance intervals and determined feature relevance class

View Source
    def print_interval_with_class(self):

        """

        Pretty print the relevance intervals and determined feature relevance class

        """

        output = ""

        if self.interval_ is None:

            output += "Model is not fitted."

        output += "############## Relevance bounds ##############\n"

        output += "feature: [LB -- UB], relevance class\n"

        for i in range(self.n_features_ + self.lupi_features_):

            if i == self.n_features_:

                output += "########## LUPI Relevance bounds\n"

            output += (

                f"{i:7}: [{self.interval_[i, 0]:1.1f} -- {self.interval_[i, 1]:1.1f}],"

            )

            output += f" {self.relevance_classes_string_[i]}\n"

        return output
score
def score(
    self,
    X,
    y
)

Using fitted model predict points for X and compare to truth y.

Parameters

X : numpy.ndarray y : numpy.ndarray

Returns

Model specific score (0 is worst, 1 is best)

View Source
    def score(self, X, y):

        """

        Using fitted model predict points for `X` and compare to truth `y`.

        Parameters

        ----------

        X : numpy.ndarray

        y : numpy.ndarray

        Returns

        -------

        Model specific score (0 is worst, 1 is best)

        """

        if self.optim_model_:

            return self.optim_model_.score(X, y)

        else:

            raise NotFittedError()
set_params
def set_params(
    self,
    **params
)

Set the parameters of this estimator.

The method works on simple estimators as well as on nested objects (such as pipelines). The latter have parameters of the form <component>__<parameter> so that it's possible to update each component of a nested object.

Parameters

**params : dict Estimator parameters.

Returns

self : object Estimator instance.

View Source
    def set_params(self, **params):

        """

        Set the parameters of this estimator.

        The method works on simple estimators as well as on nested objects

        (such as pipelines). The latter have parameters of the form

        ``<component>__<parameter>`` so that it's possible to update each

        component of a nested object.

        Parameters

        ----------

        **params : dict

            Estimator parameters.

        Returns

        -------

        self : object

            Estimator instance.

        """

        if not params:

            # Simple optimization to gain speed (inspect is slow)

            return self

        valid_params = self.get_params(deep=True)

        nested_params = defaultdict(dict)  # grouped by prefix

        for key, value in params.items():

            key, delim, sub_key = key.partition('__')

            if key not in valid_params:

                raise ValueError('Invalid parameter %s for estimator %s. '

                                 'Check the list of available parameters '

                                 'with `estimator.get_params().keys()`.' %

                                 (key, self))

            if delim:

                nested_params[key][sub_key] = value

            else:

                setattr(self, key, value)

                valid_params[key] = value

        for key, sub_params in nested_params.items():

            valid_params[key].set_params(**sub_params)

        return self
transform
def transform(
    self,
    X
)

Reduce X to the selected features.

Parameters

X : array of shape [n_samples, n_features] The input samples.

Returns

X_r : array of shape [n_samples, n_selected_features] The input samples with only the selected features.

View Source
    def transform(self, X):

        """Reduce X to the selected features.

        Parameters

        ----------

        X : array of shape [n_samples, n_features]

            The input samples.

        Returns

        -------

        X_r : array of shape [n_samples, n_selected_features]

            The input samples with only the selected features.

        """

        tags = self._get_tags()

        X = check_array(X, dtype=None, accept_sparse='csr',

                        force_all_finite=not tags.get('allow_nan', True))

        mask = self.get_support()

        if not mask.any():

            warn("No features were selected: either the data is"

                 " too noisy or the selection test too strict.",

                 UserWarning)

            return np.empty(0).reshape((X.shape[0], 0))

        if len(mask) != X.shape[1]:

            raise ValueError("X has a different shape than during fitting.")

        return X[:, safe_mask(X, mask)]

ProblemName

class ProblemName(
    /,
    *args,
    **kwargs
)

Enum which contains usable models for which feature relevance intervals can be computed in :func:~FRI. Values of enums contains class of model and data generation method found in external library arfs_gen.

View Source
class ProblemName(Enum):

    """

    Enum which contains usable models for which feature relevance intervals can be computed in :func:`~FRI`.

    Values of enums contains class of model and data generation method found in external library `arfs_gen`.

    """

    CLASSIFICATION = [fri.model.Classification, arfs_gen.ProblemName.CLASSIFICATION]

    REGRESSION = [fri.model.Regression, arfs_gen.ProblemName.REGRESSION]

    ORDINALREGRESSION = [

        fri.model.OrdinalRegression,

        arfs_gen.ProblemName.ORDINALREGRESSION,

    ]

    LUPI_CLASSIFICATION = [

        fri.model.LUPI_Classification,

        arfs_gen.ProblemName.LUPI_CLASSIFICATION,

    ]

    LUPI_REGRESSION = [fri.model.LUPI_Regression, arfs_gen.ProblemName.LUPI_REGRESSION]

    LUPI_ORDREGRESSION = [

        fri.model.LUPI_OrdinalRegression,

        arfs_gen.ProblemName.LUPI_ORDREGRESSION,

    ]

Ancestors (in MRO)

  • enum.Enum

Class variables

CLASSIFICATION
LUPI_CLASSIFICATION
LUPI_ORDREGRESSION
LUPI_REGRESSION
ORDINALREGRESSION
REGRESSION
name
value