python - example - scikit-learn

¿Cómo trazar scikit aprender informe de clasificación?

Question

¿Es posible trazar con el informe de clasificación matplotlib scikit-learn? Supongamos que imprimo el informe de clasificación de esta manera:

print ''/n*Classification Report:/n'', classification_report(y_test, predictions)
confusion_matrix_graph = confusion_matrix(y_test, predictions)

y me sale:

Clasification Report:
precision recall f1-score support
1 0.62 1.00 0.76 66
2 0.93 0.93 0.93 40
3 0.59 0.97 0.73 67
4 0.47 0.92 0.62 272
5 1.00 0.16 0.28 413
avg / total 0.77 0.57 0.49 858

¿Cómo puedo "trazar" el gráfico avobe?

Answer 1

Acabo de escribir una función plot_classification_report() para este propósito. Espero eso ayude. Esta función elimina la función de clasificación_informe como un argumento y traza las puntuaciones. Aquí está la función.

def plot_classification_report(cr, title=''Classification report '', with_avg_total=False, cmap=plt.cm.Blues):
lines = cr.split(''/n'')
classes = []
plotMat = []
for line in lines[2 : (len(lines) - 3)]:
#print(line)
t = line.split()
# print(t)
classes.append(t[0])
v = [float(x) for x in t[1: len(t) - 1]]
print(v)
plotMat.append(v)
if with_avg_total:
aveTotal = lines[len(lines) - 1].split()
classes.append(''avg/total'')
vAveTotal = [float(x) for x in t[1:len(aveTotal) - 1]]
plotMat.append(vAveTotal)
plt.imshow(plotMat, interpolation=''nearest'', cmap=cmap)
plt.title(title)
plt.colorbar()
x_tick_marks = np.arange(3)
y_tick_marks = np.arange(len(classes))
plt.xticks(x_tick_marks, [''precision'', ''recall'', ''f1-score''], rotation=45)
plt.yticks(y_tick_marks, classes)
plt.tight_layout()
plt.ylabel(''Classes'')
plt.xlabel(''Measures'')

Para el ejemplo ranking_report proporcionado por usted. Aquí están el código y la salida.

sampleClassificationReport = """ precision recall f1-score support
1 0.62 1.00 0.76 66
2 0.93 0.93 0.93 40
3 0.59 0.97 0.73 67
4 0.47 0.92 0.62 272
5 1.00 0.16 0.28 413
avg / total 0.77 0.57 0.49 858"""
plot_classification_report(sampleClassificationReport)

Aquí es cómo usarlo con la salida sklearn ranking_report:

from sklearn.metrics import classification_report
classificationReport = classification_report(y_true, y_pred, target_names=target_names)
plot_classification_report(classificationReport)

Con esta función, también puede agregar el resultado "promedio / total" a la gráfica. Para usarlo solo agrega un argumento with_avg_total como este:

plot_classification_report(classificationReport, with_avg_total=True)

Answer 2

Ampliando la respuesta de Bin :

