pred_labels=None, title=None, normalize=False,

hide_zeros=False, x_tick_rotation=0, ax=None,

figsize=None, cmap='Blues', title_fontsize="large",

text_fontsize="medium"):

"""Generates confusion matrix plot from predictions and true labels

if ax is None:

fig, ax = plt.subplots(1, 1, figsize=figsize)

cm = confusion_matrix(y_true, y_pred, labels=labels)

if labels is None:

classes = unique_labels(y_true, y_pred)

else:

classes = np.asarray(labels)

if normalize:

cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]

cm = np.around(cm, decimals=2)

cm[np.isnan(cm)] = 0.0

if true_labels is None:

true_classes = classes

else:

validate_labels(classes, true_labels, "true_labels")

true_label_indexes = np.in1d(classes, true_labels)

true_classes = classes[true_label_indexes]

cm = cm[true_label_indexes]

if pred_labels is None:

pred_classes = classes

else:

validate_labels(classes, pred_labels, "pred_labels")

pred_label_indexes = np.in1d(classes, pred_labels)

pred_classes = classes[pred_label_indexes]

cm = cm[:, pred_label_indexes]

if title:

ax.set_title(title, fontsize=title_fontsize)

elif normalize:

ax.set_title('Normalized Confusion Matrix', fontsize=title_fontsize)

else:

ax.set_title('Confusion Matrix', fontsize=title_fontsize)

image = ax.imshow(cm, interpolation='nearest', cmap=plt.cm.get_cmap(cmap))

plt.colorbar(mappable=image)

x_tick_marks = np.arange(len(pred_classes))

y_tick_marks = np.arange(len(true_classes))

ax.set_xticks(x_tick_marks)

ax.set_xticklabels(pred_classes, fontsize=text_fontsize,

rotation=x_tick_rotation)

ax.set_yticks(y_tick_marks)

ax.set_yticklabels(true_classes, fontsize=text_fontsize)

thresh = cm.max() / 2.

for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):

if not (hide_zeros and cm[i, j] == 0):

ax.text(j, i, cm[i, j],

horizontalalignment="center",

verticalalignment="center",

fontsize=text_fontsize,

color="white" if cm[i, j] > thresh else "black")

ax.set_ylabel('True label', fontsize=text_fontsize)

ax.set_xlabel('Predicted label', fontsize=text_fontsize)

ax.grid('off')

curves=('micro', 'macro', 'each_class'),

ax=None, figsize=None, cmap='nipy_spectral',

title_fontsize="large", text_fontsize="medium"):

"""Generates the ROC curves from labels and predicted scores/probabilities

y_true = np.array(y_true)

y_probas = np.array(y_probas)

if 'micro' not in curves and 'macro' not in curves and \

'each_class' not in curves:

raise ValueError('Invalid argument for curves as it '

'only takes "micro", "macro", or "each_class"')

classes = np.unique(y_true)

probas = y_probas

fpr = dict()

tpr = dict()

roc_auc = dict()

for i in range(len(classes)):

fpr[i], tpr[i], _ = roc_curve(y_true, probas[:, i],

pos_label=classes[i])

roc_auc[i] = auc(fpr[i], tpr[i])

# Compute micro-average ROC curve and ROC area

micro_key = 'micro'

i = 0

while micro_key in fpr:

i += 1

micro_key += str(i)

y_true = label_binarize(y_true, classes=classes)

if len(classes) == 2:

y_true = np.hstack((1 - y_true, y_true))

fpr[micro_key], tpr[micro_key], _ = roc_curve(y_true.ravel(),

probas.ravel())

roc_auc[micro_key] = auc(fpr[micro_key], tpr[micro_key])

# Compute macro-average ROC curve and ROC area

# First aggregate all false positive rates

all_fpr = np.unique(np.concatenate([fpr[x] for x in range(len(classes))]))

# Then interpolate all ROC curves at this points

mean_tpr = np.zeros_like(all_fpr)

for i in range(len(classes)):

mean_tpr += interp(all_fpr, fpr[i], tpr[i])

# Finally average it and compute AUC

