PRISMClassifier

class sklearn_nominal.PRISMClassifier(max_rule_length=9223372036854775807, max_rules_per_class=9223372036854775807, min_rule_support=10, max_error_per_rule=1, backend='pandas', class_weight=None)

A PRISM classifier.

[1] Chendrowska, J. (1987) PRISM: An Algorithm for Inducing Modular Rules. International Journal of Man-Machine Studies, vol 27, pp. 349-370.

[2] Chendrowska, J. (1990) Knowledge Acquisition for Expert Systems: Inducing Modular Rules from Examples. PhD Thesis, The Open University.

[3] Bramer, M. (2007) Principles of Data Mining, Springer Press.

Args:

max_rule_length (int, optional): The maximum number of conditions in a rule.

Analogous to the maximum height of a Tree model. Defaults to sys.maxsize.

max_rules_per_class (int, optional): Maximum number of rules for the model

per class. Analogous to the maximum number of leaves in a Tree model. Defaults to sys.maxsize.

min_rule_support (int, optional): Minimum number of samples that satisfy

the condition of a rule required to include that rule in the model. Analogous to the min_samples_leaf parameter for Tree models. Defaults to 10.

max_error_per_rule (float, optional): Maximum (absolute) error that the

rule can have. Defaults to 1.

backend (str, optional): The backend to use for computations. Defaults to DEFAULT_BACKEND. class_weight (dict or “balanced”, optional): Weights associated with classes

in the form {class_label: weight}. If None, all classes are assumed to have weight one. Defaults to None.

Attributes:

classes_ (ndarray of shape (n_classes,)): The classes labels. n_classes_ (int): The number of classes. n_features_in_ (int): Number of features seen during fit. feature_names_in_ (ndarray of shape (n_features_in_,)): Names of features

seen during fit. Defined only when X has feature names that are all strings.

n_outputs_ (int): The number of outputs when fit is performed. model_ (RuleModel): The underlying model object.

See Also:

TreeRegressor: A decision tree regressor with nominal support. NaiveBayesClassifier: A NaiveBayesClassifier with nominal support. CN2Classifier: A CN2Classifier classifier with nominal support. ZeroRClassifier: A ZeroR classifier with nominal support. OneRClassifier: A OneR classifier with nominal support.

Examples:

>>> from sklearn.datasets import fetch_openml
>>> df = fetch_openml("credit-g",version=2).frame
>>> x,y = df.iloc[:,0:-1], df.iloc[:,-1]
>>>
>>> from sklearn_nominal import PRISMClassifier
>>> model = PRISMClassifier()
>>> model.fit(x,y)
>>>
>>> from sklearn.metrics import accuracy_score
>>> y_pred = model.predict(x)
>>> print(accuracy_score(y,y_pred))
... 0.787

Methods

build_error(criterion, class_weight)	Builds the error function for the given criterion.
check_is_fitted()	Checks if the model has been fitted.
complexity()	Returns the complexity of the fitted model.
fit(x, y)	Fit the PRISM model according to the given training data.
get_class_weights(y)	Computes the class weights based on the input target.
get_dtypes(x)	Extracts and maps data types from the input.
get_feature_names()	Returns the names of the features seen during fit.
get_metadata_routing()	Get metadata routing of this object.
get_params([deep])	Get parameters for this estimator.
get_y(y)	Validates and encodes the target labels.
make_model(d, class_weight)	Creates the PRISM trainer for the model.
predict(x)	Perform classification on an array of test vectors X.
predict_proba(x)	Return probability estimates for the test data X.
pretty_print([class_names])	Returns a string representation of the fitted model.
score(X, y[, sample_weight])	Return the mean accuracy on the given test data and labels.
set_dtypes(x)	Sets and persists the data types based on the input.
set_fit_request(*[, x])	Request metadata passed to the fit method.
set_model(model)	Sets the underlying backend model and marks it as fitted.
set_params(**params)	Set the parameters of this estimator.
set_predict_proba_request(*[, x])	Request metadata passed to the predict_proba method.
set_predict_request(*[, x])	Request metadata passed to the predict method.
set_score_request(*[, sample_weight])	Request metadata passed to the score method.
set_sklearn_tags(tags)	Sets scikit-learn tags for the supervised nominal model.
validate_data_fit_classification(x, y)	Validates and transforms data for classification fitting.
validate_data_predict(x)	Validates and prepares input data for prediction.

build_error(criterion, class_weight)

Builds the error function for the given criterion.

Parameters:

criterionstr

The error criterion to use (e.g., “entropy”, “gini”, “gain_ratio”).

class_weightnp.ndarray

The class weights to be used by the error function.

Returns:

TargetError

An instance of the requested error function from sklearn_nominal.shared.

Raises:

ValueError

If the criterion is not recognized.

Return type:

TargetError

check_is_fitted()

Checks if the model has been fitted.

Raises:

NotFittedError

If the is_fitted_ attribute is not set or is False.

complexity()

Returns the complexity of the fitted model.

