Skip to content
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
144 lines (112 sloc) 4.8 KB

BigDL supports loading and saving tensorflow models. This page will give you a basic introduction of this feature. For more interesting and sophisticated examples, please checkout here.

Loading a Tensorflow model into BigDL

BigDL supports loading tensorflow model with only a few lines of code.

If we already have a freezed graph protobuf file, we can use the loadTF api directly to load the tensorflow model.

Otherwise, we should first use the script provided by BigDL's distribution package, or the dump_model function defined in here to generate the model definition file (model.pb) and variable binary file (model.bin).

Generate model definition file and variable binary file

Use Script


Use python function

import tensorflow as tf

# This is your model definition.
xs = tf.placeholder(tf.float32, [None, 1])

W1 = tf.Variable(tf.zeros([1,10])+0.2)
b1 = tf.Variable(tf.zeros([10])+0.1)
Wx_plus_b1 = tf.nn.bias_add(tf.matmul(xs,W1), b1)
output = tf.nn.tanh(Wx_plus_b1, name="output")

# Adding the following lines right after your model definition 
from bigdl.util.tf_utils import dump_model
dump_model_path = "/tmp/model"
# This line of code will create a Session and initialized all the Variable and
# save the model definition and variable to dump_model_path as BigDL readable format.

Optionally, you can also pass in a initialized (either from scratch or from a checkpoint) Session object containing all the variables of your model or pass in a pre-trained checkpoint path directly. See the dump_model doc in this file.

Load Tensorflow model in BigDL


import java.nio.ByteOrder

val modelPath = "/tmp/model/model.pb"
val binPath = "/tmp/model/model.bin"
val inputs = Seq("Placeholder")
val outputs = Seq("output")
val model = Module.loadTF(modelPath, Seq("Placeholder"),
    Seq("output"), ByteOrder.LITTLE_ENDIAN, Some(binPath))


from bigdl.nn.layer import *
model_def = "/tmp/model/model.pb"
model_variable = "/tmp/model/model.bin"
inputs = ["Placeholder"]
outputs = ["output"]
model = Model.load_tensorflow(model_def, inputs, outputs, byte_order = "little_endian", bigdl_type="float", bin_file=model_variable)

Saving a BigDL functional model to Tensorflow model file

You can also save a functional model to protobuf files so that it can be used in Tensorflow inference.

When saving the model, placeholders will be added to the tf model as input nodes. So you need to pass in the names and shapes of the placeholders. BigDL model does not have such information. The order of the placeholder information should be same as the inputs of the graph model.


// create a graph model
val linear = Linear(10, 2).inputs()
val sigmoid = Sigmoid().inputs(linear)
val softmax = SoftMax().inputs(sigmoid)
val model = Graph(Array(linear), Array(softmax))

// save it to Tensorflow model file
model.saveTF(Seq(("input", Seq(4, 10))), "/tmp/model.pb")


from bigdl.nn.layer import *
from bigdl.optim.optimizer import *
from bigdl.util.common import *

# create a graph model
linear = Linear(10, 2)()
sigmoid = Sigmoid()(linear)
softmax = SoftMax()(sigmoid)
model = Model([linear], [softmax])

# save it to Tensorflow model file
model.save_tensorflow([("input", [4, 10])], "/tmp/model.pb")

Build Tensorflow model and run on BigDL

You can construct your BigDL model directly from the input and output nodes of Tensorflow model. That is to say, you can use Tensorflow to define a model and use BigDL to run it.


import tensorflow as tf
import numpy as np
from bigdl.nn.layer import *

input = tf.placeholder(tf.float32, [None, 5])
weight = tf.Variable(tf.random_uniform([5, 10]))
bias = tf.Variable(tf.random_uniform([10]))
middle = tf.nn.bias_add(tf.matmul(input, weight), bias)
output = tf.nn.tanh(middle)

# construct BigDL model and get the result form 
bigdl_model = Model(input, output, model_type="tensorflow")

Supported Operations

Please check this page

You can’t perform that action at this time.