predict

Predict responses using a trained deep learning neural network

Syntax

YPred = predict(net,imds)

YPred = predict(net,ds)

YPred = predict(net,X)

YPred = predict(net,tbl)

[YPred1,...,YPredM] = predict(___)

YPred = predict(net,sequences)

___ = predict(___,Name,Value)

Description

You can make predictions using a trained neural network for deep learning on either a CPU or GPU. Using a GPU requires Parallel Computing Toolbox™ and a CUDA^® enabled NVIDIA^® GPU with compute capability 3.0 or higher. Specify the hardware requirements using the ExecutionEnvironment name-value pair argument.

YPred = predict(net,imds) predicts responses for the image data in imds using the trained SeriesNetwork or DAGNetwork object net. For dlnetwork input, see predict.

YPred = predict(net,ds) predicts responses for the data in the datastore ds. For networks with multiple inputs, use this syntax with a combined or transformed datastore object.

YPred = predict(net,X) predicts responses for the data in the numeric array X.

YPred = predict(net,tbl) predicts responses for the data in the table tbl.

[YPred1,...,YPredM] = predict(___) predicts responses for the M outputs of a multi-output network using any of the previous syntaxes. The output YPredj corresponds to the network output net.OutputNames(j). To return categorical outputs for the classification output layers, set the 'ReturnCategorical' option to true.

YPred = predict(net,sequences) predicts responses for the sequence or time series data in sequences using the trained LSTM network net.

___ = predict(___,Name,Value) predicts responses with additional options specified by one or more name-value pair arguments.

Tip

When making predictions with sequences of different lengths, the mini-batch size can impact the amount of padding added to the input data which can result in different predicted values. Try using different values to see which works best with your network. To specify mini-batch size and padding options, use the 'MiniBatchSize' and 'SequenceLength' options.

Examples

Predict Output Scores Using a Trained ConvNet

Load the sample data.

[XTrain,YTrain] = digitTrain4DArrayData;

digitTrain4DArrayData loads the digit training set as 4-D array data. XTrain is a 28-by-28-by-1-by-5000 array, where 28 is the height and 28 is the width of the images. 1 is the number of channels and 5000 is the number of synthetic images of handwritten digits. YTrain is a categorical vector containing the labels for each observation.

Construct the convolutional neural network architecture.

layers = [ ...
    imageInputLayer([28 28 1])
    convolution2dLayer(5,20)
    reluLayer
    maxPooling2dLayer(2,'Stride',2)
    fullyConnectedLayer(10)
    softmaxLayer
    classificationLayer];

Set the options to default settings for the stochastic gradient descent with momentum.

options = trainingOptions('sgdm');

Train the network.

rng('default')
net = trainNetwork(XTrain,YTrain,layers,options);

Training on single CPU.
Initializing input data normalization.
|========================================================================================|
|  Epoch  |  Iteration  |  Time Elapsed  |  Mini-batch  |  Mini-batch  |  Base Learning  |
|         |             |   (hh:mm:ss)   |   Accuracy   |     Loss     |      Rate       |
|========================================================================================|
|       1 |           1 |       00:00:00 |       10.16% |       2.3195 |          0.0100 |
|       2 |          50 |       00:00:05 |       50.78% |       1.7102 |          0.0100 |
|       3 |         100 |       00:00:10 |       63.28% |       1.1632 |          0.0100 |
|       4 |         150 |       00:00:15 |       60.16% |       1.0859 |          0.0100 |
|       6 |         200 |       00:00:21 |       68.75% |       0.8996 |          0.0100 |
|       7 |         250 |       00:00:27 |       76.56% |       0.7919 |          0.0100 |
|       8 |         300 |       00:00:32 |       73.44% |       0.8411 |          0.0100 |
|       9 |         350 |       00:00:38 |       81.25% |       0.5514 |          0.0100 |
|      11 |         400 |       00:00:43 |       90.62% |       0.4744 |          0.0100 |
|      12 |         450 |       00:00:49 |       92.19% |       0.3614 |          0.0100 |
|      13 |         500 |       00:00:54 |       94.53% |       0.3159 |          0.0100 |
|      15 |         550 |       00:01:01 |       96.09% |       0.2543 |          0.0100 |
|      16 |         600 |       00:01:06 |       92.19% |       0.2765 |          0.0100 |
|      17 |         650 |       00:01:12 |       95.31% |       0.2461 |          0.0100 |
|      18 |         700 |       00:01:18 |       99.22% |       0.1418 |          0.0100 |
|      20 |         750 |       00:01:24 |       98.44% |       0.1000 |          0.0100 |
|      21 |         800 |       00:01:30 |       98.44% |       0.1448 |          0.0100 |
|      22 |         850 |       00:01:36 |       98.44% |       0.0989 |          0.0100 |
|      24 |         900 |       00:01:43 |       96.88% |       0.1316 |          0.0100 |
|      25 |         950 |       00:01:49 |      100.00% |       0.0859 |          0.0100 |
|      26 |        1000 |       00:01:56 |      100.00% |       0.0701 |          0.0100 |
|      27 |        1050 |       00:02:08 |      100.00% |       0.0759 |          0.0100 |
|      29 |        1100 |       00:02:17 |       99.22% |       0.0663 |          0.0100 |
|      30 |        1150 |       00:02:22 |       98.44% |       0.0775 |          0.0100 |
|      30 |        1170 |       00:02:25 |       99.22% |       0.0732 |          0.0100 |
|========================================================================================|

