name='inputs', default='',

help='Specifies input data files to pass to numpy.load(). Format should be '

'\'<input_key>=<filename>\' or \'<input_key>=<filename>[<variable_name>]\','

name='input_exprs', default='',

help='Specifies Python literal expressions or numpy functions. Format '

'should be "<input_key>=\'<python_expression>\'", separated by \';\'. Numpy'

' can be accessed with \'np\'. Note that expressions are passed to '

'literal_eval(), making this flag susceptible to code injection. Overrides '

name='input_examples', default='',

help='Specifies tf.train.Example objects as inputs. Format should be '

'\'<input_key>=[{{feature0:value_list,feature1:value_list}}]\', where input'

' keys are separated by \';\'. Overrides duplicate input keys provided with'

name='op_denylist', default=None,

help='If specified, detects and reports the given ops. List of ops should '

'be comma-separated. If not specified, the default list of ops is '

'[WriteFile, ReadFile, PrintV2]. To specify an empty list, pass in the '

name='variables_to_feed', default='',

help='Names of the variables that will be fed into the SavedModel graph. '

'Pass in \'\' to feed no variables, \'all\' to feed all variables, or a '

'comma-separated list of variable names. Variables not fed will be frozen. '

'*NOTE* Variables passed here must be set *by the user*. These variables '

'will NOT be frozen, and their values will be uninitialized in the compiled'

name='target_triple', default='x86_64-pc-linux',

help='Triple identifying a target variation, containing information such as'

' processor architecture, vendor, operating system, and environment. '

name='cpp_class', default=None,

help='The name of the generated C++ class, wrapping the generated function.'

' Format should be [[<optional_namespace>::],...]<class_name>, i.e. the '

'same syntax as C++ for specifying a class. This class will be generated in'

name='multithreading', default='False',

help='Enable multithreading in the compiled computation. Note that with '

'this flag enabled, the resulting object files may have external '

'show': ['dir'],

'run': ['dir', 'tag_set', 'signature_def'],

'scan': ['dir'],

'convert': ['dir', 'output_dir', 'tag_set'],

'freeze_model': ['dir', 'output_prefix', 'tag_set'],

'aot_compile_cpu': ['cpp_class'],

"""Prints the tag-sets stored in SavedModel directory.

tag_sets = saved_model_utils.get_saved_model_tag_sets(saved_model_dir)

print('The given SavedModel contains the following tag-sets:')

for tag_set in sorted(tag_sets):

"""Returns a set of the ops in the MetaGraph.

all_ops_set = _get_ops_in_metagraph(meta_graph_def)

print(

'The MetaGraph with tag set %s contains the following ops:'

% meta_graph_def.meta_info_def.tags,

all_ops_set,

"""Prints the ops in the MetaGraph.

meta_graph_def = saved_model_utils.get_meta_graph_def(saved_model_dir,

tag_set)

"""Prints the keys for each SignatureDef in the SignatureDef map.

signature_def_map = get_signature_def_map(saved_model_dir, tag_set)

print('The given SavedModel MetaGraphDef contains SignatureDefs with the '

'following keys:')

for signature_def_key in sorted(signature_def_map.keys()):

signature_def_key):

"""Gets TensorInfo for all inputs of the SignatureDef.

if signature_def_key not in meta_graph_def.signature_def:

raise ValueError(

f'Could not find signature "{signature_def_key}". Please choose from: '

f'{", ".join(meta_graph_def.signature_def.keys())}')

signature_def_key):

"""Gets TensorInfos for all outputs of the SignatureDef.

"""Prints input and output TensorInfos.

inputs_tensor_info = _get_inputs_tensor_info_from_meta_graph_def(

meta_graph_def, signature_def_key

)

outputs_tensor_info = _get_outputs_tensor_info_from_meta_graph_def(

meta_graph_def, signature_def_key)

indent_str = ' ' * indent

def in_print(s):

print(indent_str + s)

in_print('The given SavedModel SignatureDef contains the following input(s):')

for input_key, input_tensor in sorted(inputs_tensor_info.items()):

in_print(' inputs[\'%s\'] tensor_info:' % input_key)

_print_tensor_info(input_tensor, indent+1)

in_print('The given SavedModel SignatureDef contains the following '

'output(s):')

for output_key, output_tensor in sorted(outputs_tensor_info.items()):

in_print(' outputs[\'%s\'] tensor_info:' % output_key)

_print_tensor_info(output_tensor, indent+1)

in_print('Method name is: %s' %

"""Prints input and output TensorInfos.

meta_graph_def = saved_model_utils.get_meta_graph_def(

saved_model_dir, tag_set

)