mean_tpr /= len(classes)

macro_key = 'macro'

i = 0

while macro_key in fpr:

i += 1

macro_key += str(i)

fpr[macro_key] = all_fpr

tpr[macro_key] = mean_tpr

roc_auc[macro_key] = auc(fpr[macro_key], tpr[macro_key])

if ax is None:

fig, ax = plt.subplots(1, 1, figsize=figsize)

ax.set_title(title, fontsize=title_fontsize)

if 'each_class' in curves:

for i in range(len(classes)):

color = plt.cm.get_cmap(cmap)(float(i) / len(classes))

ax.plot(fpr[i], tpr[i], lw=2, color=color,

label='ROC curve of class {0} (area = {1:0.2f})'

''.format(classes[i], roc_auc[i]))

if 'micro' in curves:

ax.plot(fpr[micro_key], tpr[micro_key],

label='micro-average ROC curve '

'(area = {0:0.2f})'.format(roc_auc[micro_key]),

color='deeppink', linestyle=':', linewidth=4)

if 'macro' in curves:

ax.plot(fpr[macro_key], tpr[macro_key],

label='macro-average ROC curve '

'(area = {0:0.2f})'.format(roc_auc[macro_key]),

color='navy', linestyle=':', linewidth=4)

ax.plot([0, 1], [0, 1], 'k--', lw=2)

ax.set_xlim([0.0, 1.0])

ax.set_ylim([0.0, 1.05])

ax.set_xlabel('False Positive Rate', fontsize=text_fontsize)

ax.set_ylabel('True Positive Rate', fontsize=text_fontsize)

ax.tick_params(labelsize=text_fontsize)

ax.legend(loc='lower right', fontsize=text_fontsize)

ax=None, figsize=None, title_fontsize="large",

text_fontsize="medium"):

"""Generates the KS Statistic plot from labels and scores/probabilities

y_true = np.array(y_true)

y_probas = np.array(y_probas)

classes = np.unique(y_true)

if len(classes) != 2:

raise ValueError('Cannot calculate KS statistic for data with '

'{} category/ies'.format(len(classes)))

probas = y_probas

# Compute KS Statistic curves

thresholds, pct1, pct2, ks_statistic, \

max_distance_at, classes = binary_ks_curve(y_true,

probas[:, 1].ravel())

if ax is None:

fig, ax = plt.subplots(1, 1, figsize=figsize)

ax.set_title(title, fontsize=title_fontsize)

ax.plot(thresholds, pct1, lw=3, label='Class {}'.format(classes[0]))

ax.plot(thresholds, pct2, lw=3, label='Class {}'.format(classes[1]))

idx = np.where(thresholds == max_distance_at)[0][0]

ax.axvline(max_distance_at, *sorted([pct1[idx], pct2[idx]]),

label='KS Statistic: {:.3f} at {:.3f}'.format(ks_statistic,

max_distance_at),

linestyle=':', lw=3, color='black')

ax.set_xlim([0.0, 1.0])

ax.set_ylim([0.0, 1.0])

ax.set_xlabel('Threshold', fontsize=text_fontsize)

ax.set_ylabel('Percentage below threshold', fontsize=text_fontsize)

ax.tick_params(labelsize=text_fontsize)

ax.legend(loc='lower right', fontsize=text_fontsize)

title='Precision-Recall Curve',

curves=('micro', 'each_class'), ax=None,

figsize=None, cmap='nipy_spectral',

title_fontsize="large",

text_fontsize="medium"):

"""Generates the Precision Recall Curve from labels and probabilities

y_true = np.array(y_true)

y_probas = np.array(y_probas)

classes = np.unique(y_true)

probas = y_probas

if 'micro' not in curves and 'each_class' not in curves:

raise ValueError('Invalid argument for curves as it '

'only takes "micro" or "each_class"')

# Compute Precision-Recall curve and area for each class

precision = dict()

recall = dict()

average_precision = dict()

for i in range(len(classes)):

precision[i], recall[i], _ = precision_recall_curve(

y_true, probas[:, i], pos_label=classes[i])