Run the trained network on a test set and predict the scores.

[XTest,YTest] = digitTest4DArrayData;
YPred = predict(net,XTest);

predict, by default, uses a CUDA® enabled GPU with compute capability 3.0, when available. You can also choose to run predict on a CPU using the 'ExecutionEnvironment','cpu' name-value pair argument.

Display the first 10 images in the test data and compare to the predictions from predict.

YTest(1:10,:)

ans = 10x1 categorical
     0 
     0 
     0 
     0 
     0 
     0 
     0 
     0 
     0 
     0 

YPred(1:10,:)

ans = 10x10 single matrix

    0.9978    0.0001    0.0008    0.0002    0.0003    0.0000    0.0004    0.0000    0.0002    0.0003
    0.8883    0.0000    0.0472    0.0001    0.0000    0.0002    0.0029    0.0001    0.0014    0.0599
    0.9998    0.0000    0.0000    0.0000    0.0000    0.0000    0.0000    0.0000    0.0000    0.0001
    0.9814    0.0000    0.0000    0.0000    0.0000    0.0000    0.0046    0.0000    0.0011    0.0129
    0.9748    0.0000    0.0132    0.0003    0.0000    0.0000    0.0002    0.0004    0.0112    0.0001
    0.9872    0.0000    0.0001    0.0000    0.0000    0.0000    0.0007    0.0000    0.0072    0.0047
    0.9981    0.0000    0.0000    0.0000    0.0000    0.0000    0.0018    0.0000    0.0000    0.0000
    1.0000    0.0000    0.0000    0.0000    0.0000    0.0000    0.0000    0.0000    0.0000    0.0000
    0.9270    0.0000    0.0046    0.0000    0.0006    0.0009    0.0001    0.0000    0.0018    0.0650
    0.9328    0.0000    0.0139    0.0012    0.0001    0.0001    0.0378    0.0000    0.0110    0.0031

YTest contains the digits corresponding to the images in XTest. The columns of YPred contain predict’s estimation of a probability that an image contains a particular digit. That is, the first column contains the probability estimate that the given image is digit 0, the second column contains the probability estimate that the image is digit 1, the third column contains the probability estimate that the image is digit 2, and so on. You can see that predict’s estimation of probabilities for the correct digits are almost 1 and the probability for any other digit is almost 0. predict correctly estimates the first 10 observations as digit 0.

Predict Output Scores Using a Trained LSTM Network

Load pretrained network. JapaneseVowelsNet is a pretrained LSTM network trained on the Japanese Vowels dataset as described in [1] and [2]. It was trained on the sequences sorted by sequence length with a mini-batch size of 27.

load JapaneseVowelsNet

View the network architecture.

net.Layers

ans = 
  5x1 Layer array with layers:

     1   'sequenceinput'   Sequence Input          Sequence input with 12 dimensions
     2   'lstm'            LSTM                    LSTM with 100 hidden units
     3   'fc'              Fully Connected         9 fully connected layer
     4   'softmax'         Softmax                 softmax
     5   'classoutput'     Classification Output   crossentropyex with '1' and 8 other classes

Load the test data.

[XTest,YTest] = japaneseVowelsTestData;

Make predictions on the test data.

YPred = predict(net,XTest);

View the prediction scores for the first 10 sequences.

YPred(1:10,:)

