title: Returning probabilities in a classification prediction in Keras?
body: <p>I am trying to make a simple proof-of-concept where I can see the probabilities of different classes for a given prediction.</p>
  
  <p>However, everything I try seems to only output the predicted class, even though I am using a softmax activation. I am new to machine learning, so I'm not sure if I am making a simple mistake or if this is a feature not available in Keras. </p>
  
  <p>I'm using Keras + TensorFlow. I have adapted one of the <a href="https://github.com/fchollet/keras/blob/master/examples/mnist_mlp.py" rel="noreferrer">basic examples</a> given by Keras for classifying the MNIST dataset.</p>
  
  <p>My code below is exactly the same as the example, except for a few (commented) extra lines that exports the model to a local file.</p>
  
  <pre><code>'''Trains a simple deep NN on the MNIST dataset.
  Gets to 98.40% test accuracy after 20 epochs
  (there is *a lot* of margin for parameter tuning).
  2 seconds per epoch on a K520 GPU.
  '''
  
  from __future__ import print_function
  
  import keras
  from keras.datasets import mnist
  from keras.models import Sequential
  from keras.layers import Dense, Dropout
  from keras.optimizers import RMSprop
  
  import h5py # added import because it is required for model.save
  model_filepath = 'test_model.h5' # added filepath config
  
  batch_size = 128
  num_classes = 10
  epochs = 20
  
  # the data, shuffled and split between train and test sets
  (x_train, y_train), (x_test, y_test) = mnist.load_data()
  
  x_train = x_train.reshape(60000, 784)
  x_test = x_test.reshape(10000, 784)
  x_train = x_train.astype('float32')
  x_test = x_test.astype('float32')
  x_train /= 255
  x_test /= 255
  print(x_train.shape[0], 'train samples')
  print(x_test.shape[0], 'test samples')
  
  # convert class vectors to binary class matrices
  y_train = keras.utils.to_categorical(y_train, num_classes)
  y_test = keras.utils.to_categorical(y_test, num_classes)
  
  model = Sequential()
  model.add(Dense(512, activation='relu', input_shape=(784,)))
  model.add(Dropout(0.2))
  model.add(Dense(512, activation='relu'))
  model.add(Dropout(0.2))
  model.add(Dense(num_classes, activation='softmax'))
  
  model.summary()
  
  model.compile(loss='categorical_crossentropy',
            optimizer=RMSprop(),
            metrics=['accuracy'])
  
  history = model.fit(x_train, y_train,
                  batch_size=batch_size,
                  epochs=epochs,
                  verbose=1,
                  validation_data=(x_test, y_test))
  score = model.evaluate(x_test, y_test, verbose=0)
  print('Test loss:', score[0])
  print('Test accuracy:', score[1])
  
  model.save(model_filepath) # added saving model
  print('Model saved') # added log
  </code></pre>
  
  <p>Then the second part of this is a simple script that should import the model, predict the class for some given data, and print out the probabilities for each class. (I am using the same mnist class included with the Keras codebase to make an example as simple as possible).</p>
  
  <pre><code>import keras
  from keras.datasets import mnist
  from keras.models import Sequential
  import keras.backend as K
  
  import numpy
  
  # loading model saved locally in test_model.h5
  model_filepath = 'test_model.h5'
  prev_model = keras.models.load_model(model_filepath)
  
  # these lines are copied from the example for loading MNIST data
  (x_train, y_train), (x_test, y_test) = mnist.load_data()
  x_train = x_train.reshape(60000, 784)
  
  # for this example, I am only taking the first 10 images
  x_slice = x_train[slice(1, 11, 1)]
  
  # making the prediction
  prediction = prev_model.predict(x_slice)
  
  # logging each on a separate line
  for single_prediction in prediction:
      print(single_prediction)
  </code></pre>
  
  <p>If I run the first script to export the model, then the second script to classify some examples, I get the following output:</p>
  
  <pre><code>[ 1.  0.  0.  0.  0.  0.  0.  0.  0.  0.]
  [ 0.  0.  0.  0.  1.  0.  0.  0.  0.  0.]
  [ 0.  1.  0.  0.  0.  0.  0.  0.  0.  0.]
  [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  1.]
  [ 0.  0.  1.  0.  0.  0.  0.  0.  0.  0.]
  [ 0.  1.  0.  0.  0.  0.  0.  0.  0.  0.]
  [ 0.  0.  0.  1.  0.  0.  0.  0.  0.  0.]
  [ 0.  1.  0.  0.  0.  0.  0.  0.  0.  0.]
  [ 0.  0.  0.  0.  1.  0.  0.  0.  0.  0.]
  [ 0.  0.  0.  1.  0.  0.  0.  0.  0.  0.]
  </code></pre>
  
  <p>This is great for seeing which class each is predicted to be, but what if I want to see the relative probabilities of each class for each example? I am looking for something more like this:</p>
  
  <pre><code>[ 0.94 0.01 0.02 0. 0. 0.01 0. 0.01 0.01 0.]
  [ 0. 0. 0. 0. 0.51 0. 0. 0. 0.49 0.]
  ...
  </code></pre>
  
  <p>In other words, I need to know how sure each prediction is, not just the prediction itself. I thought seeing the relative probabilities was a part of using a softmax activation in the model, but I can't seem to find anything in the Keras documentation that would give me probabilities instead of the predicted answer. Am I making some kind of silly mistake, or is this feature not available?</p>