"""Prints the callable concrete and polymorphic functions of the Saved Model.

has_object_graph_def = False

for meta_graph_def in meta_graphs:

has_object_graph_def |= meta_graph_def.HasField('object_graph_def')

if not has_object_graph_def:

return

with ops_lib.Graph().as_default():

trackable_object = load.load(saved_model_dir)

print('\nConcrete Functions:', end='')

children = list(

save._AugmentedGraphView(trackable_object) # pylint: disable=protected-access

.list_children(trackable_object))

children = sorted(children, key=lambda x: x.name)

for name, child in children:

concrete_functions = []

if isinstance(child, defun.ConcreteFunction):

concrete_functions.append(child)

elif isinstance(child, def_function.Function):

concrete_functions.extend(

child._list_all_concrete_functions_for_serialization()) # pylint: disable=protected-access

else:

continue

print('\n Function Name: \'%s\'' % name)

concrete_functions = sorted(concrete_functions, key=lambda x: x.name)

for index, concrete_function in enumerate(concrete_functions, 1):

args, kwargs = None, None

if concrete_function.structured_input_signature:

args, kwargs = concrete_function.structured_input_signature

elif concrete_function._arg_keywords: # pylint: disable=protected-access

# For pure ConcreteFunctions we might have nothing better than

# _arg_keywords.

args = concrete_function._arg_keywords # pylint: disable=protected-access

if args:

print(' Option #%d' % index)

print(' Callable with:')

_print_args(args, indent=4)

if kwargs:

"""Formats and prints the argument of the concrete functions defined in the model.

indent_str = ' ' * indent

def _maybe_add_quotes(value):

is_quotes = '\'' * isinstance(value, str)

return is_quotes + str(value) + is_quotes

def in_print(s, end='\n'):

print(indent_str + s, end=end)

for index, element in enumerate(arguments, 1):

if indent == 4:

in_print('%s #%d' % (argument_type, index))

if isinstance(element, str):

in_print(' %s' % element)

elif isinstance(element, tensor_spec.TensorSpec):

print((indent + 1) * ' ' + '%s: %s' % (element.name, repr(element)))

elif (isinstance(element, collections_abc.Iterable) and

not isinstance(element, dict)):

in_print(' DType: %s' % type(element).__name__)

in_print(' Value: [', end='')

for value in element:

print('%s' % _maybe_add_quotes(value), end=', ')

print('\b\b]')

elif isinstance(element, dict):

in_print(' DType: %s' % type(element).__name__)

in_print(' Value: {', end='')

for (key, value) in element.items():

print('\'%s\': %s' % (str(key), _maybe_add_quotes(value)), end=', ')

print('\b\b}')

else:

in_print(' DType: %s' % type(element).__name__)

"""Prints details of the given tensor_info.

indent_str = ' ' * indent

def in_print(s):

print(indent_str + s)

in_print(' dtype: ' +

{value: key

for (key, value) in types_pb2.DataType.items()}[tensor_info.dtype])

# Display shape as tuple.

if tensor_info.tensor_shape.unknown_rank:

shape = 'unknown_rank'

else:

dims = [str(dim.size) for dim in tensor_info.tensor_shape.dim]

shape = ', '.join(dims)

shape = '(' + shape + ')'

in_print(' shape: ' + shape)

"""Prints tag-set, ops, SignatureDef, and Inputs/Outputs of SavedModel.

saved_model = saved_model_utils.read_saved_model(saved_model_dir)

for meta_graph_def in sorted(

saved_model.meta_graphs,

key=lambda meta_graph_def: list(meta_graph_def.meta_info_def.tags),

):

tag_set = meta_graph_def.meta_info_def.tags

print("\nMetaGraphDef with tag-set: '%s' "

"contains the following SignatureDefs:" % ', '.join(tag_set))

tag_set = ','.join(tag_set)

signature_def_map = meta_graph_def.signature_def

for signature_def_key in sorted(signature_def_map.keys()):

print('\nsignature_def[\'' + signature_def_key + '\']:')

_show_inputs_outputs_mgd(meta_graph_def, signature_def_key, indent=1)

_show_ops_in_metagraph_mgd(meta_graph_def)

"""DEPRECATED: Use saved_model_utils.get_meta_graph_def instead.

"""Gets SignatureDef map from a MetaGraphDef in a SavedModel.

meta_graph = saved_model_utils.get_meta_graph_def(saved_model_dir, tag_set)

"""Scans meta_graph_def and reports if there are ops on denylist.

ops_in_metagraph = set(

meta_graph_lib.ops_used_by_graph_def(meta_graph_def.graph_def))

denylisted_ops = op_denylist & ops_in_metagraph

if denylisted_ops:

# TODO(yifeif): print more warnings

print(

'MetaGraph with tag set %s contains the following denylisted ops:' %

meta_graph_def.meta_info_def.tags, denylisted_ops)

else:

print(

'MetaGraph with tag set %s does not contain the default denylisted ops:'

tag_set,

signature_def_key,

input_tensor_key_feed_dict,

outdir,

overwrite_flag,

worker=None,

init_tpu=False,

use_tfrt=False,

tf_debug=False):

"""Runs SavedModel and fetch all outputs.