ans = 10x9 single matrix

    0.9918    0.0000    0.0000    0.0000    0.0006    0.0010    0.0001    0.0006    0.0059
    0.9868    0.0000    0.0000    0.0000    0.0006    0.0010    0.0001    0.0010    0.0105
    0.9924    0.0000    0.0000    0.0000    0.0006    0.0010    0.0001    0.0006    0.0054
    0.9896    0.0000    0.0000    0.0000    0.0006    0.0009    0.0001    0.0007    0.0080
    0.9965    0.0000    0.0000    0.0000    0.0007    0.0009    0.0000    0.0003    0.0016
    0.9888    0.0000    0.0000    0.0000    0.0006    0.0010    0.0001    0.0008    0.0087
    0.9886    0.0000    0.0000    0.0000    0.0006    0.0010    0.0001    0.0008    0.0089
    0.9982    0.0000    0.0000    0.0000    0.0006    0.0007    0.0000    0.0001    0.0004
    0.9883    0.0000    0.0000    0.0000    0.0006    0.0010    0.0001    0.0008    0.0093
    0.9959    0.0000    0.0000    0.0000    0.0007    0.0011    0.0000    0.0004    0.0019

Compare these prediction scores to the labels of these sequences. The function assigns high prediction scores to the correct class.

YTest(1:10)

ans = 10x1 categorical
     1 
     1 
     1 
     1 
     1 
     1 
     1 
     1 
     1 
     1 

Input Arguments

net — Trained network

SeriesNetwork object | DAGNetwork object

Trained network, specified as a SeriesNetwork or a DAGNetwork object. You can get a trained network by importing a pretrained network (for example, by using the googlenet function) or by training your own network using trainNetwork.

imds — Image datastore

ImageDatastore object

Image datastore, specified as an ImageDatastore object.

ImageDatastore allows batch reading of JPG or PNG image files using prefetching. If you use a custom function for reading the images, then ImageDatastore does not prefetch.

Tip

Use augmentedImageDatastore for efficient preprocessing of images for deep learning including image resizing.

Do not use the readFcn option of imageDatastore as this option is usually significantly slower.

ds — Datastore

datastore

Datastore of input data.

For networks with a single input, ds can return either:

• a single image or sequence

• a cell array of images or sequences

• a table, where the first column contains images or sequences

For networks with multiple image inputs layers, ds must be a combined or transformed datastore that returns a cell array with numInputs columns containing the input data, where numInputs is the number of network inputs. The ith element of the cell array corresponds to the input net.InputNames(i).

For more information, see Datastores for Deep Learning.

X — Image data

numeric array

Image data, specified as a numeric array. The size of the array depends on the type of image input:

Input	Description
2-D images	A h-by-w-by-c-by-N numeric array, where h, w, and c are the height, width, and number of channels of the images, respectively, and N is the number of images.
3-D images	A h-by-w-by-d-by-c-by-N numeric array, where h, w, d, and c are the height, width, depth, and number of channels of the images, respectively, and N is the number of images.

If the array contains NaNs, then they are propagated through the network.

sequences — Sequence or time series data

cell array of numeric arrays | numeric array | datastore

Sequence or time series data, specified as an N-by-1 cell array of numeric arrays, where N is the number of observations, a numeric array representing a single sequence, or a datastore.

For cell array or numeric array input, the dimensions of the numeric arrays containing the sequences depend on the type of data.

Input	Description
Vector sequences	c-by-s matrices, where c is the number of features of the sequences and s is the sequence length.
2-D image sequences	h-by-w-by-c-by-s arrays, where h, w, and c correspond to the height, width, and number of channels of the images, respectively, and s is the sequence length.
3-D image sequences	h-by-w-by-d-by-c-by-s, where h, w, d, and c correspond to the height, width, depth, and number of channels of the 3-D images, respectively, and s is the sequence length.

For datastore input, the datastore must return data as a cell array of sequences or a table whose first column contains sequences. The dimensions of the sequence data must correspond to the table above.

tbl — Table of images

table

Table of images containing the input data in the first column. Each row in the table corresponds to an observation. The table contains absolute or relative file paths to an image, specified as a character vector or images specified as a numeric array.

Data Types: table

Name-Value Pair Arguments

Example: 'MiniBatchSize',256 specifies the mini-batch size as 256.

Specify optional comma-separated pair of Name,Value argument. Name is the argument name and Value is the corresponding value. Name must appear inside single quotes (' ').

'MiniBatchSize' — Size of mini-batches

128 (default) | positive integer

Size of mini-batches to use for prediction, specified as a positive integer. Larger mini-batch sizes require more memory, but can lead to faster predictions.

When making predictions with sequences of different lengths, the mini-batch size can impact the amount of padding added to the input data which can result in different predicted values. Try using different values to see which works best with your network. To specify mini-batch size and padding options, use the 'MiniBatchSize' and 'SequenceLength' options.

Example: 'MiniBatchSize',256