The definition of complexity is backend and model dependent. For trees, it typically represents the number of nodes.

Returns:

int or float

The complexity metric of the model.

Raises:

NotFittedError

If the model has not been fitted yet.

fit(x, y)

Fit the PRISM model according to the given training data.

The PRISM algorithm induces modular classification rules for each class independently. For each target class, it finds rules that cover as many samples of that class as possible while minimizing the inclusion of other classes.

Args:

x (pd.DataFrame or np.ndarray): The training input samples. y (np.ndarray): The target values (class labels) as integers or strings.

Returns:

self: Returns the instance itself.

get_class_weights(y)

Computes the class weights based on the input target.

Parameters:

yarray-like of shape (n_samples,)

The target labels.

Returns:

np.ndarray

The computed weights for each class, aligned with self.classes_.

get_dtypes(x)

Extracts and maps data types from the input.

This method identifies the data types of the input features to ensure they are correctly handled by the backend.

Parameters:

x{array-like, sparse matrix} of shape (n_samples, n_features)

The input data.

Returns:

dict or None

A dictionary mapping column names to data types if x is a DataFrame, otherwise None.

get_feature_names()

Returns the names of the features seen during fit.

Returns:

ndarray of str or None

The feature names, or None if they were not available during fit (e.g., if input was a numpy array).

get_metadata_routing()

Get metadata routing of this object.

Please check User Guide on how the routing mechanism works.

Returns:

routingMetadataRequest

A MetadataRequest encapsulating routing information.

get_params(deep=True)

Get parameters for this estimator.

Parameters:

deepbool, default=True

If True, will return the parameters for this estimator and contained subobjects that are estimators.

Returns:

paramsdict

Parameter names mapped to their values.

get_y(y)

Validates and encodes the target labels.

Parameters:

yarray-like of shape (n_samples,)

The target labels to encode.

Returns:

ndarray

The integer-encoded target labels.

make_model(d, class_weight)

Creates the PRISM trainer for the model.

Args:

d (Dataset): The dataset to train on. class_weight (np.ndarray): The weights for each class.

Returns:

PRISM: The PRISM trainer instance.

predict(x)

Perform classification on an array of test vectors X.

For each input sample, the algorithm evaluates the modular rules. If multiple rules match, ties are resolved (often by choosing the class with the highest rule confidence). If no rules match, the default majority class from the entire training set is predicted.

Args:

x (pd.DataFrame or np.ndarray): The input samples.

Returns:

np.ndarray: Predicted target values for X.

predict_proba(x)

Return probability estimates for the test data X.

Probabilities are estimated based on the class distribution of all matching modular rules for the input sample. If no rules match, the global class distribution of the training data is used.

Args:

x (pd.DataFrame or np.ndarray): The input samples.

Returns:

np.ndarray: Returns the probability of the sample for each class

in the model.

pretty_print(class_names=None)

Returns a string representation of the fitted model.

Delegates the visualization logic to the underlying backend model.

Parameters:

class_nameslist of str, optional

Names of the classes to use in the output. If None, default identifiers are used.

Returns:

str

A human-readable representation of the model.

Raises:

NotFittedError

If the model has not been fitted yet.

score(X, y, sample_weight=None)

Return the mean accuracy on the given test data and labels.

In multi-label classification, this is the subset accuracy which is a harsh metric since you require for each sample that each label set be correctly predicted.

Parameters:

Xarray-like of shape (n_samples, n_features)

Test samples.

yarray-like of shape (n_samples,) or (n_samples, n_outputs)

True labels for X.

sample_weightarray-like of shape (n_samples,), default=None

Sample weights.

Returns:

scorefloat

Mean accuracy of self.predict(X) w.r.t. y.

set_dtypes(x)

Sets and persists the data types based on the input.

This is called during fit to ensure that subsequent calls to predict can cast the input data to the same types, preserving nominal/numeric distinctions.

Parameters:

x{pd.DataFrame, np.ndarray, sparse matrix}

The input data to extract types from.

Raises:

ValueError

If the input type is not supported or if the input is not 2D.

set_fit_request(*, x: bool | None | str = '$UNCHANGED$') → PRISMClassifier

Request metadata passed to the fit method.

Note that this method is only relevant if enable_metadata_routing=True (see sklearn.set_config()). Please see User Guide on how the routing mechanism works.

The options for each parameter are:

• True: metadata is requested, and passed to fit if provided. The request is ignored if metadata is not provided.

• False: metadata is not requested and the meta-estimator will not pass it to fit.

• None: metadata is not requested, and the meta-estimator will raise an error if the user provides it.

• str: metadata should be passed to the meta-estimator with this given alias instead of the original name.

The default (sklearn.utils.metadata_routing.UNCHANGED) retains the existing request. This allows you to change the request for some parameters and not others.

Added in version 1.3.

Note

This method is only relevant if this estimator is used as a sub-estimator of a meta-estimator, e.g. used inside a Pipeline. Otherwise it has no effect.

Parameters:

xstr, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED

