def get_1st_feature_extractor_tensors(
detection_graph: tf.Graph) -> (dict, dict):
allDict = {}
allDictShape = {}
currentBlockID = 0
currentUnitID = 0
convNum = 1
for i, n in enumerate(detection_graph.as_graph_def().node):
if "FirstStageFeatureExtractor" in n.name:
if (CONV_CST in n.name.lower()
or SHORTCUT_CST in n.name) and n.name.endswith('weights'):
blockFind = n.name.find(BLOCK_CST)
tensor = getTensor(detection_graph, n.name)
if blockFind == -1:
allDict[CONV_CST + str(convNum)] = tensor
allDictShape[CONV_CST + str(convNum)] = tensor.shape
else:
blockID, unitID, convID = getBUC(n.name)
if blockID != currentBlockID:
allDict[blockID] = {}
allDictShape[blockID] = {}
currentBlockID = blockID
currentUnitID = 0
if unitID != currentUnitID:
allDict[blockID][unitID] = {}
allDictShape[blockID][unitID] = {}
currentUnitID = unitID
if SHORTCUT_CST in n.name:
convID = SHORTCUT_CST
allDict[blockID][unitID][convID] = tensor
allDictShape[blockID][unitID][convID] = tensor.shape
return allDict, allDictShape
def get_2nd_feature_extractor_weights(detection_graph: tf.Graph,
sess: tf.Session) -> dict:
allDict = {}
prevName = ""
currentBlockID = 0
currentUnitID = 0
currentConvID = 0
shortcut = False
c2 = 0
convNum = 1
for i, n in enumerate(detection_graph.as_graph_def().node):
if "SecondStageFeatureExtractor" in n.name:
if (CONV_CST in n.name.lower()
or SHORTCUT_CST in n.name) and n.name.endswith('weights'):
blockFind = n.name.find(BLOCK_CST)
tensor = getTensor(detection_graph, n.name)
weights = getWeightsByTensor(sess, tensor)
if blockFind == -1:
allDict[n.name] = weights
else:
blockID, unitID, convID = getBUC(n.name)
if blockID != currentBlockID:
allDict[blockID] = {}
currentBlockID = blockID
currentUnitID = 0
if unitID != currentUnitID:
allDict[blockID][unitID] = {}
currentUnitID = unitID
if SHORTCUT_CST in n.name:
convID = SHORTCUT_CST
allDict[blockID][unitID][convID] = weights
return allDict
def _run_tf_optimizer(config: ConfigProto, graph: tf.Graph,
signature_def: SignatureDef) -> GraphDef:
"""Run the TF optimizer ("grappler") on a graph"""
graph_def = graph.as_graph_def()
meta_graph = export_meta_graph(graph_def=graph_def, graph=graph)
meta_graph.signature_def['not_used_key'].CopyFrom(signature_def)
return tf_optimizer.OptimizeGraph(config, meta_graph)
def get_1st_feature_extractor_bn(detection_graph: tf.Graph,
sess: tf.Session) -> dict:
bnDict = {}
allDict = {}
prevName = ""
currentBlockID = 0
currentUnitID = 0
currentConvID = 0
shortcut = False
c2 = 0
convNum = 1
for i, n in enumerate(detection_graph.as_graph_def().node):
if BN_CST in n.name:
if (CONV_CST in n.name.lower() or SHORTCUT_CST in n.name):
if n.name.endswith(BETA_CST):
bnDict[n.name] = getWeightsByName(detection_graph, n.name,
sess)
elif n.name.endswith(GAMMA_CST):
bnDict[n.name] = getWeightsByName(detection_graph, n.name,
sess)
elif n.name.endswith(MOVING_MEAN_CST):
bnDict[n.name] = getWeightsByName(detection_graph, n.name,
sess)
elif n.name.endswith(MOVING_VAR_CST):
bnDict[n.name] = getWeightsByName(detection_graph, n.name,
sess)
for k, v in bnDict.items():
blockFind = k.find(BLOCK_CST)
if k.endswith(BETA_CST):
key = BETA_CST
elif k.endswith(GAMMA_CST):
key = GAMMA_CST
elif k.endswith(MOVING_MEAN_CST):
key = MOVING_MEAN_CST
elif k.endswith(MOVING_VAR_CST):
key = MOVING_VAR_CST
if blockFind == -1:
if not CONV_CST + str(convNum) in allDict:
allDict[CONV_CST + str(convNum)] = {}
allDict[CONV_CST + str(convNum)][key] = v
else:
blockID, unitID, convID = getBUC(k)
if blockID != currentBlockID:
allDict[blockID] = {}
currentBlockID = blockID
currentUnitID = 0
if unitID != currentUnitID:
allDict[blockID][unitID] = {}
currentUnitID = unitID
if SHORTCUT_CST in k:
convID = SHORTCUT_CST
if not convID in allDict[blockID][unitID]:
allDict[blockID][unitID][convID] = {}
allDict[blockID][unitID][convID][key] = v
return allDict
def get_by_name(graph: tf.Graph, name: str):
"""Return op in Graph with name or None if not found.
Parameters
----------
graph : tf.Graph
A Tensorflow Graph
Returns
-------
tf.Operation or None
"""
for node in graph.as_graph_def().node:
if node.name == name:
return graph.as_graph_element(node.name)
return None
def _process_graph(graph: tf.Graph) -> List[str]:
"""
Gets the list of the output nodes present in the graph for inference
:return: list of node names
"""
all_nodes = [x.name for x in graph.as_graph_def().node]
print("############")
print(all_nodes)
nodes = [x for x in all_nodes if x in POSSIBLE_OUTPUT_NODES | MODEL_CONSTANTS]
print("List of nodes to export for brain TODO(oleguer put name here)")
print("############")
print(nodes)
print("############")
for n in nodes:
print("\t" + n)
return nodes
def get_all_graph_nodes_names(graph: tf.Graph) -> List[str]:
return [n.name for n in graph.as_graph_def().node]
def getComputationalCostInFlops(graph: tf.Graph,
keywords: List[Union[str, List]] = None,
exclude_keywords: bool = True) -> int:
"""Calculate the number of flops required to run the graph, while excluding any nodes that contain the supplied
keywords.
Parameters
----------
graph : tf.Graph
Tensorflow graph object to analyze.
keywords : list(str or list)
Select the nodes containing the specified keywords in the node names. An individual "keyword" item can be either a
string, or a list of strings. When a list of strings is supplied as a keyword, the node is selected using a
logical and operator, i.e., all the strings must be present in the node name. When `exclude_keywords` is
set to `True`, the total flops returned excludes the flops used for the specified nodes.
When `exclude_keywords` is set to `False`, the return value only contains the total flops used for the
specified keywords. Default value of `None` returns the total flops for the entire computational graph.
exclude_keywords : bool
Whether to exclude (or include only) the specified keywords from the total flops counted.
Returns
-------
flops : int
Total number of flops required for one pass through the graph.
Notes
-----
Calculates the flops using the estimates from `sopt.benchmarks.ops.tensorflow.flops_registry_custom`. The
estimates used might not include all the operations used in the supplied graph.
I went carefully through the nodes for the simple case of ePIE reconstruction, where I found that this function
did actually correctly include all the relevant nodes.
"""
from tensorflow.python.framework import graph_util
import sopt.benchmarks.ops.tensorflow.flops_registry_custom
from sopt.benchmarks.ops.tensorflow.graph_utils_custom import get_flops_for_node_list
with graph.as_default():
run_meta = tf.RunMetadata()
opts = tf.profiler.ProfileOptionBuilder.float_operation()
profile = tf.profiler.profile(run_meta=run_meta,
cmd="scope",
options=opts)
flops_all_ops = profile.total_float_ops
graph_def = graph.as_graph_def()
if keywords is None:
return flops_all_ops
keywords_flops = 0
def _checkWordListInName(word_or_list, name):
if isinstance(word_or_list, str):
return word_or_list in name
for word in word_or_list:
if not word in name:
return False
return True
for word_or_list in keywords:
keywords_nodes = [
node for node in graph_def.node
if _checkWordListInName(word_or_list, node.name)
]
flops = get_flops_for_node_list(graph, keywords_nodes)
keywords_flops += flops
return_flops = flops_all_ops - keywords_flops if exclude_keywords else keywords_flops
return return_flops