'Acceleration' — Performance optimization

'auto' (default) | 'mex' | 'none'

Performance optimization, specified as the comma-separated pair consisting of 'Acceleration' and one of the following:

• 'auto' — Automatically apply a number of optimizations suitable for the input network and hardware resource.

• 'mex' — Compile and execute a MEX function. This option is available when using a GPU only. Using a GPU requires Parallel Computing Toolbox and a CUDA enabled NVIDIA GPU with compute capability 3.0 or higher. If Parallel Computing Toolbox or a suitable GPU is not available, then the software returns an error.

• 'none' — Disable all acceleration.

The default option is 'auto'. If 'auto' is specified, MATLAB^® will apply a number of compatible optimizations. If you use the 'auto' option, MATLAB does not ever generate a MEX function.

Using the 'Acceleration' options 'auto' and 'mex' can offer performance benefits, but at the expense of an increased initial run time. Subsequent calls with compatible parameters are faster. Use performance optimization when you plan to call the function multiple times using new input data.

The 'mex' option generates and executes a MEX function based on the network and parameters used in the function call. You can have several MEX functions associated with a single network at one time. Clearing the network variable also clears any MEX functions associated with that network.

The 'mex' option is only available when you are using a GPU. You must have a C/C++ compiler installed and the GPU Coder™ Interface for Deep Learning Libraries support package. Install the support package using the Add-On Explorer in MATLAB. For setup instructions, see MEX Setup (GPU Coder). GPU Coder is not required.

The 'mex' option does not support all layers. For a list of supported layers, see Supported Layers (GPU Coder). Recurrent neural networks (RNNs) containing a sequenceInputLayer are not supported.

You cannot use MATLAB Compiler™ to deploy your network when using the 'mex' option.

Example: 'Acceleration','mex'

'ExecutionEnvironment' — Hardware resource

'auto' (default) | 'gpu' | 'cpu'

Hardware resource, specified as the comma-separated pair consisting of 'ExecutionEnvironment' and one of the following:

• 'auto' — Use a GPU if one is available; otherwise, use the CPU.

• 'gpu' — Use the GPU. Using a GPU requires Parallel Computing Toolbox and a CUDA enabled NVIDIA GPU with compute capability 3.0 or higher. If Parallel Computing Toolbox or a suitable GPU is not available, then the software returns an error.

• 'cpu' — Use the CPU.

Example: 'ExecutionEnvironment','cpu'

'ReturnCategorical' — Option to return categorical labels

false (default) | true

Option to return categorical labels, specified as true or false.

If ReturnCategorical is true, then the function returns categorical labels for classification output layers. Otherwise, the function returns the prediction scores for classification output layers.

'SequenceLength' — Option to pad, truncate, or split input sequences

'longest' (default) | 'shortest' | positive integer

Option to pad, truncate, or split input sequences, specified as one of the following:

• 'longest' — Pad sequences in each mini-batch to have the same length as the longest sequence. This option does not discard any data, though padding can introduce noise to the network.

• 'shortest' — Truncate sequences in each mini-batch to have the same length as the shortest sequence. This option ensures that no padding is added, at the cost of discarding data.

• Positive integer — For each mini-batch, pad the sequences to the nearest multiple of the specified length that is greater than the longest sequence length in the mini-batch, and then split the sequences into smaller sequences of the specified length. If splitting occurs, then the software creates extra mini-batches. Use this option if the full sequences do not fit in memory. Alternatively, try reducing the number of sequences per mini-batch by setting the 'MiniBatchSize' option to a lower value.

To learn more about the effect of padding, truncating, and splitting the input sequences, see Sequence Padding, Truncation, and Splitting.

Example: 'SequenceLength','shortest'

'SequencePaddingDirection' — Direction of padding or truncation

'right' (default) | 'left'

Direction of padding or truncation, specified as one of the following:

• 'right' — Pad or truncate sequences on the right. The sequences start at the same time step and the software truncates or adds padding to the end of the sequences.

• 'left' — Pad or truncate sequences on the left. The software truncates or adds padding to the start of the sequences so that the sequences end at the same time step.

Because LSTM layers process sequence data one time step at a time, when the layer OutputMode property is 'last', any padding in the final time steps can negatively influence the layer output. To pad or truncate sequence data on the left, set the 'SequencePaddingDirection' option to 'left'.

For sequence-to-sequence networks (when the OutputMode property is 'sequence' for each LSTM layer), any padding in the first time steps can negatively influence the predictions for the earlier time steps. To pad or truncate sequence data on the right, set the 'SequencePaddingDirection' option to 'right'.

