content: """
  ================
  Confusion matrix
  ================
  
  Example of confusion matrix usage to evaluate the quality
  of the output of a classifier on the iris data set. The
  diagonal elements represent the number of points for which
  the predicted label is equal to the true label, while
  off-diagonal elements are those that are mislabeled by the
  classifier. The higher the diagonal values of the confusion
  matrix the better, indicating many correct predictions.
  
  The figures show the confusion matrix with and without
  normalization by class support size (number of elements
  in each class). This kind of normalization can be
  interesting in case of class imbalance to have a more
  visual interpretation of which class is being misclassified.
  
  Here the results are not as good as they could be as our
  choice for the regularization parameter C was not the best.
  In real life applications this parameter is usually chosen
  using :ref:`grid_search`.
  
  """
  
  print(__doc__)
  
  import itertools
  import numpy as np
  import matplotlib.pyplot as plt
  
  from sklearn import svm, datasets
  from sklearn.model_selection import train_test_split
  from sklearn.metrics import confusion_matrix
  
  # import some data to play with
  iris = datasets.load_iris()
  X = iris.data
  y = iris.target
  class_names = iris.target_names
  
  # Split the data into a training set and a test set
  X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
  
  # Run classifier, using a model that is too regularized (C too low) to see
  # the impact on the results
  classifier = svm.SVC(kernel='linear', C=0.01)
  y_pred = classifier.fit(X_train, y_train).predict(X_test)
  
  
  def plot_confusion_matrix(cm, classes,
                            normalize=False,
                            title='Confusion matrix',
                            cmap=plt.cm.Blues):
      """
      This function prints and plots the confusion matrix.
      Normalization can be applied by setting `normalize=True`.
      """
      if normalize:
          cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
          print("Normalized confusion matrix")
      else:
          print('Confusion matrix, without normalization')
  
      print(cm)
  
      plt.imshow(cm, interpolation='nearest', cmap=cmap)
      plt.title(title)
      plt.colorbar()
      tick_marks = np.arange(len(classes))
      plt.xticks(tick_marks, classes, rotation=45)
      plt.yticks(tick_marks, classes)
  
      fmt = '.2f' if normalize else 'd'
      thresh = cm.max() / 2.
      for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
          plt.text(j, i, format(cm[i, j], fmt),
                   horizontalalignment="center",
                   color="white" if cm[i, j] > thresh else "black")
  
      plt.tight_layout()
      plt.ylabel('True label')
      plt.xlabel('Predicted label')
  
  # Compute confusion matrix
  cnf_matrix = confusion_matrix(y_test, y_pred)
  np.set_printoptions(precision=2)
  
  # Plot non-normalized confusion matrix
  plt.figure()
  plot_confusion_matrix(cnf_matrix, classes=class_names,
                        title='Confusion matrix, without normalization')
  
  # Plot normalized confusion matrix
  plt.figure()
  plot_confusion_matrix(cnf_matrix, classes=class_names, normalize=True,
                        title='Normalized confusion matrix')
  
  plt.show()
  