title: Confusion matrix on images in CNN keras
body: <p>I have trained my model(multiclass classification) of CNN using keras and now I want to evaluate the model on my test set of images.</p>
  
  <p>What are the possible options for evaluating my model apart from the accuracy, precision and recall? I know how to get the precision and recall from a custom script. But I cannot find a way to get the confusion matrix for my 12 classes of <strong>images</strong>. 
  Scikit-learn shows a <a href="http://scikit-learn.org/stable/modules/generated/sklearn.metrics.confusion_matrix.html" rel="noreferrer">way</a>, but not for images.
  I am using model.fit_generator ()</p>
  
  <p>Is there a way to create confusion matrix for all my classes or finding classification confidence on my classes? I am using Google Colab, though I can download the model and run it locally.</p>
  
  <p>Any help would be appreciated.</p>
  
  <p>Code:</p>
  
  <pre><code>train_data_path = 'dataset_cfps/train'
  validation_data_path = 'dataset_cfps/validation'
  
  #Parametres
  img_width, img_height = 224, 224
  
  vggface = VGGFace(model='resnet50', include_top=False, input_shape=(img_width, img_height, 3))
  
  #vgg_model = VGGFace(include_top=False, input_shape=(224, 224, 3))
  
  last_layer = vggface.get_layer('avg_pool').output
  x = Flatten(name='flatten')(last_layer)
  xx = Dense(256, activation = 'sigmoid')(x)
  x1 = BatchNormalization()(xx)
  x2 = Dropout(0.3)(x1)
  y = Dense(256, activation = 'sigmoid')(x2)
  yy = BatchNormalization()(y)
  y1 = Dropout(0.6)(yy)
  x3 = Dense(12, activation='sigmoid', name='classifier')(y1)
  
  custom_vgg_model = Model(vggface.input, x3)
  
  
  # Create the model
  model = models.Sequential()
  
  # Add the convolutional base model
  model.add(custom_vgg_model)
  
  model.summary()
  #model = load_model('facenet_resnet_lr3_SGD_sameas1.h5')
  
  def recall(y_true, y_pred):
       true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
       possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))
       recall = true_positives / (possible_positives + K.epsilon())
       return recall
  
  def precision(y_true, y_pred):
      true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
      predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))
      precision = true_positives / (predicted_positives + K.epsilon())
      return precision
  
  train_datagen = ImageDataGenerator(
        rescale=1./255,
        rotation_range=20,
        width_shift_range=0.2,
        height_shift_range=0.2,
        horizontal_flip=True,
        fill_mode='nearest')
  
  
  validation_datagen = ImageDataGenerator(rescale=1./255)
  
  # Change the batchsize according to your system RAM
  train_batchsize = 32
  val_batchsize = 32
  
  train_generator = train_datagen.flow_from_directory(
          train_data_path,
          target_size=(img_width, img_height),
          batch_size=train_batchsize,
          class_mode='categorical')
  
  validation_generator = validation_datagen.flow_from_directory(
          validation_data_path,
          target_size=(img_width, img_height),
          batch_size=val_batchsize,
          class_mode='categorical',
          shuffle=True)
  
  # Compile the model
  model.compile(loss='categorical_crossentropy',
                optimizer=optimizers.SGD(lr=1e-3),
                metrics=['acc', recall, precision])
  # Train the model
  history = model.fit_generator(
        train_generator,
        steps_per_epoch=train_generator.samples/train_generator.batch_size ,
        epochs=100,
        validation_data=validation_generator,
        validation_steps=validation_generator.samples/validation_generator.batch_size,
        verbose=1)
  
  # Save the model
  model.save('facenet_resnet_lr3_SGD_new_FC.h5')
  </code></pre>