To learn more about the effect of padding, truncating, and splitting the input sequences, see Sequence Padding, Truncation, and Splitting.

'SequencePaddingValue' — Value to pad input sequences

0 (default) | scalar

Value by which to pad input sequences, specified as a scalar. The option is valid only when SequenceLength is 'longest' or a positive integer. Do not pad sequences with NaN, because doing so can propagate errors throughout the network.

Example: 'SequencePaddingValue',-1

Output Arguments

YPred — Predicted scores or responses

matrix | 4-D numeric array | cell array of matrices

Predicted scores or responses, returned as a matrix, a 4-D numeric array, or a cell array of matrices. The format of YPred depends on the type of problem.

The following table describes the format for classification problems.

Task	Format
Image classification	N-by-K matrix, where N is the number of observations, and K is the number of classes
Sequence-to-label classification
Sequence-to-sequence classification	N-by-1 cell array of matrices, where N is the number of observations. The sequences are matrices with K rows, where K is the number of classes. Each sequence has the same number of time steps as the corresponding input sequence after applying the SequenceLength option to each mini-batch independently.

The following table describes the format for regression problems.

Task	Format
2-D image regression	N-by-R matrix, where N is the number of images and R is the number of responses. h-by-w-by-c-by-N numeric array, where h, w, and c are the height, width, and number of channels of the images, respectively, and N is the number of images.
3-D image regression	N-by-R matrix, where N is the number of images and R is the number of responses. h-by-w-by-d-by-c-by-N numeric array, where h, w, d, and c are the height, width, depth, and number of channels of the images, respectively, and N is the number of images.
Sequence-to-one regression	N-by-R matrix, where N is the number of sequences and R is the number of responses.
Sequence-to-sequence regression	N-by-1 cell array of numeric sequences, where N is the number of sequences. The sequences are matrices with R rows, where R is the number of responses. Each sequence has the same number of time steps as the corresponding input sequence after applying the SequenceLength option to each mini-batch independently.

For sequence-to-sequence regression problems with one observation, sequences can be a matrix. In this case, YPred is a matrix of responses.

Algorithms

If the image data contains NaNs, predict propagates them through the network. If the network has ReLU layers, these layers ignore NaNs. However, if the network does not have a ReLU layer, then predict returns NaNs as predictions.

All functions for deep learning training, prediction, and validation in Deep Learning Toolbox™ perform computations using single-precision, floating-point arithmetic. Functions for deep learning include trainNetwork, predict, classify, and activations. The software uses single-precision arithmetic when you train networks using both CPUs and GPUs.

Alternatives

You can compute the predicted scores and the predicted classes from a trained network using classify.

You can also compute the activations from a network layer using activations.

For sequence-to-label and sequence-to-sequence classification networks (LSTM networks), you can make predictions and update the network state using classifyAndUpdateState and predictAndUpdateState.

References

[1] M. Kudo, J. Toyama, and M. Shimbo. "Multidimensional Curve Classification Using Passing-Through Regions." Pattern Recognition Letters. Vol. 20, No. 11–13, pages 1103–1111.

[2] UCI Machine Learning Repository: Japanese Vowels Dataset. https://archive.ics.uci.edu/ml/datasets/Japanese+Vowels

Extended Capabilities

C/C++ Code Generation

Generate C and C++ code using MATLAB® Coder™.

Usage notes and limitations:

• Only the syntax YPred = predict(net,X) is supported.

• The input X must not have a variable size. The size must be fixed at code generation time.

For more information about generating code for deep learning neural networks, see Workflow for Deep Learning Code Generation with MATLAB Coder (MATLAB Coder).

GPU Code Generation

Generate CUDA® code for NVIDIA® GPUs using GPU Coder™.

Usage notes and limitations:

• GPU code generation supports the following syntaxes:

  • YPred = predict(net,X)

  • [YPred1,...,YPredM] = predict(__)

  • YPred = predict(net,sequences)

  • __ = predict(__,Name,Value)

• The input X must not have variable size. The size must be fixed at code generation time.

• GPU code generation for the predict function supports inputs that are defined as half-precision floating point data types. For more information, see half.

• GPU code generation supports only vector sequences. The sequence length can be variable sized. The feature dimension must be fixed at code generation time.

• Only the 'MiniBatchSize', 'SequenceLength', 'SequencePaddingDirection', and 'SequencePaddingValue' name-value pair arguments are supported for code generation. All name-value pairs must be compile-time constants.

• Only the 'longest' and 'shortest' option of the 'SequenceLength' name-value pair is supported for code generation.