y_true = label_binarize(y_true, classes=classes)

if len(classes) == 2:

y_true = np.hstack((1 - y_true, y_true))

for i in range(len(classes)):

average_precision[i] = average_precision_score(y_true[:, i],

probas[:, i])

# Compute micro-average ROC curve and ROC area

micro_key = 'micro'

i = 0

while micro_key in precision:

i += 1

micro_key += str(i)

precision[micro_key], recall[micro_key], _ = precision_recall_curve(

y_true.ravel(), probas.ravel())

average_precision[micro_key] = average_precision_score(y_true, probas,

average='micro')

if ax is None:

fig, ax = plt.subplots(1, 1, figsize=figsize)

ax.set_title(title, fontsize=title_fontsize)

if 'each_class' in curves:

for i in range(len(classes)):

color = plt.cm.get_cmap(cmap)(float(i) / len(classes))

ax.plot(recall[i], precision[i], lw=2,

label='Precision-recall curve of class {0} '

'(area = {1:0.3f})'.format(classes[i],

average_precision[i]),

color=color)

if 'micro' in curves:

ax.plot(recall[micro_key], precision[micro_key],

label='micro-average Precision-recall curve '

'(area = {0:0.3f})'.format(average_precision[micro_key]),

color='navy', linestyle=':', linewidth=4)

ax.set_xlim([0.0, 1.0])

ax.set_ylim([0.0, 1.05])

ax.set_xlabel('Recall')

ax.set_ylabel('Precision')

ax.tick_params(labelsize=text_fontsize)

ax.legend(loc='best', fontsize=text_fontsize)

feature_names=None, max_num_features=20,

order='descending', x_tick_rotation=0, ax=None,

figsize=None, title_fontsize="large",

text_fontsize="medium"):

"""Generates a plot of a classifier's feature importances.

if not hasattr(clf, 'feature_importances_'):

raise TypeError('"feature_importances_" attribute not in classifier. '

'Cannot plot feature importances.')

importances = clf.feature_importances_

if hasattr(clf, 'estimators_')\

and isinstance(clf.estimators_, list)\

and hasattr(clf.estimators_[0], 'feature_importances_'):

std = np.std([tree.feature_importances_ for tree in clf.estimators_],

axis=0)

else:

std = None

if order == 'descending':

indices = np.argsort(importances)[::-1]

elif order == 'ascending':

indices = np.argsort(importances)

elif order is None:

indices = np.array(range(len(importances)))

else:

raise ValueError('Invalid argument {} for "order"'.format(order))

if ax is None:

fig, ax = plt.subplots(1, 1, figsize=figsize)

if feature_names is None:

feature_names = indices

else:

feature_names = np.array(feature_names)[indices]

max_num_features = min(max_num_features, len(importances))

ax.set_title(title, fontsize=title_fontsize)

if std is not None:

ax.bar(range(max_num_features),

importances[indices][:max_num_features], color='r',

yerr=std[indices][:max_num_features], align='center')

else:

ax.bar(range(max_num_features),

importances[indices][:max_num_features],

color='r', align='center')

ax.set_xticks(range(max_num_features))

ax.set_xticklabels(feature_names[:max_num_features],

rotation=x_tick_rotation)

ax.set_xlim([-1, max_num_features])

ax.tick_params(labelsize=text_fontsize)

train_sizes=None, n_jobs=1, scoring=None,

ax=None, figsize=None, title_fontsize="large",

text_fontsize="medium"):

"""Generates a plot of the train and test learning curves for a classifier.

if ax is None:

fig, ax = plt.subplots(1, 1, figsize=figsize)

if train_sizes is None:

train_sizes = np.linspace(.1, 1.0, 5)

ax.set_title(title, fontsize=title_fontsize)

ax.set_xlabel("Training examples", fontsize=text_fontsize)

ax.set_ylabel("Score", fontsize=text_fontsize)

train_sizes, train_scores, test_scores = learning_curve(

clf, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes,

scoring=scoring)

train_scores_mean = np.mean(train_scores, axis=1)

