lore_explainer package

Submodules

lore_explainer.datamanager module

lore_explainer.datamanager.get_features_map(feature_names, real_feature_names)

lore_explainer.datamanager.get_numeric_columns(df)

lore_explainer.datamanager.get_real_feature_names(rdf, numeric_columns, class_name)

lore_explainer.datamanager.one_hot_encoding(df, class_name)

lore_explainer.datamanager.prepare_adult_dataset(filename)

lore_explainer.datamanager.prepare_bank_dataset(filename)

lore_explainer.datamanager.prepare_churn_dataset(filename)

lore_explainer.datamanager.prepare_compass_dataset(filename, binary=False)

lore_explainer.datamanager.prepare_dataset(df, class_name)

lore_explainer.datamanager.prepare_fico_dataset(filename)

lore_explainer.datamanager.prepare_german_dataset(filename)

lore_explainer.datamanager.prepare_iris_dataset(filename)

lore_explainer.datamanager.prepare_medical_dataset(filename)

lore_explainer.datamanager.prepare_wine_dataset(filename)

lore_explainer.datamanager.prepare_yeast_dataset(filename)

lore_explainer.datamanager.remove_missing_values(df)

lore_explainer.decision_tree module

lore_explainer.decision_tree.is_leaf(inner_tree, index)

lore_explainer.decision_tree.learn_local_decision_tree(Z, Yb, weights, class_values, multi_label=False, one_vs_rest=False, cv=5, prune_tree=False)

lore_explainer.decision_tree.prune_duplicate_leaves(dt)

lore_explainer.decision_tree.prune_index(inner_tree, decisions, index=0)

lore_explainer.explanation module

class lore_explainer.explanation.Explanation

Bases: object

cstr()

rstr()

class lore_explainer.explanation.ExplanationEncoder(*, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)

Bases: json.encoder.JSONEncoder

Special json encoder for Rule types

default(obj)

Implement this method in a subclass such that it returns a serializable object for o, or calls the base implementation (to raise a TypeError).

For example, to support arbitrary iterators, you could implement default like this:

def default(self, o):
    try:
        iterable = iter(o)
    except TypeError:
        pass
    else:
        return list(iterable)
    # Let the base class default method raise the TypeError
    return JSONEncoder.default(self, o)

class lore_explainer.explanation.ImageExplanation(img, segments)

Bases: lore_explainer.explanation.Explanation

get_image_counterfactuals(hide_rest=False, num_features=None, min_importance=0.0)

get_image_rule(hide_rest=False, num_features=None, min_importance=0.0)

class lore_explainer.explanation.MultilabelExplanation

Bases: lore_explainer.explanation.Explanation

class lore_explainer.explanation.TextExplanation(text, indexed_text)

Bases: lore_explainer.explanation.Explanation

get_text_counterfactuals(num_features=None, min_importance=0.0)

get_text_rule(num_features=None, min_importance=0.0)

lore_explainer.explanation.json2explanation(obj)

lore_explainer.lorem module

class lore_explainer.lorem.LOREM(K, bb_predict, feature_names, class_name, class_values, numeric_columns, features_map, neigh_type='genetic', categorical_use_prob=True, continuous_fun_estimation=False, size=1000, ocr=0.1, multi_label=False, one_vs_rest=False, filter_crules=True, init_ngb_fn=True, kernel_width=None, kernel=None, random_state=None, verbose=False, **kwargs)

Bases: object

explain_instance(x, samples=1000, use_weights=True, metric=<function neuclidean>)

lore_explainer.lorem.default_kernel(d, kernel_width)

lore_explainer.neighgen module

class lore_explainer.neighgen.ClosestInstancesGenerator(bb_predict, feature_values, features_map, nbr_features, nbr_real_features, numeric_columns_index, ocr=0.1, K=None, rK=None, k=None, core_neigh_type='unified', alphaf=0.5, alphal=0.5, metric_features=<function neuclidean>, metric_labels='hamming', categorical_use_prob=True, continuous_fun_estimation=False, size=1000, verbose=False)

Bases: lore_explainer.neighgen.NeighborhoodGenerator

generate(x, num_samples=1000)

class lore_explainer.neighgen.GeneticGenerator(bb_predict, feature_values, features_map, nbr_features, nbr_real_features, numeric_columns_index, ocr=0.1, alpha1=0.5, alpha2=0.5, metric=<function neuclidean>, ngen=100, mutpb=0.2, cxpb=0.5, tournsize=3, halloffame_ratio=0.1, random_seed=None, verbose=False)

Bases: lore_explainer.neighgen.NeighborhoodGenerator

add_halloffame(population, halloffame)

clone(x)

fit(toolbox, population_size)

fitness_equal(x, x1)

fitness_notequal(x, x1)

generate(x, num_samples=1000)

mutate(toolbox, x)

random_init()

record_init(x)

setup_toolbox(x, evaluate, population_size)

setup_toolbox_noteq(x, x1, evaluate, population_size)

class lore_explainer.neighgen.GeneticProbaGenerator(bb_predict, feature_values, features_map, nbr_features, nbr_real_features, numeric_columns_index, ocr=0.1, alpha1=0.5, alpha2=0.5, metric=<function neuclidean>, ngen=100, mutpb=0.2, cxpb=0.5, tournsize=3, halloffame_ratio=0.1, bb_predict_proba=None, random_seed=None, verbose=False)

Bases: lore_explainer.neighgen.GeneticGenerator

fitness_equal(x, x1)

fitness_equal_proba(x, x1)

fitness_notequal(x, x1)

fitness_notequal_proba(x, x1)