# Get a list of output tensor names.

meta_graph_def = saved_model_utils.get_meta_graph_def(saved_model_dir,

tag_set)

# Re-create feed_dict based on input tensor name instead of key as session.run

# uses tensor name.

inputs_tensor_info = _get_inputs_tensor_info_from_meta_graph_def(

meta_graph_def, signature_def_key)

# Check if input tensor keys are valid.

for input_key_name in input_tensor_key_feed_dict.keys():

if input_key_name not in inputs_tensor_info:

raise ValueError(

'"%s" is not a valid input key. Please choose from %s, or use '

'--show option.' %

(input_key_name, '"' + '", "'.join(inputs_tensor_info.keys()) + '"'))

inputs_feed_dict = {

inputs_tensor_info[key].name: tensor

for key, tensor in input_tensor_key_feed_dict.items()

}

# Get outputs

outputs_tensor_info = _get_outputs_tensor_info_from_meta_graph_def(

meta_graph_def, signature_def_key)

# Sort to preserve order because we need to go from value to key later.

output_tensor_keys_sorted = sorted(outputs_tensor_info.keys())

output_tensor_names_sorted = [

outputs_tensor_info[tensor_key].name

for tensor_key in output_tensor_keys_sorted

]

config = None

if use_tfrt:

logging.info('Using TFRT session.')

config = config_pb2.ConfigProto(

experimental=config_pb2.ConfigProto.Experimental(use_tfrt=True))

with session.Session(worker, graph=ops_lib.Graph(), config=config) as sess:

if init_tpu:

print('Initializing TPU System ...')

# This is needed for freshly started worker, or if the job

# restarts after a preemption.

sess.run(tpu.initialize_system())

loader.load(sess, tag_set.split(','), saved_model_dir)

if tf_debug:

sess = local_cli_wrapper.LocalCLIDebugWrapperSession(sess)

outputs = sess.run(output_tensor_names_sorted, feed_dict=inputs_feed_dict)

for i, output in enumerate(outputs):

output_tensor_key = output_tensor_keys_sorted[i]

print('Result for output key %s:\n%s' % (output_tensor_key, output))

# Only save if outdir is specified.

if outdir:

# Create directory if outdir does not exist

if not os.path.isdir(outdir):

os.makedirs(outdir)

output_full_path = os.path.join(outdir, output_tensor_key + '.npy')

# If overwrite not enabled and file already exist, error out

if not overwrite_flag and os.path.exists(output_full_path):

raise RuntimeError(

'Output file %s already exists. Add \"--overwrite\" to overwrite'

' the existing output files.' % output_full_path)

np.save(output_full_path, output)

