def export(prototxt_path, caffemodel_path, input_sources, conversion_info_path,
output_path):
conv_info = conversion_info.load(conversion_info_path)
tensor_info_by_caffe_name = {t.source_name: t for t in conv_info.tensors}
np.random.seed(0)
net = caffe.Net(prototxt_path, caffemodel_path, caffe.TEST)
net.forward(
**input_sources.create_feed_dict(_get_input_dtypes_and_shapes(net)))
has_error = False
for k, v in six.iteritems(net.blobs):
tensor_info = tensor_info_by_caffe_name.get(k)
if tensor_info is not None:
filename = os.path.join(output_path,
tensor_info.target_name + ".dat")
arr = v.data.copy()
if np.isnan(arr).any():
print("Error: '{}' has nan's".format(tensor_info.target_name))
has_error = True
elif not np.isfinite(arr).all():
print("Error: '{}' has inf's".format(tensor_info.target_name))
has_error = True
try:
for transform in tensor_info.transforms:
arr = transform.apply_np(arr)
write_nnef_tensor(filename, np.asarray(arr, order='C'))
except ValueError as e:
print("Error: Can not export '{}': {}".format(
tensor_info.target_name, e))
if has_error:
raise utils.NNEFToolsException("There were errors!")
def tf_export_activations(input_shapes,
input_sources,
conversion_info_file_name,
output_directory,
checkpoint_path=None,
init_variables=False,
tensors_per_iter=25):
from nnef_tools.activation_export.tensorflow.tf_activation_exporter import export
input_shapes = tf_get_input_shapes(input_shape=input_shapes)
feed_dict = create_feed_dict(input_sources=input_sources,
input_shapes=input_shapes)
info = conversion_info.load(conversion_info_file_name)
export(output_path=output_directory,
feed_dict=feed_dict,
conversion_info=info,
checkpoint_path=checkpoint_path,
tensors_per_iter=tensors_per_iter,
init_variables=init_variables)
def _test(self,
fun,
cmp=True,
custom_tf_to_nnef_converters="",
custom_nnef_to_tf_converters="",
test_module="tests.activation.tf_py_layer_test_cases"):
out_dir = os.path.join("out", fun.__name__)
try:
tf.reset_default_graph()
tf.set_random_seed(0)
network_outputs = fun()
feed_dict = get_feed_dict()
checkpoint_path = os.path.join("out", fun.__name__,
"orig_checkpoint",
fun.__name__ + ".ckpt")
checkpoint_path = save_random_checkpoint(network_outputs,
checkpoint_path,
feed_dict)
tf.reset_default_graph()
tf.set_random_seed(0)
compress_nnef = False
command = """
./nnef_tools/convert.py --input-framework=tensorflow-py \\
--output-framework=nnef \\
--input-model={module}.{network}{checkpoint} \\
--output-directory=out/{network}/nnef \\
--custom-converters="{custom}" \\
--permissive \\
--io-transformation=SMART_TF_NHWC_TO_NCHW \\
{compress}
""".format(checkpoint=':' +
checkpoint_path if checkpoint_path else "",
network=fun.__name__,
custom=custom_tf_to_nnef_converters,
compress="--compress" if compress_nnef else "",
module=test_module)
convert.convert_using_command(command)
open(os.path.join("out", fun.__name__, "__init__.py"), "w").close()
tf.reset_default_graph()
tf.set_random_seed(0)
fun()
conv_info = conversion_info.load(
os.path.join("out", fun.__name__, "nnef", "conversion.json"))
tf_activation_exporter.export(output_path=os.path.join(
"out", fun.__name__, "nnef", "activations"),
feed_dict=feed_dict,
conversion_info=conv_info,
checkpoint_path=checkpoint_path,
verbose=False)
prefer_nhwc_options = [True]
if tf_has_cuda_gpu():
prefer_nhwc_options += [False]
for prefer_nhwc in prefer_nhwc_options:
print("Converting to TensorFlow {}".format(
"NHWC" if prefer_nhwc else "NCHW"))
data_format_str = ("nhwc" if prefer_nhwc else "nchw")
tf_output_dir = os.path.join("out", fun.__name__,
"tf_" + data_format_str)
command = """
./nnef_tools/convert.py --input-framework=nnef \\
--output-framework=tensorflow-py \\
--input-model=out/{network}/nnef/model{tgz} \\
--output-directory={output} \\
--io-transformation=SMART_NCHW_TO_TF_NHWC \\
--custom-converters="{custom}" \\
--permissive
""".format(network=fun.__name__,
custom=custom_nnef_to_tf_converters,
tgz=".nnef.tgz" if compress_nnef else "",
output=tf_output_dir)
convert.convert_using_command(command)
open(os.path.join(tf_output_dir, "__init__.py"), "w").close()
open(os.path.join(tf_output_dir, "model", "__init__.py"),
"w").close()
with open(os.path.join(tf_output_dir, "model",
"model.py")) as f:
tf_src = f.read()
# noinspection PyProtectedMember
new_net_fun = tf_py_io._tfsource_to_function(
tf_src, fun.__name__)
conv_info_tf_to_nnef = conversion_info.load(
os.path.join(out_dir, "nnef", "conversion.json"))
conv_info_nnef_to_tf = conversion_info.load(
os.path.join(tf_output_dir, "conversion.json"))
conv_info_tf_to_tf = conversion_info.compose(
conv_info_tf_to_nnef, conv_info_nnef_to_tf)
conversion_info.dump(
conv_info_tf_to_tf,
os.path.join(tf_output_dir, "conv_info_tf_to_tf.json"))
feed_dict2 = activation_test.transform_feed_dict(
feed_dict, conv_info_tf_to_tf)
nnef2_out_dir = os.path.join(out_dir,
"nnef_from_tf_" + data_format_str)
tf.reset_default_graph()
tf.set_random_seed(0)
command = """
./nnef_tools/convert.py --input-framework=tensorflow-py \\
--output-framework=nnef \\
--input-model={input}{checkpoint} \\
--output-directory={output} \\
--custom-converters="{custom}" \\
--permissive \\
--io-transformation=SMART_TF_NHWC_TO_NCHW \\
{compress}
""".format(checkpoint=(
':' +
(os.path.join(tf_output_dir, "model", "checkpoint",
"model.ckpt") if checkpoint_path else "")),
input=tf_output_dir.replace('/', '.') +
".model.model." + fun.__name__,
custom=custom_tf_to_nnef_converters,
compress="--compress" if compress_nnef else "",
output=nnef2_out_dir)
convert.convert_using_command(command)
conv_info_tf_to_nnef2 = conversion_info.load(
os.path.join(out_dir, "nnef_from_tf_" + data_format_str,
"conversion.json"))
conv_info_nnef_to_nnef = conversion_info.compose(
conv_info_nnef_to_tf, conv_info_tf_to_nnef2)
conversion_info.dump(
conv_info_nnef_to_nnef,
os.path.join(nnef2_out_dir, "conv_info_nnef_to_nnef.json"))
tf.reset_default_graph()
tf.set_random_seed(0)
new_net_fun()
tf_activation_exporter.export(
output_path=os.path.join(nnef2_out_dir, "activations"),
feed_dict=feed_dict2,
conversion_info=conv_info_tf_to_nnef2,
checkpoint_path=(os.path.join(tf_output_dir, "model",
"checkpoint", "model.ckpt")
if checkpoint_path else None),
verbose=False)
if cmp:
activation_test.compare_activation_dirs(
os.path.join(out_dir, "nnef", "activations"),
os.path.join(out_dir,
"nnef_from_tf_" + data_format_str,
"activations"),
conv_info_nnef_to_nnef,
verbose=False)
finally:
if DELETE_DATS_AND_CHECKPOINTS:
dat_files = recursive_glob(out_dir, "*.dat")
checkpoints = recursive_glob(out_dir, "*ckpt*")
for file_name in set(dat_files + checkpoints):
os.remove(file_name)
def _test_network(path, source_shape=1):
assert utils.is_anyint(source_shape) or isinstance(
source_shape, (list, tuple))
network = os.path.basename(path.rsplit('.', 1)[0])
command = """
./nnef_tools/convert.py --input-format=tensorflow-pb \\
--input-model={path} \\
--output-format=nnef \\
--output-model=out/nnef/{network}.nnef.tgz \\
--compress \\
--conversion-info \\
--input-shape="{shape}" """.format(
path=path, network=network, shape=source_shape)
print(command)
convert.convert_using_command(command)
for prefer_nchw in [False, True]:
print("Prefer NCHW" if prefer_nchw else "Prefer NHWC")
prefer_nchw_opt = "--prefer-nchw" if prefer_nchw else ""
prefer_nchw_str = "_prefer_nchw" if prefer_nchw else ""
command = """
./nnef_tools/convert.py --input-format=nnef \\
--input-model=out/nnef/{network}.nnef.tgz \\
--output-format=tensorflow-pb \\
--output-model=out/tensorflow-pb{nchw_str}/{network}.pb \\
--conversion-info \\
{nchw_opt}""".format(
network=network,
nchw_str=prefer_nchw_str,
nchw_opt=prefer_nchw_opt)
print(command)
convert.convert_using_command(command)
command = """
./nnef_tools/convert.py --input-format=tensorflow-pb \\
--input-model=out/tensorflow-pb{nchw_str}/{network}.pb \\
--output-format=nnef \\
--output-model=out/nnef2{nchw_str}/{network}.nnef.tgz \\
--compress \\
--conversion-info""".format(
network=network, nchw_str=prefer_nchw_str)
print(command)
convert.convert_using_command(command)
activation_testing = int(
os.environ.get('NNEF_ACTIVATION_TESTING', '1'))
print("Activation testing is",
"ON" if activation_testing else "OFF")
if activation_testing:
import numpy as np
import tensorflow as tf
from nnef_tools import export_activation
from nnef_tools.activation_export.tensorflow import tf_activation_exporter
def normalize_shape(shape, default=1):
return [
int(dim.value) if dim.value is not None else default
for dim in shape.dims
]
tf.reset_default_graph()
export_activation.tf_set_default_graph_from_pb(path)
if isinstance(source_shape, (list, tuple)):
feed_dict = {
placeholder.name: np.random.random(source_shape)
for placeholder in get_placeholders()
}
else:
feed_dict = {
placeholder.name: np.random.random(
normalize_shape(placeholder.shape,
default=source_shape))
for placeholder in get_placeholders()
}
conv_info_tf_to_nnef = conversion_info.load(
os.path.join("out", 'nnef',
network + ".nnef.tgz.conversion.json"))
tf_activation_exporter.export(
output_path=os.path.join("out", 'nnef', network +
".nnef.tgz.activations"),
feed_dict=feed_dict,
conversion_info=conv_info_tf_to_nnef,
input_output_only=True,
verbose=False)
conv_info_nnef_to_tf = conversion_info.load(
os.path.join('out', 'tensorflow-pb' + prefer_nchw_str,
network + ".pb.conversion.json"))
conv_info_tf_to_tf = conversion_info.compose(
conv_info_tf_to_nnef, conv_info_nnef_to_tf)
feed_dict2 = activation_test.transform_feed_dict(
feed_dict, conv_info_tf_to_tf)
conv_info_tf_to_nnef2 = conversion_info.load(
os.path.join('out', 'nnef2' + prefer_nchw_str,
network + ".nnef.tgz.conversion.json"))
conv_info_nnef_to_nnef = conversion_info.compose(
conv_info_nnef_to_tf, conv_info_tf_to_nnef2)
tf.reset_default_graph()
export_activation.tf_set_default_graph_from_pb(
os.path.join('out', 'tensorflow-pb' + prefer_nchw_str,
network + ".pb"))
tf_activation_exporter.export(
output_path=os.path.join("out", 'nnef2' + prefer_nchw_str,
network +
".nnef.tgz.activations"),
feed_dict=feed_dict2,
conversion_info=conv_info_tf_to_nnef2,
input_output_only=True,
verbose=False)
activation_test.compare_activation_dirs(
os.path.join("out", 'nnef',
network + ".nnef.tgz.activations"),
os.path.join("out", 'nnef2' + prefer_nchw_str,
network + ".nnef.tgz.activations"),
conv_info_nnef_to_nnef,
verbose=False)
def _test(self,
fun,
cmp=True,
custom_tf_to_nnef_converters="",
custom_nnef_to_tf_converters="",
test_module="nnef_tests.conversion.tf_py_layer_test_cases"):
activation_testing = int(os.environ.get('NNEF_ACTIVATION_TESTING',
'1'))
print("Activation testing is", "ON" if activation_testing else "OFF")
out_dir = os.path.join("out", fun.__name__)
try:
tf.reset_default_graph()
tf.set_random_seed(0)
network_outputs = fun()
feed_dict = get_feed_dict()
checkpoint_path = os.path.join("out", fun.__name__,
"orig_checkpoint",
fun.__name__ + ".ckpt")
checkpoint_path = save_random_checkpoint(network_outputs,
checkpoint_path,
feed_dict)
tf.reset_default_graph()
tf.set_random_seed(0)
compress_nnef = False
command = """
./nnef_tools/convert.py --input-format tensorflow-py \\
--output-format nnef \\
--input-model {module}.{network} {checkpoint} \\
--output-model out/{network}/{network}.nnef{tgz} \\
--custom-converters {custom} \\
--permissive \\
--io-transformation SMART_TF_NHWC_TO_NCHW \\
--conversion-info \\
{compress}
""".format(
checkpoint=checkpoint_path if checkpoint_path else "",
network=fun.__name__,
custom=" ".join(custom_tf_to_nnef_converters),
compress="--compress" if compress_nnef else "",
module=test_module,
tgz=".tgz" if compress_nnef else "")
convert.convert_using_command(command)
if activation_testing:
tf.reset_default_graph()
tf.set_random_seed(0)
fun()
conv_info = conversion_info.load(
os.path.join("out", fun.__name__,
fun.__name__ + ".nnef.conversion.json"))
tf_activation_exporter.export(output_path=os.path.join(
"out", fun.__name__, fun.__name__ + ".nnef",
"activations"),
feed_dict=feed_dict,
conversion_info=conv_info,
checkpoint_path=checkpoint_path,
verbose=False)
prefer_nhwc_options = [True]
if tf_has_cuda_gpu():
prefer_nhwc_options += [False]
for prefer_nhwc in prefer_nhwc_options:
print("Converting to TensorFlow {}".format(
"NHWC" if prefer_nhwc else "NCHW"))
data_format_str = ("nhwc" if prefer_nhwc else "nchw")
tf_output_path = os.path.join(
"out", fun.__name__,
fun.__name__ + '_' + data_format_str + '.py')
command = """
./nnef_tools/convert.py --input-format nnef \\
--output-format tensorflow-py \\
--input-model out/{network}/{network}.nnef{tgz} \\
--output-model {output} \\
--io-transformation SMART_NCHW_TO_TF_NHWC \\
--custom-converters {custom} \\
--permissive \\
--conversion-info
""".format(network=fun.__name__,
custom=" ".join(custom_nnef_to_tf_converters),
tgz=".nnef.tgz" if compress_nnef else "",
output=tf_output_path)
convert.convert_using_command(command)
with open(os.path.join(tf_output_path), 'r') as f:
tf_src = f.read()
# noinspection PyProtectedMember
new_net_fun = tf_py_io._tfsource_to_function(
tf_src, fun.__name__)
conv_info_tf_to_nnef = conversion_info.load(
os.path.join("out", fun.__name__,
fun.__name__ + ".nnef.conversion.json"))
conv_info_nnef_to_tf = conversion_info.load(
os.path.join(tf_output_path + ".conversion.json"))
conv_info_tf_to_tf = conversion_info.compose(
conv_info_tf_to_nnef, conv_info_nnef_to_tf)
conversion_info.dump(
conv_info_tf_to_tf,
os.path.join(tf_output_path + ".conv_info_tf_to_tf.json"))
feed_dict2 = activation_test.transform_feed_dict(
feed_dict, conv_info_tf_to_tf)
nnef2_out_dir = os.path.join(tf_output_path + ".nnef")
tf.reset_default_graph()
tf.set_random_seed(0)
command = """
./nnef_tools/convert.py --input-format tensorflow-py \\
--output-format nnef \\
--input-model {input} {checkpoint} \\
--output-model {output} \\
--custom-converters {custom} \\
--permissive \\
--io-transformation SMART_TF_NHWC_TO_NCHW \\
--conversion-info \\
{compress}
""".format(
checkpoint=(os.path.join(tf_output_path + ".checkpoint")
if checkpoint_path else ""),
input=tf_output_path.replace('/', '.')[:-len('.py')] +
"." + fun.__name__,
custom=" ".join(custom_tf_to_nnef_converters),
compress="--compress" if compress_nnef else "",
output=nnef2_out_dir)
convert.convert_using_command(command)
conv_info_tf_to_nnef2 = conversion_info.load(
nnef2_out_dir + ".conversion.json")
conv_info_nnef_to_nnef = conversion_info.compose(
conv_info_nnef_to_tf, conv_info_tf_to_nnef2)
conversion_info.dump(
conv_info_nnef_to_nnef,
os.path.join(nnef2_out_dir +
".conv_info_nnef_to_nnef.json"))
if activation_testing:
tf.reset_default_graph()
tf.set_random_seed(0)
new_net_fun()
tf_activation_exporter.export(
output_path=os.path.join(nnef2_out_dir, "activations"),
feed_dict=feed_dict2,
conversion_info=conv_info_tf_to_nnef2,
checkpoint_path=(os.path.join(tf_output_path +
".checkpoint")
if checkpoint_path else None),
verbose=False)
if cmp:
activation_test.compare_activation_dirs(
os.path.join("out", fun.__name__,
fun.__name__ + ".nnef",
"activations"),
os.path.join(nnef2_out_dir, "activations"),
conv_info_nnef_to_nnef,
verbose=False)
finally:
if self.delete_dats_and_checkpoints:
dat_files = utils.recursive_glob(out_dir, "*.dat")
checkpoints = utils.recursive_glob(out_dir, "*ckpt*")
for file_name in set(dat_files + checkpoints):
os.remove(file_name)
def test_tf_pb(filename, source_shapes, feed_dict, prefer_nhwc, network_name,
export_io_only, delete_after_each):
dir = os.path.join('out',
network_name + ('_nhwc' if prefer_nhwc else '_nchw'))
if os.path.exists(dir):
shutil.rmtree(dir)
tf_pb_all_in_one.convert_tf_pb_to_nnef(
file_name=filename,
output_directory=os.path.join(dir, 'nnef'),
network_name=network_name,
optimization_level=tf_pb_all_in_one.OptimizationLevel.FULL,
io_transform=tf_pb_all_in_one.IOTransform.SMART_TF_NHWC_TO_NCHW,
source_shapes=source_shapes,
activation_export_feed_dict=feed_dict,
activation_export_io_only=export_io_only)
conv_info1 = conversion_info.load(
os.path.join(dir, 'nnef', 'conversion.json'))
tf_pb_all_in_one.convert_nnef_to_tf_pb(
nnef_tgz_or_dir_path=os.path.join(dir, 'nnef', network_name + '_nnef'),
output_directory=os.path.join(dir, 'tf_pb'),
optimization_level=tf_pb_all_in_one.OptimizationLevel.FULL,
io_transform=(tf_pb_all_in_one.IOTransform.SMART_NCHW_TO_TF_NHWC
if prefer_nhwc else
tf_pb_all_in_one.IOTransform.SMART_NCHW_TO_TF_NCHW),
prefer_nhwc=prefer_nhwc)
conv_info2 = conversion_info.load(
os.path.join(dir, 'tf_pb', 'conversion.json'))
feed_dict2 = (activation_test.transform_feed_dict(
feed_dict=feed_dict,
conv_info=conversion_info.compose(conv_info1, conv_info2))
if feed_dict is not None else None)
tf_pb_all_in_one.convert_tf_pb_to_nnef(
file_name=os.path.join(dir, 'tf_pb', 'graph.pb'),
output_directory=os.path.join(dir, 'nnef2'),
network_name=network_name,
optimization_level=tf_pb_all_in_one.OptimizationLevel.FULL,
io_transform=(tf_pb_all_in_one.IOTransform.SMART_TF_NHWC_TO_NCHW
if prefer_nhwc else
tf_pb_all_in_one.IOTransform.SMART_TF_NCHW_TO_NCHW),
activation_export_feed_dict=feed_dict2,
activation_export_io_only=export_io_only)
conv_info3 = conversion_info.load(
os.path.join(dir, 'nnef2', 'conversion.json'))
if feed_dict is not None:
activation_test.compare_activation_dirs(
os.path.join(dir, 'nnef', 'activations'),
os.path.join(dir, 'nnef2', 'activations'),
conv_info=conversion_info.compose(conv_info2, conv_info3),
verbose=False,
allowed_bad_pixel_ratio=0.01
if not prefer_nhwc and not export_io_only else 0.0)
if delete_after_each:
shutil.rmtree(dir)