def _multidim_multiclass_prob_sk_metric(preds, target, normalize=None):
sk_preds = torch.argmax(preds, dim=len(preds.shape) - 2).view(-1).numpy()
sk_target = target.view(-1).numpy()
return sk_confusion_matrix(y_true=sk_target,
y_pred=sk_preds,
normalize=normalize)
def _multidim_multiclass_sk_metric(preds, target, normalize=None):
sk_preds = preds.view(-1).numpy()
sk_target = target.view(-1).numpy()
return sk_confusion_matrix(y_true=sk_target,
y_pred=sk_preds,
normalize=normalize)
def _sk_cm_multilabel(preds, target, normalize=None):
sk_preds = preds.view(-1).numpy()
sk_target = target.view(-1).numpy()
return sk_confusion_matrix(y_true=sk_target,
y_pred=sk_preds,
normalize=normalize)
def _multilabel_prob_sk_metric(preds, target, normalize=None):
sk_preds = (preds.view(-1).numpy() >= THRESHOLD).astype(np.uint8)
sk_target = target.view(-1).numpy()
return sk_confusion_matrix(y_true=sk_target,
y_pred=sk_preds,
normalize=normalize)
def confusion_matrix(y_true, y_predicted, labels):
df = pd.DataFrame(data=sk_confusion_matrix(y_true, y_predicted),
index=labels,
columns=labels)
df.index.name = 'true classes'
df.columns.name = 'predicted classes'
return df
def confusion_matrix(y_test, y_pred):
cm = sk_confusion_matrix(y, y_pred)
cm = pd.DataFrame(data=cm, columns=[-1, 1], index=[-1, 1])
cm.columns.name = 'Predicted label'
cm.index.name = 'True label'
error_rate = (y_pred != y).mean()
print('error rate: %.2f' % error_rate)
return cm
def draw_confusion_matrix(y_test, y_pred, labels):
cm = sk_confusion_matrix(y_test, y_pred)
cm = pd.DataFrame(data=cm, columns=labels, index=labels)
cm.columns.name = 'Predicted label'
cm.index.name = 'True label'
error_rate = (y_pred != y_test).mean()
print('mean error rate: %.2f' % error_rate)
return cm
def confusion_matrix(y_test, y_pred):
cm = sk_confusion_matrix(y, y_pred)
cm = pd.DataFrame(data=cm, columns=[-1, 1], index=[-1, 1])
cm.columns.name = 'Predicted label'
cm.index.name = 'True label'
error_rate = (y_pred != y).mean()
print('error rate: %.2f' % error_rate)
return cm
def draw_confusion_matrix(y_test, y_pred, labels):
cm = sk_confusion_matrix(y_test, y_pred)
cm = pd.DataFrame(data=cm, columns=labels, index=labels)
cm.columns.name = 'Predicted label'
cm.index.name = 'True label'
error_rate = (y_pred != y_test).mean()
print('mean error rate: %.2f' % error_rate)
return cm
def test_confusion_matrix_random(n_samples, dtype, problem_type):
upper_range = 2 if problem_type == 'binary' else 1000
y_true, y_pred, _, _ = generate_random_labels(
lambda rng: rng.randint(0, upper_range, n_samples).astype(dtype))
cm = confusion_matrix(y_true, y_pred)
ref = sk_confusion_matrix(y_true, y_pred)
cp.testing.assert_array_almost_equal(ref, cm, decimal=4)
def test_confusion_matrix_multiclass_subset_labels(labels):
y_true, y_pred, _, _ = generate_random_labels(
lambda rng: rng.randint(0, 3, 10).astype(np.int32))
ref = sk_confusion_matrix(y_true, y_pred, labels=labels)
labels = cp.array(labels, dtype=np.int32)
cm = confusion_matrix(y_true, y_pred, labels=labels)
cp.testing.assert_array_almost_equal(ref, cm, decimal=4)
def test_confusion_matrix_multiclass_subset_labels(labels, client):
y_true, y_pred, np_y_true, np_y_pred = generate_random_labels(
lambda rng: rng.randint(0, 3, 10).astype(np.int32), as_cupy=True)
y_true, y_pred = da.from_array(y_true), da.from_array(y_pred)
ref = sk_confusion_matrix(np_y_true, np_y_pred, labels=labels)
labels = cp.array(labels, dtype=np.int32)
cm = confusion_matrix(y_true, y_pred, labels=labels)
cp.testing.assert_array_almost_equal(ref, cm, decimal=4)
def confusion_matrix(y_test, y_pred):
cm = sk_confusion_matrix(y_test, y_pred)
if cm.shape[1] == 2:
cm = pd.DataFrame(data=cm, columns=[0, 1], index=[0, 1])
else:
cm = pd.DataFrame(data=cm, columns=[1, 2, 3], index=[1, 2, 3])
cm.columns.name = 'Predicted label'
cm.index.name = 'True label'
return cm
def make_confusion_matrix_report(clf, x, y):
assert len(clf.classes_) == 2
assert clf.classes_[0] == 0
assert clf.classes_[1] == 1
y_pred = clf.predict(x)
cm = sk_confusion_matrix(y, y_pred)
cm = pd.DataFrame(data=cm, columns=[0, 1], index=[0, 1])
cm.columns.name = 'Predicted label'
cm.index.name = 'True label'
return "\n%s\n" % str(cm)
def test_confusion_matrix_random_weights(n_samples, dtype, weights_dtype):
y_true, y_pred, _, _ = generate_random_labels(
lambda rng: rng.randint(0, 10, n_samples).astype(dtype))
if weights_dtype == 'int':
sample_weight = np.random.RandomState(0).randint(0, 10, n_samples)
else:
sample_weight = np.random.RandomState(0).rand(n_samples)
cm = confusion_matrix(y_true, y_pred, sample_weight=sample_weight)
ref = sk_confusion_matrix(y_true, y_pred, sample_weight=sample_weight)
cp.testing.assert_array_almost_equal(ref, cm, decimal=4)
def test_confusion_matrix_random(n_samples, dtype, problem_type, cluster):
client = Client(cluster)
upper_range = 2 if problem_type == 'binary' else 1000
y_true, y_pred, np_y_true, np_y_pred = generate_random_labels(
lambda rng: rng.randint(0, upper_range, n_samples).astype(dtype),
as_cupy=True)
y_true, y_pred = da.from_array(y_true), da.from_array(y_pred)
cm = confusion_matrix(y_true, y_pred)
ref = sk_confusion_matrix(np_y_true, np_y_pred)
cp.testing.assert_array_almost_equal(ref, cm, decimal=4)
client.close()
def confusion_matrix(learn: Learner,
dl: DeviceDataLoader,
thres: float = None) -> [np.ndarray, np.ndarray]:
""" Compute confusion matrix.
Args:
learn: trained model
dl: dataloader with images and ground truth masks
thres: threshold under which to reject predicted label and set to class-id 0 instead.
Return:
The un-normalized and the normalized confusion matrices.
"""
y_gts = []
y_preds = []
# Loop over all images
for im_path, gt_path in zip(dl.x.items, dl.y.items):
pred_mask, _ = predict(im_path, learn, thres)
# load ground truth and resize to be same size as predited mask
gt_mask = PIL.Image.open(gt_path)
gt_mask = gt_mask.resize(pred_mask.shape[::-1],
resample=PIL.Image.NEAREST)
gt_mask = np.asarray(gt_mask)
# Store predicted and ground truth labels
assert len(gt_mask.flatten()) == len(pred_mask.flatten())
y_gts.extend(gt_mask.flatten())
y_preds.extend(pred_mask.flatten())
# Compute confusion matrices
cmat = sk_confusion_matrix(y_gts, y_preds)
cmat_norm = sk_confusion_matrix(y_gts, y_preds, normalize="true")
return cmat, cmat_norm
def _confusion_matrix(targets, predictions):
"""Helper function to produce a confusion matrix after properly formatting `predictions`
Parameters
----------
targets: Array-like
The target/expected output labels for each of the given `predictions`
predictions: Array-like
The predicted values corresponding to each of the elements in `targets`
Returns
-------
Array-like
A confusion matrix for the given `targets` and `predictions`"""
return sk_confusion_matrix(targets, get_clean_prediction(targets, predictions))
def confusion_matrix(y_true, y_pred, target_names, normalize=False, title='Confusion matrix', cmap=plt.cm.Blues):
cm = sk_confusion_matrix(y_true, y_pred)
if normalize:
cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
np.set_printoptions(precision=2)
fig = Figure()
canvas = FigureCanvas(fig)
ax = fig.add_subplot(111)
im = ax.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)
fig.colorbar(im)
tick_marks = np.arange(len(target_names))
ax.set_xticks(tick_marks)
ax.set_xticklabels(target_names, rotation=45)
ax.set_yticks(tick_marks)
ax.set_yticklabels(target_names)
fig.tight_layout()
ax.set_title(title)
ax.set_ylabel('True label')
ax.set_xlabel('Predicted label')
return fig
def test_confusion_matrix_random_weights(n_samples, dtype, weights_dtype,
client):
y_true, y_pred, np_y_true, np_y_pred = generate_random_labels(
lambda rng: rng.randint(0, 10, n_samples).astype(dtype), as_cupy=True)
y_true, y_pred = da.from_array(y_true), da.from_array(y_pred)
if weights_dtype == 'int':
sample_weight = np.random.RandomState(0).randint(0, 10, n_samples)
else:
sample_weight = np.random.RandomState(0).rand(n_samples)
ref = sk_confusion_matrix(np_y_true,
np_y_pred,
sample_weight=sample_weight)
sample_weight = cp.array(sample_weight)
sample_weight = da.from_array(sample_weight)
cm = confusion_matrix(y_true, y_pred, sample_weight=sample_weight)
cp.testing.assert_array_almost_equal(ref, cm, decimal=4)
def confusion_matrix(model, dataset_loader):
targets = []
outputs = []
for stft, y in dataset_loader:
target_class = np.argmax(y, axis=1)
targets = np.append(targets, target_class)
with torch.no_grad():
logits = model(stft)
predicted_class = np.argmax(logits.cpu().detach().numpy(), axis=1)
outputs = np.append(outputs, predicted_class)
Confusion_matrix = sk_confusion_matrix(targets.tolist(), outputs.tolist())
print('Confusion_matrix:')
print(Confusion_matrix)
Se = Confusion_matrix[0][0] / (sum(Confusion_matrix[0]))
Sq = (Confusion_matrix[1][1] + Confusion_matrix[2][2] +
Confusion_matrix[3][3]) / (sum(Confusion_matrix[1]) + sum(
Confusion_matrix[2]) + sum(Confusion_matrix[3]))
return Se, Sq, (Se + Sq) / 2
def error_rate(predictions, labels):
Confusion_matrix=sk_confusion_matrix(numpy.argmax(predictions, 1).tolist(), labels.tolist())
print('Confusion_matrix:')
print(Confusion_matrix)
Se1 = Confusion_matrix[1,1]+Confusion_matrix[2,2]+Confusion_matrix[3,3]
Se2 = Confusion_matrix[1,1]+Confusion_matrix[1,0]+Confusion_matrix[1,2]+Confusion_matrix[1,3]+Confusion_matrix[2,2]+Confusion_matrix[2,0]+Confusion_matrix[2,1]+Confusion_matrix[2,3]+Confusion_matrix[3,3]+Confusion_matrix[3,0]+Confusion_matrix[3,1]+Confusion_matrix[3,2]
Se = Se1/Se2
Sp = Confusion_matrix[0,0]/(Confusion_matrix[0,0]+Confusion_matrix[0,1]+Confusion_matrix[0,2]+Confusion_matrix[0,3])
Acc = (Se+Sp)*100/2
target_names = ['class 0', 'class 1', 'class 2', 'class 3']
print()
accuracy = 100.0-(100.0 *numpy.sum(numpy.argmax(predictions, 1) == labels)/predictions.shape[0])
"""Return the error rate based on dense predictions and sparse labels."""
return 100.0 - (
100.0 *
numpy.sum(numpy.argmax(predictions, 1) == labels) /
predictions.shape[0]), Acc
def confusion_matrix(model, dataset_loader):
targets = []
outputs = []
for stft, mfcc, y in dataset_loader:
stft = stft.to(device)
mfcc = mfcc.to(device)
y = one_hot(np.array(y.numpy()), 4)
target_class = np.argmax(y, axis=1)
targets = np.append(targets, target_class)
predicted_class = np.argmax(model(stft, mfcc).cpu().detach().numpy(),
axis=1)
outputs = np.append(outputs, predicted_class)
Confusion_matrix = sk_confusion_matrix(targets.tolist(), outputs.tolist())
print('Confusion_matrix:')
print(Confusion_matrix)
target_names = ['class 0', 'class 1', 'class 2', 'class 3']
print('classification_report:')
print(
classification_report(targets.tolist(),
outputs.tolist(),
target_names=target_names))
def __str__(self):
cmx = sk_confusion_matrix(*self._fix_label_prediction_representation())
return f"{cmx}"
def confusion_matrix(y_true,
y_pred,
target_names=None,
normalize=False,
cmap=None,
ax=None):
"""
Plot confustion matrix.
Parameters
----------
y_true : array-like, shape = [n_samples]
Correct target values (ground truth).
y_pred : array-like, shape = [n_samples]
Target predicted classes (estimator predictions).
target_names : list
List containing the names of the target classes. List must be in order
e.g. ``['Label for class 0', 'Label for class 1']``. If ``None``,
generic labels will be generated e.g. ``['Class 0', 'Class 1']``
ax: matplotlib Axes
Axes object to draw the plot onto, otherwise uses current Axes
normalize : bool
Normalize the confusion matrix
cmap : matplotlib Colormap
If ``None`` uses a modified version of matplotlib's OrRd colormap.
Notes
-----
http://scikit-learn.org/stable/auto_examples/model_selection/plot_confusion_matrix.html
Returns
-------
ax: matplotlib Axes
Axes containing the plot
Examples
--------
.. plot:: ../../examples/confusion_matrix.py
"""
if any((val is None for val in (y_true, y_pred))):
raise ValueError("y_true and y_pred are needed to plot confusion "
"matrix")
# calculate how many names you expect
values = set(y_true).union(set(y_pred))
expected_len = len(values)
if target_names and (expected_len != len(target_names)):
raise ValueError(
('Data cointains {} different values, but target'
' names contains {} values.'.format(expected_len,
len(target_names))))
# if the user didn't pass target_names, create generic ones
if not target_names:
values = list(values)
values.sort()
target_names = ['Class {}'.format(v) for v in values]
cm = sk_confusion_matrix(y_true, y_pred)
if normalize:
cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
np.set_printoptions(precision=2)
if ax is None:
ax = plt.gca()
# this (y, x) may sound counterintuitive. The reason is that
# in a matrix cell (i, j) is in row=i and col=j, translating that
# to an x, y plane (which matplotlib uses to plot), we need to use
# i as the y coordinate (how many steps down) and j as the x coordinate
# how many steps to the right.
for (y, x), v in np.ndenumerate(cm):
try:
label = '{:.2}'.format(v)
except:
label = v
ax.text(x,
y,
label,
horizontalalignment='center',
verticalalignment='center')
if cmap is None:
cmap = default_heatmap()
im = ax.imshow(cm, interpolation='nearest', cmap=cmap)
plt.colorbar(im, ax=ax)
tick_marks = np.arange(len(target_names))
ax.set_xticks(tick_marks)
ax.set_xticklabels(target_names)
ax.set_yticks(tick_marks)
ax.set_yticklabels(target_names)
title = 'Confusion matrix'
if normalize:
title += ' (normalized)'
ax.set_title(title)
ax.set_ylabel('True label')
ax.set_xlabel('Predicted label')
return ax
for filename_csv in [
result_prefix + '_results_train.csv',
result_prefix + '_results_valid.csv'
]:
print('computer confusion matrix:', filename_csv + '\n')
df = pd.read_csv(filename_csv, delimiter=',')
gt_label = df['labels'].tolist()
for i in range(0, NUM_CLASSES):
y_true = encoding_labels(gt_label, i)
list_prob = df['class' + str(i)].tolist()
y_pred = convert_prob_to_label(list_prob,
i,
list_threshold=LIST_THRESHOLD)
cf1 = sk_confusion_matrix(y_true, y_pred)
print(str(i) + ':')
print(cf1)
# sk_roc_auc_score(y_true, y_score)
#endregion
if COMPUTE_EXCLUSION_NUM:
num_exclusion = 0
for filename_csv in [
result_prefix + 'results_train.csv',
result_prefix + 'results_valid.csv'
]:
print('computer confusion matrix:', filename_csv + '\n')
if pat_id not in dict_patient_predict:
dict_patient_predict[pat_id] = 0
elif dict_patient_predict[pat_id] == 0 and np.argmax(probs[i]) == 1:
dict_patient_predict[pat_id] = 1
list_label_gt = []
list_label_predict = []
for (k, v) in dict_patient_gt.items():
list_label_gt.append(v)
list_label_predict.append(dict_patient_predict[k])
from sklearn.metrics import confusion_matrix as sk_confusion_matrix
labels = [x for x in range(0, 2)]
confusion_matrix = sk_confusion_matrix(list_label_gt,
list_label_predict,
labels=labels)
print('OK')
'''
train
0 = [1256, 43]
1 = [9, 249]
validation
0 = [150, 8]
1 = [1, 34]
'''
def on_epoch_end(self, epoch, logs=None):
try:
with open(config_file_realtime, 'r') as json_file:
data = json.load(json_file)
if data['epoch_compute_cf_train'] == 1:
compute_cf_train = True
else:
compute_cf_train = False
if data['epoch_compute_cf_valid'] == 1:
compute_cf_valid = True
else:
compute_cf_valid = False
if data['epoch_compute_cf_test'] == 1:
compute_cf_test = True
else:
compute_cf_test = False
except:
print('read realtime helper file error!')
compute_cf_train = True
compute_cf_valid = True
compute_cf_test = True
if compute_cf_train:
print('calculate confusion matrix of training dataset...')
generator_cf_train = My_images_generator_2d(
train_files,
train_labels,
num_output=num_classes,
batch_size=batch_size_train,
image_shape=input_shape)
i = 0
for x_train, y_train in generator_cf_train.gen():
probabilities = self.model.predict(x_train)
if i == 0:
probs = probabilities
else:
probs = np.vstack((probs, probabilities))
i += 1
if i == math.ceil(len(train_files) / batch_size_train):
break
y_preds = probs.argmax(axis=-1)
y_preds = y_preds.tolist()
from sklearn.metrics import confusion_matrix as sk_confusion_matrix
labels = [x for x in range(0, num_classes)]
confusion_matrix_train = sk_confusion_matrix(train_labels,
y_preds,
labels=labels)
print(confusion_matrix_train)
if compute_cf_valid:
print('calculate confusion matrix of validation dataset...')
generator_cf_valid = My_images_generator_2d(
valid_files,
valid_labels,
num_output=num_classes,
batch_size=batch_size_valid,
image_shape=input_shape)
i = 0
for x_valid, y_valid in generator_cf_valid.gen():
probabilities = self.model.predict(x_valid)
if i == 0:
probs = probabilities
else:
probs = np.vstack((probs, probabilities))
i += 1
if i == math.ceil(len(valid_files) / batch_size_valid):
break
y_preds = probs.argmax(axis=-1)
y_preds = y_preds.tolist()
from sklearn.metrics import confusion_matrix as sk_confusion_matrix
labels = [x for x in range(0, num_classes)]
confusion_matrix_valid = sk_confusion_matrix(valid_labels,
y_preds,
labels=labels)
print(confusion_matrix_valid)
if compute_cf_test:
print('calculate confusion matrix of test dataset...')
generator_cf_test = My_images_generator_2d(
test_files,
test_labels,
num_output=num_classes,
batch_size=batch_size_valid,
image_shape=input_shape)
i = 0
for x_test, y_test in generator_cf_test.gen():
probabilities = self.model.predict(x_test)
if i == 0:
probs = probabilities
else:
probs = np.vstack((probs, probabilities))
i += 1
if i == math.ceil(len(test_files) / batch_size_valid):
break
y_preds = probs.argmax(axis=-1)
y_preds = y_preds.tolist()
from sklearn.metrics import confusion_matrix as sk_confusion_matrix
labels = [x for x in range(0, num_classes)]
confusion_matrix_test = sk_confusion_matrix(test_labels,
y_preds,
labels=labels)
print(confusion_matrix_test)
def compute_confusion_matrix(probs_list, dir_dest,
all_files, all_labels,
dir_preprocess='', dir_original='', ):
cf_list = []
not_match_list = []
# every model's confusion matrix and not match files
for probs in probs_list:
y_preds = probs.argmax(axis=-1)
y_preds = y_preds.tolist()
NUM_CLASSES = probs[0].shape[0] #len(probs[0])
labels = [x for x in range(0, NUM_CLASSES)]
cf1 = sk_confusion_matrix(all_labels, y_preds, labels=labels)
cf_list.append(cf1)
not_match1 = []
for i in range(len(all_files)):
if all_labels[i] != y_preds[i]:
dict_predict = {'filename': all_files[i], 'pred_level': y_preds[i], 'label_level': all_labels[i]}
not_match1.append(dict_predict)
not_match_list.append(not_match1)
# region total confusion matrix and not match files
for i, probs in enumerate(probs_list):
if i == 0:
prob_total = probs
else:
prob_total += probs
prob_total /= len(probs_list)
y_pred_total = prob_total.argmax(axis=-1)
cf_total = sk_confusion_matrix(all_labels, y_pred_total, labels=labels)
not_match_total = []
for i in range(len(all_files)):
if all_labels[i] != y_pred_total[i]:
prob_max = np.max(prob_total[i]) * 100 # find maximum probability value
dict_predict = {'filename': all_files[i], 'pred_level': y_pred_total[i],
'prob_max': prob_max,
'label_level': all_labels[i]}
not_match_total.append(dict_predict)
# endregion
# export confusion files
if dir_dest != '':
for dict1 in not_match_total:
img_file_source = str(dict1['filename']).strip()
# some files are deleted for some reasons.
if not os.path.exists(img_file_source):
raise RuntimeError(img_file_source + ' not found!')
_, filename = os.path.split(img_file_source)
file_dest = os.path.join(dir_dest, str(dict1['label_level']) + '_' + str(dict1['pred_level'])
, str(int(dict1['prob_max'])) + '__' + filename)
#copy original files instead of preprocessed files
if dir_preprocess != '' and dir_original != '':
if not dir_preprocess.endswith('/'):
dir_preprocess = dir_preprocess + '/'
if not dir_original.endswith('/'):
dir_original = dir_original + '/'
img_file_source = img_file_source.replace(dir_preprocess, dir_original)
if not os.path.exists(img_file_source):
raise RuntimeError(img_file_source + ' not found!')
if not os.path.exists(os.path.dirname(file_dest)):
os.makedirs(os.path.dirname(file_dest))
shutil.copyfile(img_file_source, file_dest)
print('copy file:', file_dest)
return cf_list, not_match_list, cf_total, not_match_total
def confusion_matrix(Y_true, Y_pred, label_len=6):
"""
Generate confusion matrix in a string format
Parameters
----------
Y_true : list
The true labels
Y_pred : list
The test labels
label_len : int
The maximum label text length displayed (minimum length: 6)
Returns
-------
cfmat : str
The confusion matrix in str format (X-axis: prediction, -axis: ground truth)
acc : float
The accuracy
"""
import numpy as np
from sklearn.metrics import confusion_matrix as sk_confusion_matrix
# find labels
if type(Y_true) == np.ndarray:
Y_labels = np.unique(Y_true)
else:
Y_labels = list(set(Y_true))
# Check the provided label name length
if label_len < 6:
label_len = 6
logger.warning('label_len < 6. Setting to 6.')
label_tpl = '%' + '-%ds' % label_len
col_tpl = '%' + '-%d.2f' % label_len
# sanity check
if len(Y_pred) > len(Y_true):
raise RuntimeError('Y_pred has more items than Y_true')
elif len(Y_pred) < len(Y_true):
Y_true = Y_true[:len(Y_pred)]
cm = sk_confusion_matrix(Y_true, Y_pred, Y_labels)
# compute confusion matrix
cm_rate = cm.copy().astype('float')
cm_sum = np.sum(cm, axis=1)
# Fill confusion string
for r, s in zip(cm_rate, cm_sum):
if s > 0:
r /= s
cm_txt = label_tpl % 'gt\dt'
for l in Y_labels:
cm_txt += label_tpl % str(l)[:label_len]
cm_txt += '\n'
for l, r in zip(Y_labels, cm_rate):
cm_txt += label_tpl % str(l)[:label_len]
for c in r:
cm_txt += col_tpl % c
cm_txt += '\n'
# compute accuracy
correct = 0.0
for c in range(cm.shape[0]):
correct += cm[c][c]
cm_sum = cm.sum()
if cm_sum > 0:
acc = correct / cm.sum()
else:
acc = 0.0
return cm_txt, acc
def confusion_matrix(y_true, y_pred, target_names=None, ax=None,
normalize=False, cmap=None):
"""
Plot confustion matrix.
Parameters
----------
y_true : array-like, shape = [n_samples]
Correct target values (ground truth).
y_pred : array-like, shape = [n_samples]
Target predicted classes (estimator predictions).
target_names : list
Lst containing the names of the target classes. List mus be in order
e.g. ['Label for class 0', 'Label for class 1']. If None, generic
labels will be generated e.g. ['Class 0', 'Class 1']
ax: matplotlib Axes
Axes object to draw the plot onto, otherwise uses current Axes
normalize : bool
Normalize the confusion matrix
cmap : matplotlib Colormap
If None uses a modified version of matplotlib's OrRd colormap.
Returns
-------
ax: matplotlib Axes
Axes containing the plot
"""
# calculate how many names you expect
values = set(y_true).union(set(y_pred))
expected_len = len(values)
if target_names and (expected_len != len(target_names)):
raise ValueError(('Data cointains {} different values, but target'
' names contains {} values.'.format(expected_len,
len(target_names)
)))
# if the user didn't pass target_names, create generic ones
if not target_names:
values = list(values)
values.sort()
target_names = ['Class {}'.format(v) for v in values]
cm = sk_confusion_matrix(y_true, y_pred)
if normalize:
cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
np.set_printoptions(precision=2)
if ax is None:
ax = plt.gca()
# this (y, x) may sound counterintuitive. The reason is that
# in a matrix cell (i, j) is in row=i and col=j, translating that
# to an x, y plane (which matplotlib uses to plot), we need to use
# i as the y coordinate (how many steps down) and j as the x coordinate
# how many steps to the right.
for (y, x), v in np.ndenumerate(cm):
try:
label = '{:.2}'.format(v)
except:
label = v
ax.text(x, y, label, horizontalalignment='center',
verticalalignment='center')
if cmap is None:
cmap = default_heatmap()
im = ax.imshow(cm, interpolation='nearest', cmap=cmap)
plt.colorbar(im, ax=ax)
tick_marks = np.arange(len(target_names))
ax.set_xticks(tick_marks)
ax.set_xticklabels(target_names)
ax.set_yticks(tick_marks)
ax.set_yticklabels(target_names)
title = 'Confusion matrix'
if normalize:
title += ' (normalized)'
ax.set_title(title)
ax.set_ylabel('True label')
ax.set_xlabel('Predicted label')
return ax