Metadata routing for x parameter in fit.

Returns:

selfobject

The updated object.

set_model(model)

Sets the underlying backend model and marks it as fitted.

Parameters:

modelsklearn_nominal.backend.core.Model

The trained model instance from the backend.

set_params(**params)

Set the parameters of this estimator.

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

Parameters:

**paramsdict

Estimator parameters.

Returns:

selfestimator instance

Estimator instance.

set_predict_proba_request(*, x: bool | None | str = '$UNCHANGED$') → PRISMClassifier

Request metadata passed to the predict_proba method.

Note that this method is only relevant if enable_metadata_routing=True (see sklearn.set_config()). Please see User Guide on how the routing mechanism works.

The options for each parameter are:

• True: metadata is requested, and passed to predict_proba if provided. The request is ignored if metadata is not provided.

• False: metadata is not requested and the meta-estimator will not pass it to predict_proba.

• None: metadata is not requested, and the meta-estimator will raise an error if the user provides it.

• str: metadata should be passed to the meta-estimator with this given alias instead of the original name.

The default (sklearn.utils.metadata_routing.UNCHANGED) retains the existing request. This allows you to change the request for some parameters and not others.

Added in version 1.3.

Note

This method is only relevant if this estimator is used as a sub-estimator of a meta-estimator, e.g. used inside a Pipeline. Otherwise it has no effect.

Parameters:

xstr, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED

Metadata routing for x parameter in predict_proba.

Returns:

selfobject

The updated object.

set_predict_request(*, x: bool | None | str = '$UNCHANGED$') → PRISMClassifier

Request metadata passed to the predict method.

Note that this method is only relevant if enable_metadata_routing=True (see sklearn.set_config()). Please see User Guide on how the routing mechanism works.

The options for each parameter are:

• True: metadata is requested, and passed to predict if provided. The request is ignored if metadata is not provided.

• False: metadata is not requested and the meta-estimator will not pass it to predict.

• None: metadata is not requested, and the meta-estimator will raise an error if the user provides it.

• str: metadata should be passed to the meta-estimator with this given alias instead of the original name.

The default (sklearn.utils.metadata_routing.UNCHANGED) retains the existing request. This allows you to change the request for some parameters and not others.

Added in version 1.3.

Note

This method is only relevant if this estimator is used as a sub-estimator of a meta-estimator, e.g. used inside a Pipeline. Otherwise it has no effect.

Parameters:

xstr, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED

Metadata routing for x parameter in predict.

Returns:

selfobject

The updated object.

set_score_request(*, sample_weight: bool | None | str = '$UNCHANGED$') → PRISMClassifier

Request metadata passed to the score method.

Note that this method is only relevant if enable_metadata_routing=True (see sklearn.set_config()). Please see User Guide on how the routing mechanism works.

The options for each parameter are:

• True: metadata is requested, and passed to score if provided. The request is ignored if metadata is not provided.

• False: metadata is not requested and the meta-estimator will not pass it to score.

• None: metadata is not requested, and the meta-estimator will raise an error if the user provides it.

• str: metadata should be passed to the meta-estimator with this given alias instead of the original name.

The default (sklearn.utils.metadata_routing.UNCHANGED) retains the existing request. This allows you to change the request for some parameters and not others.

Added in version 1.3.

Note

This method is only relevant if this estimator is used as a sub-estimator of a meta-estimator, e.g. used inside a Pipeline. Otherwise it has no effect.

Parameters:

sample_weightstr, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED

Metadata routing for sample_weight parameter in score.

Returns:

selfobject

The updated object.

set_sklearn_tags(tags)

Sets scikit-learn tags for the supervised nominal model.

Parameters:

tagsTags

The scikit-learn tags object to be modified.

validate_data_fit_classification(x, y)

Validates and transforms data for classification fitting.

This method performs the following transformations: 1. Validates x and y using scikit-learn’s validate_data. 2. Determines the unique classes and stores them in classes_. 3. Encodes y using LabelEncoder. 4. Calculates class weights based on the class_weight parameter. 5. Packages features and the encoded target into a backend-specific

Dataset (e.g., PandasDataset).

Parameters:

xarray-like of shape (n_samples, n_features)

The input features.

yarray-like of shape (n_samples,) or (n_samples, n_outputs)

The target labels.

Returns:

tuple

A tuple containing: - Dataset : The backend-specific dataset object. - np.ndarray : The computed class weights for each class in classes_.

Raises:

ValueError

If y contains only one unique class.

Return type:

tuple[Dataset, ndarray]

validate_data_predict(x)

Validates and prepares input data for prediction.

This method ensures the input features match the structure seen during training, handles feature name alignment, and restores data types.

Parameters:

xarray-like of shape (n_samples, n_features)

The input data to validate.

Returns:

pd.DataFrame

The validated data as a pandas DataFrame, with dtypes restored to match those observed during training.

Raises:

NotFittedError

If the model has not been fitted yet.

ValueError

If the input contains no samples or has inconsistent features.