frugallydeep
Use Keras models in C++ with ease
Table of contents
Introduction
Would you like to build/train a model using Keras/Python? And would you like to run the prediction (forward pass) on your model in C++ without linking your application against TensorFlow? Then frugallydeep is exactly for you.
frugallydeep
 is a small headeronly library written in modern and pure C++.
 is very easy to integrate and use.
 depends only on FunctionalPlus, Eigen and json – also headeronly libraries.
 supports inference (
model.predict
) not only for sequential models but also for computational graphs with a more complex topology, created with the functional API.  reimplements a (small) subset of TensorFlow, i.e., the operations needed to support prediction.
 results in a much smaller binary size than linking against TensorFlow.
 works outofthebox also when compiled into a 32bit executable. (Of course, 64 bit is fine too.)
 utterly ignores even the most powerful GPU in your system and uses only one CPU core per prediction. ðŸ˜‰
 but is quite fast on one CPU core compared to TensorFlow, and you can run multiple predictions in parallel, thus utilizing as many CPUs as you like to improve the overall prediction throughput of your application/pipeline.
Supported layer types
Layer types typically used in image recognition/generation are supported, making many popular model architectures possible (see Performance section).
Add
,Concatenate
,Subtract
,Multiply
,Average
,Maximum
AveragePooling1D/2D
,GlobalAveragePooling1D/2D
Bidirectional
,TimeDistributed
,GRU
,LSTM
,CuDNNGRU
,CuDNNLSTM
Conv1D/2D
,SeparableConv2D
,DepthwiseConv2D
Cropping1D/2D
,ZeroPadding1D/2D
BatchNormalization
,Dense
,Flatten
,Normalization
Dropout
,AlphaDropout
,GaussianDropout
,GaussianNoise
SpatialDropout1D
,SpatialDropout2D
,SpatialDropout3D
RandomContrast
,RandomFlip
,RandomHeight
RandomRotation
,RandomTranslation
,RandomWidth
,RandomZoom
MaxPooling1D/2D
,GlobalMaxPooling1D/2D
ELU
,LeakyReLU
,ReLU
,SeLU
,PReLU
Sigmoid
,Softmax
,Softplus
,Tanh
Exponential
,GELU
,Softsign
UpSampling1D/2D
Reshape
,Permute
,RepeatVector
Embedding
Also supported
 multiple inputs and outputs
 nested models
 residual connections
 shared layers
 variable input shapes
 arbitrary complex model architectures / computational graphs
 custom layers (by passing custom factory functions to
load_model
)
Currently not supported are the following:
ActivityRegularization
, AveragePooling3D
, Conv2DTranspose
(why), Conv3D
, ConvLSTM2D
, Cropping3D
, Dot
, GRUCell
, LocallyConnected1D
, LocallyConnected2D
, LSTMCell
, Masking
, MaxPooling3D
, RepeatVector
, RNN
, SimpleRNN
, SimpleRNNCell
, StackedRNNCells
, ThresholdedReLU
, Upsampling3D
, temporal
models
Usage

Use Keras/Python to build (
model.compile(...)
), train (model.fit(...)
) and test (model.evaluate(...)
) your model as usual. Then save it to a single HDF5 file usingmodel.save('....h5', include_optimizer=False)
. Theimage_data_format
in your model must bechannels_last
, which is the default when using the TensorFlow backend. Models created with a differentimage_data_format
and other backends are not supported. 
Now convert it to the frugallydeep file format with
keras_export/convert_model.py

Finally load it in C++ (
fdeep::load_model(...)
) and usemodel.predict(...)
to invoke a forward pass with your data.
The following minimal example shows the full workflow:
# create_model.py
import numpy as np
from tensorflow.keras.layers import Input, Dense
from tensorflow.keras.models import Model
inputs = Input(shape=(4,))
x = Dense(5, activation='relu')(inputs)
predictions = Dense(3, activation='softmax')(x)
model = Model(inputs=inputs, outputs=predictions)
model.compile(loss='categorical_crossentropy', optimizer='nadam')
model.fit(
np.asarray([[1, 2, 3, 4], [2, 3, 4, 5]]),
np.asarray([[1, 0, 0], [0, 0, 1]]), epochs=10)
model.save('keras_model.h5', include_optimizer=False)
python3 keras_export/convert_model.py keras_model.h5 fdeep_model.json
<div class="highlight highlightsourcec++ positionrelative overflowauto" datasnippetclipboardcopycontent="// main.cpp
#include
int main()
{
const auto model = fdeep::load_model("fdeep_model.json");
const auto result = model.predict(
{fdeep::tensor(fdeep::tensor_shape(static_cast(4)),
std::vector{1, 2, 3, 4})});
std::cout << fdeep::show_tensors(result) <
// main.cpp #include <fdeep/fdeep.hpp> int main() { const auto model = fdeep::load_model("fdeep_model.json"); const auto result = model.predict( {fdeep::tensor(fdeep::tensor_shape(static_cast<std::size_t>(4)), std::vector<float>{1, 2, 3, 4})}); std::cout << fdeep::show_tensors(result) << std::endl; }