def _build_with_sig_def(sess, graph, sig_def):
# pylint: disable=protected-access
assert sig_def, 'signature_def must not be None'
with sess.as_default(), graph.as_default():
feed_mapping = {}
feed_names = []
for sigdef_key, tnsr_info in sig_def.inputs.items():
tnsr_name = tnsr_info.name
feed_mapping[sigdef_key] = tnsr_name
feed_names.append(tnsr_name)
fetch_mapping = {}
fetch_names = []
for sigdef_key, tnsr_info in sig_def.outputs.items():
tnsr_name = tnsr_info.name
fetch_mapping[sigdef_key] = tnsr_name
fetch_names.append(tnsr_name)
for tnsr_name in feed_names:
assert tfx.get_op(tnsr_name, graph), \
'requested tensor {} but found none in graph {}'.format(tnsr_name, graph)
fetches = [tfx.get_tensor(tnsr_name, graph) for tnsr_name in fetch_names]
graph_def = tfx.strip_and_freeze_until(fetches, graph, sess)
return TFInputGraph(graph_def=graph_def, input_tensor_name_from_signature=feed_mapping,
output_tensor_name_from_signature=fetch_mapping)
def _stripGraph(self, tf_graph):
gdef = tfx.strip_and_freeze_until([self._getFinalOutputOpName()],
tf_graph)
g = tf.Graph()
with g.as_default():
tf.import_graph_def(gdef, name='')
return g
def test_prediction_vs_tensorflow_inceptionV3(self):
output_col = "prediction"
image_df = image_utils.getSampleImageDF()
# An example of how a pre-trained keras model can be used with TFImageTransformer
with KSessionWrap() as (sess, g):
with g.as_default():
K.set_learning_phase(0) # this is important but it's on the user to call it.
# nChannels needed for input_tensor in the InceptionV3 call below
image_string = utils.imageInputPlaceholder(nChannels = 3)
resized_images = tf.image.resize_images(image_string,
InceptionV3Constants.INPUT_SHAPE)
preprocessed = preprocess_input(resized_images)
model = InceptionV3(input_tensor=preprocessed, weights="imagenet")
graph = tfx.strip_and_freeze_until([model.output], g, sess, return_graph=True)
transformer = TFImageTransformer(inputCol="image", outputCol=output_col, graph=graph,
inputTensor=image_string, outputTensor=model.output,
outputMode="vector")
transformed_df = transformer.transform(image_df.limit(10))
self.assertDfHasCols(transformed_df, [output_col])
collected = transformed_df.collect()
transformer_values, transformer_topK = self.transformOutputToComparables(collected,
"filePath",
output_col)
tf_values, tf_topK = self._executeTensorflow(graph, image_string.name, model.output.name,
image_df)
self.compareClassSets(tf_topK, transformer_topK)
self.compareClassOrderings(tf_topK, transformer_topK)
self.compareArrays(tf_values, transformer_values)
def _stripGraph(self, tf_graph):
gdef = tfx.strip_and_freeze_until([self._getFinalOutputOpName()],
tf_graph)
g = tf.Graph() # pylint: disable=invalid-name
with g.as_default(): # pylint: disable=not-context-manager
tf.import_graph_def(gdef, name='')
return g
def _build_with_sig_def(sess, graph, sig_def):
# pylint: disable=protected-access
assert sig_def, 'signature_def must not be None'
with sess.as_default(), graph.as_default():
feed_mapping = {}
feed_names = []
for sigdef_key, tnsr_info in sig_def.inputs.items():
tnsr_name = tnsr_info.name
feed_mapping[sigdef_key] = tnsr_name
feed_names.append(tnsr_name)
fetch_mapping = {}
fetch_names = []
for sigdef_key, tnsr_info in sig_def.outputs.items():
tnsr_name = tnsr_info.name
fetch_mapping[sigdef_key] = tnsr_name
fetch_names.append(tnsr_name)
for tnsr_name in feed_names:
assert tfx.get_op(tnsr_name, graph), \
'requested tensor {} but found none in graph {}'.format(tnsr_name, graph)
fetches = [
tfx.get_tensor(tnsr_name, graph) for tnsr_name in fetch_names
]
graph_def = tfx.strip_and_freeze_until(fetches, graph, sess)
return TFInputGraph(graph_def=graph_def,
input_tensor_name_from_signature=feed_mapping,
output_tensor_name_from_signature=fetch_mapping)
def test_prediction_vs_tensorflow_inceptionV3(self):
output_col = "prediction"
image_df = image_utils.getSampleImageDF()
# An example of how a pre-trained keras model can be used with TFImageTransformer
with KSessionWrap() as (sess, g):
with g.as_default():
K.set_learning_phase(0) # this is important but it's on the user to call it.
# nChannels needed for input_tensor in the InceptionV3 call below
image_string = utils.imageInputPlaceholder(nChannels=3)
resized_images = tf.image.resize_images(image_string,
InceptionV3Constants.INPUT_SHAPE)
# keras expects array in RGB order, we get it from image schema in BGR => need to flip
preprocessed = preprocess_input(imageIO._reverseChannels(resized_images))
model = InceptionV3(input_tensor=preprocessed, weights="imagenet")
graph = tfx.strip_and_freeze_until([model.output], g, sess, return_graph=True)
transformer = TFImageTransformer(channelOrder='BGR', inputCol="image", outputCol=output_col, graph=graph,
inputTensor=image_string, outputTensor=model.output,
outputMode="vector")
transformed_df = transformer.transform(image_df.limit(10))
self.assertDfHasCols(transformed_df, [output_col])
collected = transformed_df.collect()
transformer_values, transformer_topK = self.transformOutputToComparables(collected,
output_col, lambda row: row['image']['origin'])
tf_values, tf_topK = self._executeTensorflow(graph, image_string.name, model.output.name,
image_df)
self.compareClassSets(tf_topK, transformer_topK)
self.compareClassOrderings(tf_topK, transformer_topK)
self.compareArrays(tf_values, transformer_values)
def _buildTFGraphForName(name, featurize):
"""
Currently only supports pre-trained models from the Keras applications module.
"""
modelData = keras_apps.getKerasApplicationModel(name).getModelData(featurize)
sess = modelData["session"]
outputTensorName = modelData["outputTensorName"]
graph = tfx.strip_and_freeze_until([outputTensorName], sess.graph, sess, return_graph=True)
modelData["graph"] = graph
return modelData
def _buildTFGraphForName(name, featurize):
"""
Currently only supports pre-trained models from the Keras applications module.
"""
modelData = keras_apps.getKerasApplicationModel(name).getModelData(featurize)
sess = modelData["session"]
outputTensorName = modelData["outputTensorName"]
graph = tfx.strip_and_freeze_until([outputTensorName], sess.graph, sess, return_graph=True)
modelData["graph"] = graph
return modelData
def _loadTFGraph(self):
with KSessionWrap() as (sess, g):
assert K.backend() == "tensorflow", \
"Keras backend is not tensorflow but KerasImageTransformer only supports " + \
"tensorflow-backed Keras models."
with g.as_default():
K.set_learning_phase(0) # Testing phase
model = load_model(self.getModelFile())
out_op_name = tfx.op_name(g, model.output)
self._inputTensor = model.input.name
self._outputTensor = model.output.name
return tfx.strip_and_freeze_until([out_op_name], g, sess, return_graph=True)
def _loadTFGraph(self):
with KSessionWrap() as (sess, graph):
assert K.backend() == "tensorflow", \
"Keras backend is not tensorflow but KerasImageTransformer only supports " + \
"tensorflow-backed Keras models."
with graph.as_default():
K.set_learning_phase(0) # Testing phase
model = load_model(self.getModelFile())
out_op_name = tfx.op_name(model.output, graph)
self._inputTensor = model.input.name
self._outputTensor = model.output.name
return tfx.strip_and_freeze_until([out_op_name], graph, sess, return_graph=True)
def _buildTFGraphForName(name, featurize):
if name == "InceptionV3":
modelData = _buildInceptionV3Session(featurize)
else:
raise ValueError("%s is not a supported model. Supported models: %s" % name,
str(SUPPORTED_MODELS))
sess = modelData["session"]
outputTensorName = modelData["outputTensorName"]
graph = tfx.strip_and_freeze_until([outputTensorName], sess.graph, sess, return_graph=True)
modelData["graph"] = graph
return modelData
def _build_with_feeds_fetches(sess, graph, feed_names, fetch_names):
assert feed_names is not None, "must provide feed_names"
assert fetch_names is not None, "must provide fetch names"
with sess.as_default(), graph.as_default():
for tnsr_name in feed_names:
assert tfx.get_op(tnsr_name, graph), \
'requested tensor {} but found none in graph {}'.format(tnsr_name, graph)
fetches = [tfx.get_tensor(tnsr_name, graph) for tnsr_name in fetch_names]
graph_def = tfx.strip_and_freeze_until(fetches, graph, sess)
return TFInputGraph(graph_def=graph_def, input_tensor_name_from_signature=None,
output_tensor_name_from_signature=None)
def asGraphFunction(self, inputs, outputs, strip_and_freeze=True):
"""
Export the graph in this session as a :py:class:`GraphFunction` object
:param inputs: list, graph elements representing the inputs
:param outputs: list, graph elements representing the outputs
:param strip_and_freeze: bool, should we remove unused part of the graph and freee its values
"""
if strip_and_freeze:
gdef = tfx.strip_and_freeze_until(outputs, self.graph, self.sess)
else:
gdef = self.graph.as_graph_def(add_shapes=True)
return GraphFunction(graph_def=gdef,
input_names=[tfx.validated_input(self.graph, elem) for elem in inputs],
output_names=[tfx.validated_output(self.graph, elem) for elem in outputs])
def asGraphFunction(self, inputs, outputs, strip_and_freeze=True):
"""
Export the graph in this session as a :py:class:`GraphFunction` object
:param inputs: list, graph elements representing the inputs
:param outputs: list, graph elements representing the outputs
:param strip_and_freeze: bool, should we remove unused part of the graph and freee its values
"""
if strip_and_freeze:
gdef = tfx.strip_and_freeze_until(outputs, self.graph, self.sess)
else:
gdef = self.graph.as_graph_def(add_shapes=True)
return GraphFunction(graph_def=gdef,
input_names=[tfx.validated_input(elem, self.graph) for elem in inputs],
output_names=[tfx.validated_output(elem, self.graph) for elem in outputs])
def gen_model(name,
license,
model,
model_file,
version=VERSION,
featurize=True):
g = tf.Graph()
with tf.Session(graph=g) as session:
K.set_learning_phase(0)
inTensor = tf.placeholder(dtype=tf.string,
shape=[],
name="%s_input" % name)
decoded = tf.decode_raw(inTensor, tf.uint8)
imageTensor = tf.to_float(
tf.reshape(
decoded,
shape=[1, model.inputShape()[0],
model.inputShape()[1], 3]))
m = model.model(preprocessed=model.preprocess(imageTensor),
featurize=featurize)
outTensor = tf.to_double(tf.reshape(m.output, [-1]),
name="%s_sparkdl_output__" % name)
gdef = tfx.strip_and_freeze_until([outTensor], session.graph, session,
False)
g2 = tf.Graph()
with tf.Session(graph=g2) as session:
tf.import_graph_def(gdef, name='')
filename = "sparkdl-%s_%s.pb" % (name, version)
print('writing out ', filename)
tf.train.write_graph(g2.as_graph_def(),
logdir="./",
name=filename,
as_text=False)
with open("./" + filename, "r") as f:
h = sha256(f.read()).digest()
base64_hash = b64encode(h)
print('h', base64_hash)
model_file.write(
indent(
scala_template % {
"license": license,
"name": name,
"height": model.inputShape()[0],
"width": model.inputShape()[1],
"filename": filename,
"base64": base64_hash
}, 2))
return g2
def _build_with_feeds_fetches(sess, graph, feed_names, fetch_names):
assert feed_names is not None, "must provide feed_names"
assert fetch_names is not None, "must provide fetch names"
with sess.as_default(), graph.as_default():
for tnsr_name in feed_names:
assert tfx.get_op(tnsr_name, graph), \
'requested tensor {} but found none in graph {}'.format(tnsr_name, graph)
fetches = [
tfx.get_tensor(tnsr_name, graph) for tnsr_name in fetch_names
]
graph_def = tfx.strip_and_freeze_until(fetches, graph, sess)
return TFInputGraph(graph_def=graph_def,
input_tensor_name_from_signature=None,
output_tensor_name_from_signature=None)
def _buildTFGraphForName(name, featurize):
if name == "InceptionV3":
modelData = _buildInceptionV3Session(featurize)
else:
raise ValueError(
"%s is not a supported model. Supported models: %s" % name,
str(SUPPORTED_MODELS))
sess = modelData["session"]
outputTensorName = modelData["outputTensorName"]
graph = tfx.strip_and_freeze_until([outputTensorName],
sess.graph,
sess,
return_graph=True)
modelData["graph"] = graph
return modelData
def _buildTFGraphForName(name, featurize):
if name not in keras_apps.KERAS_APPLICATION_MODELS:
raise ValueError(
"%s is not a supported model. Supported models: %s" % name,
str(KERAS_APPLICATION_MODELS))
modelData = keras_apps.getKerasApplicationModel(name).getModelData(
featurize)
sess = modelData["session"]
outputTensorName = modelData["outputTensorName"]
graph = tfx.strip_and_freeze_until([outputTensorName],
sess.graph,
sess,
return_graph=True)
modelData["graph"] = graph
return modelData
def _loadTFGraph(self, sess, graph):
"""
Loads the Keras model into memory, then uses the passed-in session to load the
model's inference-related ops into the passed-in Tensorflow graph.
:return: A tuple (graph, input_name, output_name) where graph is the TF graph
corresponding to the Keras model's inference subgraph, input_name is the name of the
Keras model's input tensor, and output_name is the name of the Keras model's output tensor.
"""
keras_backend = K.backend()
assert keras_backend == "tensorflow", \
"Only tensorflow-backed Keras models are supported, tried to load Keras model " \
"with backend %s."%(keras_backend)
with graph.as_default():
K.set_learning_phase(0) # Inference phase
model = load_model(self.getModelFile())
out_op_name = tfx.op_name(model.output, graph)
stripped_graph = tfx.strip_and_freeze_until([out_op_name], graph, sess,
return_graph=True)
return stripped_graph, model.input.name, model.output.name
def _loadTFGraph(self, sess, graph):
"""
Loads the Keras model into memory, then uses the passed-in session to load the
model's inference-related ops into the passed-in Tensorflow graph.
:return: A tuple (graph, input_name, output_name) where graph is the TF graph
corresponding to the Keras model's inference subgraph, input_name is the name of the
Keras model's input tensor, and output_name is the name of the Keras model's output tensor.
"""
keras_backend = K.backend()
assert keras_backend == "tensorflow", \
"Only tensorflow-backed Keras models are supported, tried to load Keras model " \
"with backend %s." % (keras_backend)
with graph.as_default():
K.set_learning_phase(0) # Inference phase
model = load_model(self.getModelFile())
out_op_name = tfx.op_name(model.output, graph)
stripped_graph = tfx.strip_and_freeze_until([out_op_name], graph, sess,
return_graph=True)
return stripped_graph, model.input.name, model.output.name
def gen_model(name, license, model, model_file, version=VERSION, featurize=True):
g = tf.Graph()
with tf.Session(graph=g) as session:
K.set_learning_phase(0)
inTensor = tf.placeholder(dtype=tf.string, shape=[], name="%s_input" % name)
decoded = tf.decode_raw(inTensor, tf.uint8)
imageTensor = tf.to_float(
tf.reshape(
decoded,
shape=[
1,
model.inputShape()[0],
model.inputShape()[1],
3]))
m = model.model(preprocessed=model.preprocess(imageTensor), featurize=featurize)
outTensor = tf.to_double(tf.reshape(m.output, [-1]), name="%s_sparkdl_output__" % name)
gdef = tfx.strip_and_freeze_until([outTensor], session.graph, session, False)
g2 = tf.Graph()
with tf.Session(graph=g2) as session:
tf.import_graph_def(gdef, name='')
filename = "sparkdl-%s_%s.pb" % (name, version)
print('writing out ', filename)
tf.train.write_graph(g2.as_graph_def(), logdir="./", name=filename, as_text=False)
with open("./" + filename, "r") as f:
h = sha256(f.read()).digest()
base64_hash = b64encode(h)
print('h', base64_hash)
model_file.write(indent(
scala_template % {
"license": license,
"name": name,
"height": model.inputShape()[0],
"width": model.inputShape()[1],
"filename": filename,
"base64": base64_hash},2))
return g2
def _stripGraph(self, tf_graph):
gdef = tfx.strip_and_freeze_until([self._getFinalOutputOpName()], tf_graph)
g = tf.Graph() # pylint: disable=invalid-name
with g.as_default(): # pylint: disable=not-context-manager
tf.import_graph_def(gdef, name='')
return g
# model creation
from pyspark.ml.classification import LogisticRegression
from pyspark.ml import Pipeline
from sparkdl import readImages, TFImageTransformer
import sparkdl.graph.utils as tfx # strip_and_freeze_until was moved from sparkdl.transformers to sparkdl.graph.utils in 0.2.0
from sparkdl.transformers import utils
import tensorflow as tf
graph = tf.Graph()
with tf.Session(graph=graph) as sess:
image_arr = utils.imageInputPlaceholder()
resized_images = tf.image.resize_images(image_arr, (299, 299))
# the following step is not necessary for this graph, but can be for graphs with variables, etc
frozen_graph = tfx.strip_and_freeze_until([resized_images],
graph,
sess,
return_graph=True)
transformer = TFImageTransformer(inputCol="image",
outputCol="features",
graph=frozen_graph,
inputTensor=image_arr,
outputTensor=resized_images)
processed_image_df = transformer.transform(test_df)
processed_image_df.show()
#model.save(model_path)
#with open(model_path, 'rb') as f:
# f_content = f.read()
#tf.gfile.FastGFile(model_hdfs_path, 'wb').write(f_content)
print("-------------CAN TRANSFORM--------------")
