CODEWITHSUNDEEP
pythonscikit-learnconfusion-matrix
Rakibul Hassan
Rakibul Hassan

Reputation: 325

plot_confusion_matrix without estimator

I'm trying to use plot_confusion_matrix,

from sklearn.metrics import confusion_matrix

y_true = [1, 1, 0, 1]
y_pred = [1, 1, 0, 0]

confusion_matrix(y_true, y_pred)

Output:

array([[1, 0],
       [1, 2]])

Now, while using the followings; using 'classes' or without 'classes'

from sklearn.metrics import plot_confusion_matrix

plot_confusion_matrix(y_true, y_pred, classes=[0,1], title='Confusion matrix, without normalization')

or

plot_confusion_matrix(y_true, y_pred, title='Confusion matrix, without normalization')

I expect to get similar output like this except the numbers inside,

enter image description here

Plotting simple diagram, it should not require the estimator.

Using mlxtend.plotting, 

from mlxtend.plotting import plot_confusion_matrix
import matplotlib.pyplot as plt
import numpy as np

binary1 = np.array([[4, 1],
                   [1, 2]])

fig, ax = plot_confusion_matrix(conf_mat=binary1)
plt.show()

It provides same output.

Based on this

it requires a classifier,

disp = plot_confusion_matrix(classifier, X_test, y_test,
                                 display_labels=class_names,
                                 cmap=plt.cm.Blues,
                                 normalize=normalize)

Can I plot it without a classifier?

Upvotes: 8

Views: 7488

Answers (5)

andKaae
andKaae

Reputation: 323

I am a bit late here, but I thought other people might benefit from my answer.

As others have mentioned using plot_confusion_matrix is not an option without the classifier but it is still possible to use sklearn to obtain a similar-looking confusion matrix without the classifier. The function below does exactly this.

from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay

def confusion_ma(y_true, y_pred, class_names):
    cm = confusion_matrix(y_true, y_pred, normalize='true')
    disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=class_names)
    disp.plot(cmap=plt.cm.Blues)
    return plt.show()

The confusion_matrix function returns a simple ndarry matrix. By passing this together with labels of the predictions to the ConfusionMatrixDisplay function a similar looking matrix is obtained. In the definition I've added the class_names to be displayed instead of 0 and 1, chosen to normalize the output and specified a colormap - change accordingly to your needs.

Upvotes: 6

Giuseppe Salerno
Giuseppe Salerno

Reputation: 85

I solved the problem of using a customized classifier; you can build any custom classifier and pass it to the plot_confusion matrix as a class:

class MyModelPredict(object):
    def __init__(self, model):
        self._estimator_type = 'classifier'
        
    def predict(self, X):
        return your_custom_prediction

model = MyModelPredict()
plot_confusion_matrix(model, X, y_true)

Upvotes: 0

g4s9
g4s9

Reputation: 1

I tested the following "identity classifier" in a Jupyter notebook running the conda_python3 kernel in Amazon SageMaker. The reason is that SageMaker's transformation job is async and so does not allow the classifier to be used in the parameters of plot_confusion_matrix, y_pred has to be calculated before calling the function.

IC = type('IdentityClassifier', (), {"predict": lambda i : i, "_estimator_type": "classifier"})
plot_confusion_matrix(IC, y_pred, y_test, normalize='true', values_format='.2%');

So while plot_confusion_matrix indeed expects an estimator, you'll not necessarily have to use another tool IMO, if this solution fits your use case.

simplified POC from the notebook

Upvotes: 0

yatu
yatu

Reputation: 88226

plot_confusion_matrix expects a trained classifier. If you look at the source code, what it does is perform the prediction to generate y_pred for you:

y_pred = estimator.predict(X)
    cm = confusion_matrix(y_true, y_pred, sample_weight=sample_weight,
                          labels=labels, normalize=normalize)

So in order to plot the confusion matrix without specifying a classifier, you'll have to go with some other tool, or do it yourself. A simple option is to use seaborn:

import seaborn as sns

cm = confusion_matrix(y_true, y_pred)
f = sns.heatmap(cm, annot=True)

enter image description here

Upvotes: 10

Edoardo Guerriero
Edoardo Guerriero

Reputation: 1250

Since plot_confusion_matrix require the argument 'estimator' not to be None, the answer is: no, you can't. But you can plot your confusion matrix in other ways, for example see this answer: How can I plot a confusion matrix?

Upvotes: 1

Related Questions