import matplotlib.pyplot as plt
import numpy as np
def show_values(pc, fmt="%.2f", **kw):
''''''
Heatmap with text in each cell with matplotlib''s pyplot
Source: https://.com/a/25074150/395857
By HYRY
''''''
from itertools import izip
pc.update_scalarmappable()
ax = pc.get_axes()
for p, color, value in izip(pc.get_paths(), pc.get_facecolors(), pc.get_array()):
x, y = p.vertices[:-2, :].mean(0)
if np.all(color[:3] > 0.5):
color = (0.0, 0.0, 0.0)
else:
color = (1.0, 1.0, 1.0)
ax.text(x, y, fmt % value, ha="center", va="center", color=color, **kw)
def cm2inch(*tupl):
''''''
Specify figure size in centimeter in matplotlib
Source: https://.com/a/22787457/395857
By gns-ank
''''''
inch = 2.54
if type(tupl[0]) == tuple:
return tuple(i/inch for i in tupl[0])
else:
return tuple(i/inch for i in tupl)
def heatmap(AUC, title, xlabel, ylabel, xticklabels, yticklabels, figure_width=40, figure_height=20, correct_orientation=False, cmap=''RdBu''):
''''''
Inspired by:
- https://.com/a/16124677/395857
- https://.com/a/25074150/395857
''''''
# Plot it out
fig, ax = plt.subplots()
#c = ax.pcolor(AUC, edgecolors=''k'', linestyle= ''dashed'', linewidths=0.2, cmap=''RdBu'', vmin=0.0, vmax=1.0)
c = ax.pcolor(AUC, edgecolors=''k'', linestyle= ''dashed'', linewidths=0.2, cmap=cmap)
# put the major ticks at the middle of each cell
ax.set_yticks(np.arange(AUC.shape[0]) + 0.5, minor=False)
ax.set_xticks(np.arange(AUC.shape[1]) + 0.5, minor=False)
# set tick labels
#ax.set_xticklabels(np.arange(1,AUC.shape[1]+1), minor=False)
ax.set_xticklabels(xticklabels, minor=False)
ax.set_yticklabels(yticklabels, minor=False)
# set title and x/y labels
plt.title(title)
plt.xlabel(xlabel)
plt.ylabel(ylabel)
# Remove last blank column
plt.xlim( (0, AUC.shape[1]) )
# Turn off all the ticks
ax = plt.gca()
for t in ax.xaxis.get_major_ticks():
t.tick1On = False
t.tick2On = False
for t in ax.yaxis.get_major_ticks():
t.tick1On = False
t.tick2On = False
# Add color bar
plt.colorbar(c)
# Add text in each cell
show_values(c)
# Proper orientation (origin at the top left instead of bottom left)
if correct_orientation:
ax.invert_yaxis()
ax.xaxis.tick_top()
# resize
fig = plt.gcf()
#fig.set_size_inches(cm2inch(40, 20))
#fig.set_size_inches(cm2inch(40*4, 20*4))
fig.set_size_inches(cm2inch(figure_width, figure_height))
def plot_classification_report(classification_report, title=''Classification report '', cmap=''RdBu''):
''''''
Plot scikit-learn classification report.
Extension based on https://.com/a/31689645/395857
''''''
lines = classification_report.split(''/n'')
classes = []
plotMat = []
support = []
class_names = []
for line in lines[2 : (len(lines) - 2)]:
t = line.strip().split()
if len(t) < 2: continue
classes.append(t[0])
v = [float(x) for x in t[1: len(t) - 1]]
support.append(int(t[-1]))
class_names.append(t[0])
print(v)
plotMat.append(v)
print(''plotMat: {0}''.format(plotMat))
print(''support: {0}''.format(support))
xlabel = ''Metrics''
ylabel = ''Classes''
xticklabels = [''Precision'', ''Recall'', ''F1-score'']
yticklabels = [''{0} ({1})''.format(class_names[idx], sup) for idx, sup in enumerate(support)]
figure_width = 25
figure_height = len(class_names) + 7
correct_orientation = False
heatmap(np.array(plotMat), title, xlabel, ylabel, xticklabels, yticklabels, figure_width, figure_height, correct_orientation, cmap=cmap)
def main():
sampleClassificationReport = """ precision recall f1-score support
Acacia 0.62 1.00 0.76 66
Blossom 0.93 0.93 0.93 40
Camellia 0.59 0.97 0.73 67
Daisy 0.47 0.92 0.62 272
Echium 1.00 0.16 0.28 413
avg / total 0.77 0.57 0.49 858"""
plot_classification_report(sampleClassificationReport)
plt.savefig(''test_plot_classif_report.png'', dpi=200, format=''png'', bbox_inches=''tight'')
plt.close()
if __name__ == "__main__":
main()
#cProfile.run(''main()'') # if you want to do some profiling

salidas:

Ejemplo con más clases (~ 40):

Answer 3

Aquí puede obtener el gráfico igual que el de Franck Dernoncourt , pero con un código mucho más corto (puede caber en una sola función).

import matplotlib.pyplot as plt
import numpy as np
import itertools
def plot_classification_report(classificationReport,
title=''Classification report'',
cmap=''RdBu''):
classificationReport = classificationReport.replace(''/n/n'', ''/n'')
classificationReport = classificationReport.replace('' / '', ''/'')
lines = classificationReport.split(''/n'')
classes, plotMat, support, class_names = [], [], [], []
for line in lines[1:]: # if you don''t want avg/total result, then change [1:] into [1:-1]
t = line.strip().split()
if len(t) < 2:
continue
classes.append(t[0])
v = [float(x) for x in t[1: len(t) - 1]]
support.append(int(t[-1]))
class_names.append(t[0])
plotMat.append(v)
plotMat = np.array(plotMat)
xticklabels = [''Precision'', ''Recall'', ''F1-score'']
yticklabels = [''{0} ({1})''.format(class_names[idx], sup)
for idx, sup in enumerate(support)]
plt.imshow(plotMat, interpolation=''nearest'', cmap=cmap, aspect=''auto'')
plt.title(title)
plt.colorbar()
plt.xticks(np.arange(3), xticklabels, rotation=45)
plt.yticks(np.arange(len(classes)), yticklabels)
upper_thresh = plotMat.min() + (plotMat.max() - plotMat.min()) / 10 * 8
lower_thresh = plotMat.min() + (plotMat.max() - plotMat.min()) / 10 * 2
for i, j in itertools.product(range(plotMat.shape[0]), range(plotMat.shape[1])):
plt.text(j, i, format(plotMat[i, j], ''.2f''),
horizontalalignment="center",
color="white" if (plotMat[i, j] > upper_thresh or plotMat[i, j] < lower_thresh) else "black")
plt.ylabel(''Metrics'')
plt.xlabel(''Classes'')
plt.tight_layout()
def main():
sampleClassificationReport = """ precision recall f1-score support
Acacia 0.62 1.00 0.76 66
Blossom 0.93 0.93 0.93 40
Camellia 0.59 0.97 0.73 67
Daisy 0.47 0.92 0.62 272
Echium 1.00 0.16 0.28 413
avg / total 0.77 0.57 0.49 858"""
plot_classification_report(sampleClassificationReport)
plt.show()
plt.close()
if __name__ == ''__main__'':
main()