print('Output %s is saved to %s' % (output_tensor_key,

"""Parses input arg into dictionary that maps input to file/variable tuple.

input_dict = {}

inputs_raw = inputs_str.split(';')

for input_raw in filter(bool, inputs_raw): # skip empty strings

# Format of input=filename[variable_name]'

match = re.match(r'([^=]+)=([^\[\]]+)\[([^\[\]]+)\]$', input_raw)

if match:

input_dict[match.group(1)] = match.group(2), match.group(3)

else:

# Format of input=filename'

match = re.match(r'([^=]+)=([^\[\]]+)$', input_raw)

if match:

input_dict[match.group(1)] = match.group(2), None

else:

raise RuntimeError(

'--inputs "%s" format is incorrect. Please follow'

'"<input_key>=<filename>", or'

'"<input_key>=<filename>[<variable_name>]"' % input_raw)

"""Parses input arg into dictionary that maps input key to python expression.

input_dict = {}

for input_raw in filter(bool, input_exprs_str.split(';')):

if '=' not in input_exprs_str:

raise RuntimeError('--input_exprs "%s" format is incorrect. Please follow'

'"<input_key>=<python expression>"' % input_exprs_str)

input_key, expr = input_raw.split('=', 1)

if safe:

try:

input_dict[input_key] = ast.literal_eval(expr)

except Exception as exc:

raise RuntimeError(

f'Expression "{expr}" is not a valid python literal.') from exc

else:

# ast.literal_eval does not work with numpy expressions

input_dict[input_key] = eval(expr) # pylint: disable=eval-used

"""Parses input into dict that maps input keys to lists of tf.Example.

input_dict = preprocess_input_exprs_arg_string(input_examples_str)

for input_key, example_list in input_dict.items():

if not isinstance(example_list, list):

raise ValueError(

'tf.Example input must be a list of dictionaries, but "%s" is %s' %

(example_list, type(example_list)))

input_dict[input_key] = [

_create_example_string(example) for example in example_list

]

"""Create a serialized tf.example from feature dictionary."""

example = example_pb2.Example()

for feature_name, feature_list in example_dict.items():

if not isinstance(feature_list, list):

raise ValueError('feature value must be a list, but %s: "%s" is %s' %

(feature_name, feature_list, type(feature_list)))

if isinstance(feature_list[0], float):

example.features.feature[feature_name].float_list.value.extend(

feature_list)

elif isinstance(feature_list[0], str):

example.features.feature[feature_name].bytes_list.value.extend(

[f.encode('utf8') for f in feature_list])

elif isinstance(feature_list[0], bytes):

example.features.feature[feature_name].bytes_list.value.extend(

feature_list)

elif isinstance(feature_list[0], int):

example.features.feature[feature_name].int64_list.value.extend(

feature_list)

else:

raise ValueError(

'Type %s for value %s is not supported for tf.train.Feature.' %

(type(feature_list[0]), feature_list[0]))

input_examples_str):

"""Parses input arg strings and create inputs feed_dict.

tensor_key_feed_dict = {}

inputs = preprocess_inputs_arg_string(inputs_str)

input_exprs = preprocess_input_exprs_arg_string(input_exprs_str)

input_examples = preprocess_input_examples_arg_string(input_examples_str)

for input_tensor_key, (filename, variable_name) in inputs.items():

data = np.load(file_io.FileIO(filename, mode='rb'), allow_pickle=True) # pylint: disable=unexpected-keyword-arg

# When a variable_name key is specified for the input file

if variable_name:

# if file contains a single ndarray, ignore the input name

if isinstance(data, np.ndarray):

logging.warn(

'Input file %s contains a single ndarray. Name key \"%s\" ignored.'

% (filename, variable_name))

tensor_key_feed_dict[input_tensor_key] = data

else:

if variable_name in data:

tensor_key_feed_dict[input_tensor_key] = data[variable_name]

else:

raise RuntimeError(

'Input file %s does not contain variable with name \"%s\".' %

(filename, variable_name))

# When no key is specified for the input file.

else:

# Check if npz file only contains a single numpy ndarray.

if isinstance(data, np.lib.npyio.NpzFile):

variable_name_list = data.files

if len(variable_name_list) != 1:

raise RuntimeError(

'Input file %s contains more than one ndarrays. Please specify '

'the name of ndarray to use.' % filename)

tensor_key_feed_dict[input_tensor_key] = data[variable_name_list[0]]

else:

tensor_key_feed_dict[input_tensor_key] = data

# When input is a python expression:

for input_tensor_key, py_expr_evaluated in input_exprs.items():

if input_tensor_key in tensor_key_feed_dict:

logging.warn(

'input_key %s has been specified with both --inputs and --input_exprs'

' options. Value in --input_exprs will be used.' % input_tensor_key)

tensor_key_feed_dict[input_tensor_key] = py_expr_evaluated

# When input is a tf.Example:

for input_tensor_key, example in input_examples.items():

if input_tensor_key in tensor_key_feed_dict:

logging.warn(

'input_key %s has been specified in multiple options. Value in '

'--input_examples will be used.' % input_tensor_key)

tensor_key_feed_dict[input_tensor_key] = example

"""Function triggered by show command."""

# If all tag is specified, display all information.

if _SMCLI_ALL.value:

_show_all(_SMCLI_DIR.value)

else:

# If no tag is specified, display all tag_sets.

# If a tag set is specified:

# # If list_ops is set, display all ops in the specified MetaGraphDef.

# # If no signature_def key is specified, display all SignatureDef keys.

# # If a signature_def is specified, show its corresponding input output

# # tensor information.

if _SMCLI_TAG_SET.value is None:

if _SMCLI_LIST_OPS.value:

print('--list_ops must be paired with a tag-set or with --all.')

_show_tag_sets(_SMCLI_DIR.value)

else:

if _SMCLI_LIST_OPS.value:

_show_ops_in_metagraph(_SMCLI_DIR.value, _SMCLI_TAG_SET.value)

if _SMCLI_SIGNATURE_DEF.value is None:

_show_signature_def_map_keys(_SMCLI_DIR.value, _SMCLI_TAG_SET.value)

else:

_show_inputs_outputs(

"""Function triggered by run command.

if not _SMCLI_INPUTS.value and not _SMCLI_INPUT_EXPRS.value and not _SMCLI_INPUT_EXAMPLES.value:

raise AttributeError(

'At least one of --inputs, --input_exprs or --input_examples must be '

'required')