decision_rules.classification

decision_rules.classification.metrics

Contains class for calculating rule metrics for classification rules

class decision_rules.classification.metrics.ClassificationRulesMetrics(rules: list[AbstractRule])

Bases: AbstractRulesMetrics

Class for calculating rule metrics for classification rules

calculate_p_value(coverage: Coverage | None = None, rule: ClassificationRule | None = None, y: ndarray | None = None) → float

Calculates Fisher’s exact test for confusion matrix

Parameters:: coverage (Coverage) – coverage
Returns:: p_value
Return type:: float

get_metrics_calculator(rule: ClassificationRule, X: DataFrame, y: Series) → dict[str, Callable[[], Any]]

Returns metrics calculator object in a form of dictionary where values are the non-parmetrized callables calculating specified metrics and keys are the names of those metrics.

Examples

>>> {
>>>  'p': lambda: rule.coverage.p,
>>>  'n': lambda: rule.coverage.n,
>>>  'P': lambda: rule.coverage.P,
>>>  'N': lambda: rule.coverage.N,
>>>  'coverage': lambda: measures.coverage(rule.coverage),
>>>  ...
>>> }

Parameters:

rule (AbstractRule) – rule
X (pd.DataFrame) – data
y (pd.Series) – labels

Returns:

metrics calculator object

Return type:

dict[str, Callable[[], Any]]

property supported_metrics: list[str]: Returns: list[str]: list of names of all supported metrics

decision_rules.classification.prediction

class decision_rules.classification.prediction.VotingPredictionStrategy(rules: list[AbstractRule], default_conclusion: AbstractConclusion)

Bases: PredictionStrategy

Voting prediction strategy for classification prediction.

decision_rules.classification.prediction_indicators

class decision_rules.classification.prediction_indicators.ClassificationGeneralPredictionIndicators

Bases: TypedDict

Accuracy: float

Balanced_accuracy: float

Cohen_kappa: float

Confusion_matrix: dict

Covered_by_prediction: int

F1_macro: float

F1_micro: float

F1_weighted: float

G_mean_macro: float

G_mean_micro: float

G_mean_weighted: float

Not_covered_by_prediction: int

Recall_macro: float

Recall_micro: float

Recall_weighted: float

Specificity: float

class decision_rules.classification.prediction_indicators.ClassificationPredictionIndicators

Bases: TypedDict

for_classes: dict[str, ClassificationPredictionIndicatorsForClass]

general: ClassificationGeneralPredictionIndicators

type_of_problem: str

class decision_rules.classification.prediction_indicators.ClassificationPredictionIndicatorsForClass

Bases: TypedDict

Confusion_matrix: dict

F1_score: float

FN: int

FP: int

G_mean: float

LR_minus: float

LR_plus: float

MCC: float

NPV: float

Odd_ratio: float

PPV: float

Recall: float

Relative_risk: float

Specificity: float

TN: int

TP: int

decision_rules.classification.prediction_indicators.calculate_class_indicators_classification(cls: Any, y_true: list[Any], y_pred: list[Any]) → ClassificationPredictionIndicatorsForClass

Calculate prediction indicators for a specific class.

Parameters:

cls (Any) – The class for which to calculate the indicators.
y_true (list[Any]) – The true labels.
y_pred (List[Any]) – The predicted labels.

Returns:

A dictionary representing the calculated prediction indicators for the class.

Return type:

ClassificationPredictionIndicatorsForClass

decision_rules.classification.prediction_indicators.calculate_for_classification(y_true: list[Any], y_pred: list[Any], calculate_only_for_covered_examples: bool = False) → ClassificationPredictionIndicators

Calculate prediction indicators for classification problem.

Parameters:

y_true (np.ndarray) – Array containing the actual class labels.
y_pred (np.ndarray) – Array containing the predicted class labels.
calculate_only_for_covered_examples (bool, optional) – If true, it will calculate indicators only for the examples where prediction was not empty. Otherwise, it will calculate indicators for all the examples. Defaults to False.

Returns:

A dictionary containing various prediction indicators, including indicators for individual classes.

Return type:

ClassificationPredictionIndicators

decision_rules.classification.rule

Contains classification rule and conclusion classes.

class decision_rules.classification.rule.ClassificationConclusion(value: str | int, column_name: str)

Bases: AbstractConclusion

Conclusion part of the classification rule

Parameters:: AbstractConclusion (_type_)

is_empty() → bool: Returns whether conclusion is empty or not.

static make_empty(column_name: str) → ClassificationConclusion

Creates empty conclusion. Use it when you don’t want to use default conclusion during prediction.

Parameters:: column_name (str) – decision column name
Returns:: empty conclusion
Return type:: AbstractConclusion

positives_mask(y: ndarray) → ndarray

Calculates positive examples mask

Parameters:

y (np.ndarray)

Returns:

1 dimensional numpy array of booleans specifying: whether given examples are consistent with the conclusion.

Return type:

np.ndarray

class decision_rules.classification.rule.ClassificationRule(premise: AbstractCondition, conclusion: ClassificationConclusion, column_names: list[str])

Bases: AbstractRule

Classification decision rule.

decision_rules.classification.ruleset

Contains classification ruleset class.

class decision_rules.classification.ruleset.ClassificationRuleSet(rules: list[ClassificationRule])

Bases: AbstractRuleSet

Classification ruleset allowing to perform prediction on data

calculate_attribute_importances(condition_importances: dict[str, dict[str, float]]) → dict[str, dict[str, float]]

Calculate importances of attriubtes in RuleSet based on conditions importances

Parameters:

Union[dict[str (condition_importances) – condition importances
float] – condition importances
dict[str – condition importances
dict[str – condition importances
float]]] – condition importances

Returns:

attribute importances, in the case of classification additionally: returns information about class dict[str, dict[str, float]]:

Return type:

dict[str, float]

calculate_condition_importances(X: DataFrame, y: Series, measure: Callable[[Coverage], float]) → dict[str, dict[str, float]]

Calculate importances of conditions in RuleSet

Parameters:

X (pd.DataFrame)
y (pd.Series)
measure (Callable[[Coverage], float]) – measure used to count importance

Returns:

condition importances, in the case of classification additionally returns information about class dict[str, dict[str, float]]:

Return type:

dict[str, float]

calculate_p_values(*args) → list

get_default_prediction_strategy_class() → Type[PredictionStrategy]

Returns default prediction strategy class used when user doesn’t specify any.

Returns:

class implementing PredictionStrategy: interface

Return type:

Type[PredictionStrategy]

get_metrics_object_instance() → AbstractRulesMetrics: Returns metrics object instance.

property prediction_strategies_choice: dict[str, Type[PredictionStrategy]]

Specifies prediction strategies available for this model.

Returns:

Dictionary containing available prediction: strategies. Keys are prediction strategies names and values are classes implementing PredictionStrategy interface for this model.

Return type:

dict[str, Type[PredictionStrategy]]

update(X_train: DataFrame, y_train: Series, measure: Callable[[Coverage], float]) → ndarray

Updates ruleset using training dataset. This method should be called both after creation of new ruleset or after manipulating any of its rules or internal conditions. This method recalculates rules coverages and voting weights making it ready for prediction

Parameters:

X_train (pd.DataFrame)
y_train (pd.Series)
measure (Callable[[Coverage], float]) – voting measure function

Raises:

ValueError – if called on empty ruleset with no rules

update_using_coverages(coverages_info: dict[str, ClassificationCoverageInfodict], measure: Callable[[Coverage], float], columns_names: list[str] = None)