Answer 4

Esta es mi solución simple, usando mapa de calor marino.

import seaborn as sns
import numpy as np
from sklearn.metrics import precision_recall_fscore_support
import matplotlib.pyplot as plt
y = np.random.randint(low=0, high=10, size=100)
y_p = np.random.randint(low=0, high=10, size=100)
def plot_classification_report(y_tru, y_prd, figsize=(10, 10), ax=None):
plt.figure(figsize=figsize)
xticks = [''precision'', ''recall'', ''f1-score'', ''support'']
yticks = list(np.unique(y_tru))
yticks += [''avg'']
rep = np.array(precision_recall_fscore_support(y_tru, y_prd)).T
avg = np.mean(rep, axis=0)
avg[-1] = np.sum(rep[:, -1])
rep = np.insert(rep, rep.shape[0], avg, axis=0)
sns.heatmap(rep,
annot=True,
cbar=False,
xticklabels=xticks,
yticklabels=yticks,
ax=ax)
plot_classification_report(y, y_p)

Así se verá la trama.

Answer 5

Si solo desea trazar el informe de clasificación como un gráfico de barras en un cuaderno Jupyter, puede hacer lo siguiente.

# Assuming that classification_report, y_test and predictions are in scope...
import pandas as pd
# Build a DataFrame from the classification_report output_dict.
report_data = []
for label, metrics in classification_report(y_test, predictions, output_dict=True).items():
metrics[''label''] = label
report_data.append(metrics)
report_df = pd.DataFrame(
report_data,
columns=[''label'', ''precision'', ''recall'', ''f1-score'', ''support'']
)
# Plot as a bar chart.
report_df.plot(y=[''precision'', ''recall'', ''f1-score''], x=''label'', kind=''bar'')

Un problema con esta visualización es que las clases desequilibradas no son obvias, pero son importantes para interpretar los resultados. Una forma de representarlo es agregar una versión de la label que incluya el número de muestras (es decir, el support ):

# Add a column to the DataFrame.
report_df[''labelsupport''] = [f''{label} (n={support})''
for label, support in zip(report_df.label, report_df.support)]
# Plot the chart the same way, but use `labelsupport` as the x-axis.
report_df.plot(y=[''precision'', ''recall'', ''f1-score''], x=''labelsupport'', kind=''bar'')

Answer 6

Tu puedes hacer:

import matplotlib.pyplot as plt
cm = [[0.50, 1.00, 0.67],
[0.00, 0.00, 0.00],
[1.00, 0.67, 0.80]]
labels = [''class 0'', ''class 1'', ''class 2'']
fig, ax = plt.subplots()
h = ax.matshow(cm)
fig.colorbar(h)
ax.set_xticklabels([''''] + labels)
ax.set_yticklabels([''''] + labels)
ax.set_xlabel(''Predicted'')
ax.set_ylabel(''Ground truth'')

Answer 7

Mi solución es usar el paquete python, Yellowbrick. Yellowbrick en pocas palabras combina scikit-learn con matplotlib para producir visualizaciones para tus modelos. En unas pocas líneas puede hacer lo que se sugirió anteriormente. http://www.scikit-yb.org/en/latest/api/classifier/classification_report.html

from sklearn.naive_bayes import GaussianNB
from yellowbrick.classifier import ClassificationReport
# Instantiate the classification model and visualizer
bayes = GaussianNB()
visualizer = ClassificationReport(bayes, classes=classes, support=True)
visualizer.fit(X_train, y_train) # Fit the visualizer and the model
visualizer.score(X_test, y_test) # Evaluate the model on the test data
visualizer.poof() # Draw/show/poof the data