With GPU Coder™, you can generate optimized code for Simulink® models containing a variety of trained deep learning networks. You can implement
the deep learning functionality in Simulink by using MATLAB Function blocks or by using blocks from the
Deep Neural Networks library. When implementing with MATLAB
Function blocks, use the coder.loadDeepLearningNetwork
function
to load a trained deep learning network and use the object functions of the network object to
obtain the desired responses. You can configure the code generator to take advantage of the
NVIDIA®
CUDA® deep neural network library (cuDNN) and TensorRT™ high
performance inference libraries for NVIDIA GPUs. The generated code implements the deep convolutional neural network (CNN)
by using the architecture, the layers, and parameters that you specify in network object.
GoogLeNet has been trained on over a million images and can classify images into 1000
object categories (such as keyboard, coffee mug, pencil, and animals). The network takes an
image as input, and then outputs a label for the object in the image together with the
probabilities for each of the object categories. This example shows you how to perform
simulation and generate CUDA code for the pretrained googlenet
deep convolutional
neural network and classify an image.
Load the pretrained GoogLeNet network. You can choose to load a different pretrained network for image classification. If you do not have the required support packages installed, install the software according to the instructions provided.
net = googlenet;
The object net
contains the DAGNetwork
object.
Use the analyzeNetwork
function to display an interactive
visualization of the network architecture, to detect errors and issues in the network,
and to display detailed information about the network layers. The layer information
includes the sizes of layer activations and learnable parameters, the total number of
learnable parameters, and the sizes of state parameters of recurrent layers.
analyzeNetwork(net);
The image that you want to classify must have the same size as the input size of the
network. For GoogLeNet, the size of the imageInputLayer
is
224-by-224-by-3. The Classes
property of the output
classificationLayer
contains the names of the classes learned by
the network. View 10 random class names out of the total of 1000.
classNames = net.Layers(end).Classes; numClasses = numel(classNames); disp(classNames(randperm(numClasses,10)))
'speedboat' 'window screen' 'isopod' 'wooden spoon' 'lipstick' 'drake' 'hyena' 'dumbbell' 'strawberry' 'custard apple'
Create a Simulink model and insert a MATLAB Function block from the User-Defined Functions library.
Add an Image From File block from the Computer Vision Toolbox™ library and set the File name
parameter to
peppers.png
.
Add a Resize block from the Computer Vision Toolbox library to the model. Set the Specify
parameter of the Resize block to Number of output rows and
columns
and enter [224 224]
as the value for
Number of output rows and columns. This bock resizes the input
image to that of the input layer of the network.
Double-click the MATLAB Function block. A default function signature appears in the MATLAB Function Block Editor.
Define a function called googlenet_predict
, which implements the
prediction entry-point function. The function header declares in
as
an argument to the googlenet_predict
function, with
scores
and indxTop
as the return
value.
function [scores,indxTop] = googlenet_predict(in) %#codegen persistent mynet; if isempty(mynet) mynet = coder.loadDeepLearningNetwork('googlenet'); end % pass in input predict_scores = predict(mynet,in); [scores,indx] = sort(predict_scores, 'descend'); indxTop = indx(1:5);
A persistent object mynet
loads the DAGNetwork
object. At the first call to the entry-point function, the persistent object is
constructed and set up. On subsequent calls to the function, the same object is reused
to call predict
on inputs, avoiding reconstructing and reloading the
network object.
You can also use the activations
(Deep Learning Toolbox)
method to network activations for a specific layer. For example, the following line of
code returns the network activations for the layer specified in
layerIdx
.
out = activations(mynet,in,layerIdx,'OutputAs','Channels');
You can also use the classify
(Deep Learning Toolbox)
method to predict class labels for the image data in in
using the
trained network mynet
.
[out,scores] = classify(mynet,in);
For LSTM networks, you can use the predictAndUpdateState
(Deep Learning Toolbox) and resetState
(Deep Learning Toolbox)
methods. For usage notes and limitations of these method, see Supported Functions.
Open the block parameters of the MATLAB Function block. On the
Code Generation tab, select Reusable
function
for Function packaging.
Connect these blocks as shown in the diagram. Save the model as
googlenetModel
.
Model configuration parameters determine the acceleration method used during simulation.
Open the Configuration Parameters dialog box. Open the Solver pane. To compile your model for acceleration and generate CUDA code, configure the model to use a fixed-step solver. This table shows the solver configuration for this example.
Parameter | Setting | Effect on Generated Code |
---|---|---|
Type | Fixed-step | Maintains a constant (fixed) step size, which is required for code generation |
Solver | discrete (no continuous states) | Applies a fixed-step integration technique for computing the state derivative of the model |
Fixed-step size | auto | Simulink chooses the step size |
Select the Simulation Target pane. Set the
Language to C++
.
Select GPU acceleration.
options specific to GPU Coder are now visible in the Simulation Target > GPU Acceleration pane. For this example, you can use the default values for these GPU-specific parameters.
On the Simulation Target pane, set the Target
Library parameter in the Deep learning group to
cuDNN
.
You can also select TensorRT
to target
TensorRT high performance inference libraries for NVIDIA GPUs.
Click OK to save and close the Configuration Parameters dialog box.
You can use set_param
to configure the model parameter
programmatically in the MATLAB® command
Window.
set_param('googlenetModel','GPUAcceleration','on');
To build and simulate the GPU accelerated model, select Run on the Simulation tab or use the MATLAB command:
out = sim('googlenetModel');
The software first checks to see if CUDA/C++ code was previously compiled for your model. If code was created
previously, the software runs the model. If code was not previously built, the
software first generates and compiles the CUDA/C++ code, and then runs the model. The code generation tool places the
generated code in a subfolder of the working folder called
slprj/_slprj/googlenetModel
.
Display the top five predicted labels and their associated probabilities as a histogram. Because the network classifies images into so many object categories, and many categories are similar, it is common to consider the top-five accuracy when evaluating networks. The network classifies the image as a bell pepper with a high probability.
im = imread('peppers.png'); classNamesTop = classNames(out.yout{2}.Values.Data(:,:,1)) h = figure; h.Position(3) = 2*h.Position(3); ax1 = subplot(1,2,1); ax2 = subplot(1,2,2); image(ax1,im); barh(ax2,out.yout{1}.Values.Data(1,5:-1:1,1)) xlabel(ax2,'Probability') yticklabels(ax2,classNamesTop(5:-1:1)) ax2.YAxisLocation = 'right'; sgtitle('Top 5 predictions using GoogLeNet')
The model configuration parameters provide many options for the code generation and build process.
Select the Code Generation pane. Set the System
target file to grt.tlc
.
You can also use the Embedded Coder® target file, ert.tlc
.
Set the Language to C++
.
Select Generate GPU code.
Select Generate code only.
Select the Toolchain. For Linux® platforms, select NVIDIA CUDA | gmake (64-bit
Linux)
. For Windows® systems, select NVIDIA CUDA (w/Microsoft Visual C++ 20XX) |
nmake (64-bit windows)
.
On the Code Generation > Report pane, select Create code generation report and Open report automatically.
On the Code Generation > Interface pane, set the
Target Library in the Deep learning group to
cuDNN
.
You can also select TensorRT
to target
TensorRT high performance inference libraries for NVIDIA GPUs.
When the Generate GPU code parameter is enabled, options specific to GPU Coder are visible in the Code Generation > GPU Code pane. For this example, you can use the default values of the GPU-specific parameters in Code Generation > GPU Code pane.
Click OK to save and close the Configuration Parameters dialog box.
You can also use set_param
function to configure the model
parameter programmatically in the MATLAB Command
Window.
set_param('googlenetModel','GenerateGPUCode','CUDA');
In the Simulink Editor, open the Simulink Coder app.
Generate code.
Messages appear in the Diagnostics Viewer. The code generator produces CUDA source and header files, and an HTML code generation report. The code
generator places the files in a build folder, a subfolder
named googlenetModel_grt_rtw
under your current working folder.
Code generation for a deep learning network with custom layer is not supported in Simulink.
GPU code generation for MATLAB Function blocks in Stateflow® charts is not supported.
When GPU acceleration is enabled, the code generator does not
support Import custom code for importing custom authored
CUDA source files (*.cu). Instead, use coder.ceval
inside the MATLAB Function block.
The MATLAB Function block does not support all the data types from the MATLAB language. For supported data types, refer to the block documentation.
bdclose
(Simulink) | close_system
(Simulink) | get_param
(Simulink) | load_system
(Simulink) | open_system
(Simulink) | save_system
(Simulink) | set_param
(Simulink) | sim
(Simulink) | slbuild
(Simulink)