def __init__(self,
kernel_width=25,
verbose=False,
class_names=None,
feature_selection='auto',
signal_names=["not specified"]):
"""Init function.
Args:
kernel_width: kernel width for the exponential kernel
verbose: if true, print local prediction values from linear model
class_names: list of class names, ordered according to whatever the
classifier is using. If not present, class names will be '0',
'1', ...
feature_selection: feature selection method. can be
'forward_selection', 'lasso_path', 'none' or 'auto'.
signal_names: list of strings, names of signals
"""
# exponential kernel
def kernel(d):
return np.sqrt(np.exp(-(d**2) / kernel_width**2))
self.base = lime_base.LimeBase(kernel, verbose)
self.class_names = class_names
self.feature_selection = feature_selection
self.signal_names = signal_names
def __init__(self,
dist,
num_var,
kernel_width=.25,
verbose=False,
feature_selection='auto',
random_state=None):
"""Init function.
Args:
dist: sampling distance
kernel_width: kernel width for the exponential kernel.
If None, defaults to sqrt(number of columns) * 0.75
verbose: if true, print local prediction values from linear model
feature_selection: feature selection method. can be
'forward_selection', 'lasso_path', 'none' or 'auto'.
See function 'explain_instance_with_data' in lime_base.py for
details on what each of the options does.
random_state: an integer or numpy.RandomState that will be used to
generate random numbers. If None, the random state will be
initialized using the internal numpy seed.
"""
kernel_width = float(kernel_width)
def kernel(d):
return np.sqrt(np.exp(-(d**2) / kernel_width**2))
self.random_state = check_random_state(random_state)
self.feature_selection = feature_selection
self.base = lime_base.LimeBase(kernel,
verbose,
random_state=self.random_state)
self.dist = dist
self.verbose = verbose
self.num_var = num_var
def __init__(self,
training_df,
feature_names,
feature_map,
mode="classification",
kernel_width=25,
verbose=False,
class_names=None,
feature_selection='auto',
random_state=None):
# exponential kernel
def kernel(d):
return np.sqrt(np.exp(-(d**2) / kernel_width**2))
self.random_state = check_random_state(random_state)
self.base = lime_base.LimeBase(kernel,
verbose,
random_state=self.random_state)
self.feature_names = list(feature_names)
self.feature_map = feature_map
self.mode = mode
self.class_names = class_names
self.feature_selection = feature_selection
self.categorical_features = list(range(feature_names.shape[0]))
self.n_rows = training_df.shape[0]
self.training_df = training_df
self.user_freq = training_df['user_id'].value_counts(normalize=True)
self.item_freq = training_df['item_id'].value_counts(normalize=True)
def __init__(self,
kernel_width=.25,
kernel=None,
verbose=False,
feature_selection='auto',
random_state=None):
"""Init function.
Args:
kernel_width: kernel width for the exponential kernel.
If None, defaults to sqrt(number of columns) * 0.75.
kernel: similarity kernel that takes euclidean distances and kernel
width as input and outputs weights in (0,1). If None, defaults to
an exponential kernel.
verbose: if true, print local prediction values from linear model
feature_selection: feature selection method. can be
'forward_selection', 'lasso_path', 'none' or 'auto'.
See function 'explain_instance_with_data' in lime_base.py for
details on what each of the options does.
random_state: an integer or numpy.RandomState that will be used to
generate random numbers. If None, the random state will be
initialized using the internal numpy seed.
"""
kernel_width = float(kernel_width)
if kernel is None:
def kernel(d, kernel_width):
return np.sqrt(np.exp(-(d**2) / kernel_width**2))
kernel_fn = partial(kernel, kernel_width=kernel_width)
self.random_state = check_random_state(random_state)
self.feature_selection = feature_selection
self.base = lime_base.LimeBase(kernel_fn,
verbose,
random_state=self.random_state)
def __init__(self,
training_data,
feature_types=None,
feature_names=None,
kernel_width=3,
verbose=False,
class_names=None,
feature_selection='auto'):
self.feature_types = feature_types
if self.feature_types is None:
self.feature_types = {}
if 'categorical' not in self.feature_types:
self.feature_types['categorical'] = []
if 'countable' not in self.feature_types:
self.feature_types['countable'] = []
kernel = lambda d: np.sqrt(np.exp(-(d**2) / kernel_width**2))
self.base = lime_base.LimeBase(kernel, verbose)
self.scaler = None
self.feature_names = feature_names
self.class_names = class_names
self.scaler = sklearn.preprocessing.StandardScaler(with_mean=False)
self.scaler.fit(training_data)
self.feature_values = {}
self.feature_frequencies = {}
for feature in feature_types['categorical']:
feature_count = collections.defaultdict(lambda: 0.0)
for value in training_data[:, feature]:
feature_count[value] += 1
values, frequencies = map(list, zip(*(feature_count.items())))
self.feature_values[feature] = values
self.feature_frequencies[feature] = (np.array(frequencies) /
sum(frequencies))
self.scaler.mean_[feature] = 0
self.scaler.scale_[feature] = 1