class lore_explainer.neighgen.NeighborhoodGenerator(bb_predict, feature_values, features_map, nbr_features, nbr_real_features, numeric_columns_index, ocr=0.1)

Bases: object

balance_neigh(x, Z, num_samples)

abstract generate(x, num_samples=1000)

generate_synthetic_instance(from_z=None, mutpb=1.0)

class lore_explainer.neighgen.RandomGenerator(bb_predict, feature_values, features_map, nbr_features, nbr_real_features, numeric_columns_index, ocr=0.1)

Bases: lore_explainer.neighgen.NeighborhoodGenerator

generate(x, num_samples=1000)

class lore_explainer.neighgen.RandomGeneticGenerator(bb_predict, feature_values, features_map, nbr_features, nbr_real_features, numeric_columns_index, ocr=0.1, alpha1=0.5, alpha2=0.5, metric=<function neuclidean>, ngen=100, mutpb=0.2, cxpb=0.5, tournsize=3, halloffame_ratio=0.1, random_seed=None, verbose=False)

Bases: lore_explainer.neighgen.GeneticGenerator, lore_explainer.neighgen.RandomGenerator

generate(x, num_samples=1000)

class lore_explainer.neighgen.RandomGeneticProbaGenerator(bb_predict, feature_values, features_map, nbr_features, nbr_real_features, numeric_columns_index, ocr=0.1, alpha1=0.5, alpha2=0.5, metric=<function neuclidean>, ngen=100, mutpb=0.2, cxpb=0.5, tournsize=3, halloffame_ratio=0.1, bb_predict_proba=None, random_seed=None, verbose=False)

Bases: lore_explainer.neighgen.GeneticProbaGenerator, lore_explainer.neighgen.RandomGenerator

generate(x, num_samples=1000)

lore_explainer.rule module

class lore_explainer.rule.Condition(att, op, thr, is_continuous=True)

Bases: object

class lore_explainer.rule.ConditionEncoder(*, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)

Bases: json.encoder.JSONEncoder

Special json encoder for Condition types

default(obj)

Implement this method in a subclass such that it returns a serializable object for o, or calls the base implementation (to raise a TypeError).

For example, to support arbitrary iterators, you could implement default like this:

def default(self, o):
    try:
        iterable = iter(o)
    except TypeError:
        pass
    else:
        return list(iterable)
    # Let the base class default method raise the TypeError
    return JSONEncoder.default(self, o)

class lore_explainer.rule.NumpyEncoder(*, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)

Bases: json.encoder.JSONEncoder

Special json encoder for numpy types

default(obj)

Implement this method in a subclass such that it returns a serializable object for o, or calls the base implementation (to raise a TypeError).

For example, to support arbitrary iterators, you could implement default like this:

def default(self, o):
    try:
        iterable = iter(o)
    except TypeError:
        pass
    else:
        return list(iterable)
    # Let the base class default method raise the TypeError
    return JSONEncoder.default(self, o)

class lore_explainer.rule.Rule(premises, cons, class_name)

Bases: object

is_covered(x, feature_names)

class lore_explainer.rule.RuleEncoder(*, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)

Bases: json.encoder.JSONEncoder

Special json encoder for Rule types

default(obj)

Implement this method in a subclass such that it returns a serializable object for o, or calls the base implementation (to raise a TypeError).

For example, to support arbitrary iterators, you could implement default like this:

def default(self, o):
    try:
        iterable = iter(o)
    except TypeError:
        pass
    else:
        return list(iterable)
    # Let the base class default method raise the TypeError
    return JSONEncoder.default(self, o)

lore_explainer.rule.apply_counterfactual(x, delta, feature_names, features_map=None, features_map_inv=None, numeric_columns=None)

lore_explainer.rule.compact_premises(plist)

lore_explainer.rule.get_counterfactual_rules(x, y, dt, Z, Y, feature_names, class_name, class_values, numeric_columns, features_map, features_map_inv, bb_predict=None, multi_label=False)

lore_explainer.rule.get_depth(dt)

lore_explainer.rule.get_falsified_conditions(xd, crule)

lore_explainer.rule.get_rule(x, dt, feature_names, class_name, class_values, numeric_columns, multi_label=False)

lore_explainer.rule.get_rules(dt, feature_names, class_name, class_values, numeric_columns, multi_label=False)

lore_explainer.rule.json2cond(obj)

lore_explainer.rule.json2rule(obj)

lore_explainer.util module

lore_explainer.util.best_fit_distribution(data, bins=200, ax=None)

Model data by finding best fit distribution to data

lore_explainer.util.calculate_feature_values(X, numeric_columns_index, categorical_use_prob=False, continuous_fun_estimation=False, size=1000)

lore_explainer.util.estimate_nbr_bins(x)

lore_explainer.util.freedman_diaconis(x)

lore_explainer.util.get_distr_values(x, size=1000)

lore_explainer.util.multi_dt_predict(X, dt_list)

lore_explainer.util.multilabel2str(y, class_name)

lore_explainer.util.neuclidean(x, y)

lore_explainer.util.nmeandev(x, y)

lore_explainer.util.record2str(x, feature_names, numeric_columns)

lore_explainer.util.sigmoid(x, x0=0.5, k=10.0, L=1.0)

A logistic function or logistic curve is a common “S” shape (sigmoid curve

Parameters

• x – value to transform

• x0 – the x-value of the sigmoid’s midpoint

• k – the curve’s maximum value

• L – the steepness of the curve

Returns

sigmoid of x

lore_explainer.util.struges(x)

lore_explainer.util.vector2dict(x, feature_names)

Module contents