train_scores_std = np.std(train_scores, axis=1)

test_scores_mean = np.mean(test_scores, axis=1)

test_scores_std = np.std(test_scores, axis=1)

ax.grid()

ax.fill_between(train_sizes, train_scores_mean - train_scores_std,

train_scores_mean + train_scores_std, alpha=0.1, color="r")

ax.fill_between(train_sizes, test_scores_mean - test_scores_std,

test_scores_mean + test_scores_std, alpha=0.1, color="g")

ax.plot(train_sizes, train_scores_mean, 'o-', color="r",

label="Training score")

ax.plot(train_sizes, test_scores_mean, 'o-', color="g",

label="Cross-validation score")

ax.tick_params(labelsize=text_fontsize)

ax.legend(loc="best", fontsize=text_fontsize)

copy=True, ax=None, figsize=None, cmap='nipy_spectral',

title_fontsize="large", text_fontsize="medium"):

"""Plots silhouette analysis of clusters using fit_predict.

if copy:

clf = clone(clf)

cluster_labels = clf.fit_predict(X)

n_clusters = len(set(cluster_labels))

silhouette_avg = silhouette_score(X, cluster_labels, metric=metric)

sample_silhouette_values = silhouette_samples(X, cluster_labels,

metric=metric)

if ax is None:

fig, ax = plt.subplots(1, 1, figsize=figsize)

ax.set_title(title, fontsize=title_fontsize)

ax.set_xlim([-0.1, 1])

ax.set_ylim([0, len(X) + (n_clusters + 1) * 10 + 10])

ax.set_xlabel('Silhouette coefficient values', fontsize=text_fontsize)

ax.set_ylabel('Cluster label', fontsize=text_fontsize)

y_lower = 10

for i in range(n_clusters):

ith_cluster_silhouette_values = sample_silhouette_values[

cluster_labels == i]

ith_cluster_silhouette_values.sort()

size_cluster_i = ith_cluster_silhouette_values.shape[0]

y_upper = y_lower + size_cluster_i

color = plt.cm.get_cmap(cmap)(float(i) / n_clusters)

ax.fill_betweenx(np.arange(y_lower, y_upper),

0, ith_cluster_silhouette_values,

facecolor=color, edgecolor=color, alpha=0.7)

ax.text(-0.05, y_lower + 0.5 * size_cluster_i, str(i),

fontsize=text_fontsize)

y_lower = y_upper + 10

ax.axvline(x=silhouette_avg, color="red", linestyle="--",

label='Silhouette score: {0:0.3f}'.format(silhouette_avg))

ax.set_yticks([]) # Clear the y-axis labels / ticks

ax.set_xticks(np.arange(-0.1, 1.0, 0.2))

ax.tick_params(labelsize=text_fontsize)

ax.legend(loc='best', fontsize=text_fontsize)

ax=None, figsize=None, title_fontsize="large",

text_fontsize="medium"):

"""Plots elbow curve of different values of K for KMeans clustering.

if cluster_ranges is None:

cluster_ranges = range(1, 12, 2)

else:

cluster_ranges = sorted(cluster_ranges)

if not hasattr(clf, 'n_clusters'):

raise TypeError('"n_clusters" attribute not in classifier. '

'Cannot plot elbow method.')

clfs = []

for i in cluster_ranges:

current_clf = clone(clf)

setattr(current_clf, "n_clusters", i)

clfs.append(current_clf.fit(X).score(X))

if ax is None:

fig, ax = plt.subplots(1, 1, figsize=figsize)

ax.set_title(title, fontsize=title_fontsize)

ax.plot(cluster_ranges, np.absolute(clfs), 'b*-')

ax.grid(True)

ax.set_xlabel('Number of clusters', fontsize=text_fontsize)

ax.set_ylabel('Sum of Squared Errors', fontsize=text_fontsize)

ax.tick_params(labelsize=text_fontsize)

target_explained_variance=0.75, ax=None,

figsize=None, title_fontsize="large",

text_fontsize="medium"):

"""Plots PCA components' explained variance ratios. (new in v0.2.2)