def _tensors(detection_graph: tf.Graph) -> tuple:
# Input tensor is the image
image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')
# Output tensors are the detection boxes, scores, and classes
# Each box represents a part of the image where a particular object was detected
detection_boxes = detection_graph.get_tensor_by_name('detection_boxes:0')
# Each score represents level of confidence for each of the objects.
# The score is shown on the result image, together with the class label.
detection_scores = detection_graph.get_tensor_by_name('detection_scores:0')
detection_classes = detection_graph.get_tensor_by_name('detection_classes:0')
# Number of objects detected
num_detections = detection_graph.get_tensor_by_name('num_detections:0')
return image_tensor, detection_boxes, detection_scores, detection_classes, num_detections
def from_dict(graph: tf.Graph, dictionary: dict) -> 'EvaluationSpec':
# Metric ops
eval_metric_ops = {
key:
(graph.get_tensor_by_name(tensor), graph.get_tensor_by_name(op))
for key, (tensor, op) in dictionary['metric_ops'].items()
}
# Loss
loss = graph.get_tensor_by_name(dictionary['loss'])
return EvaluationSpec(loss=loss, eval_metric_ops=eval_metric_ops)
def _set_signature_dtypes(
graph: tf.Graph, signature_def: util.SignatureDef
) -> Tuple[tf.Graph, util.SignatureDef]:
"""Set the dtype of each input and output to match the graph and return
both
"""
for key, value in signature_def.inputs.items():
node = graph.get_tensor_by_name(value.name)
value.dtype = node.dtype.as_datatype_enum
for key, value in signature_def.outputs.items():
node = graph.get_tensor_by_name(value.name)
value.dtype = node.dtype.as_datatype_enum
return graph, signature_def
class TensoflowFaceDector(object):
def __init__(self, PATH_TO_CKPT):
"""Tensorflow detector
"""
self.detection_graph = Graph()
with self.detection_graph.as_default():
od_graph_def = compat.v1.GraphDef()
with io.gfile.GFile(PATH_TO_CKPT, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
import_graph_def(od_graph_def, name='')
with self.detection_graph.as_default():
config = compat.v1.ConfigProto()
config.gpu_options.allow_growth = True
self.sess = compat.v1.Session(graph=self.detection_graph, config=config)
self.windowNotSet = True
def run(self, image):
"""image: bgr image
return (boxes, scores, classes, num_detections)
"""
image_np = cvtColor(image, COLOR_BGR2RGB)
# the array based representation of the image will be used later in order to prepare the
# result image with boxes and labels on it.
# Expand dimensions since the model expects images to have shape: [1, None, None, 3]
image_np_expanded = expand_dims(image_np, axis=0)
image_tensor = self.detection_graph.get_tensor_by_name('image_tensor:0')
# Each box represents a part of the image where a particular object was detected.
boxes = self.detection_graph.get_tensor_by_name('detection_boxes:0')
# Each score represent how level of confidence for each of the objects.
# Score is shown on the result image, together with the class label.
scores = self.detection_graph.get_tensor_by_name('detection_scores:0')
classes = self.detection_graph.get_tensor_by_name('detection_classes:0')
num_detections = self.detection_graph.get_tensor_by_name('num_detections:0')
# Actual detection.
start_time = time()
(boxes, scores, classes, num_detections) = self.sess.run(
[boxes, scores, classes, num_detections],
feed_dict={image_tensor: image_np_expanded})
elapsed_time = time() - start_time
print('inference time cost: {}'.format(elapsed_time))
return (boxes, scores, classes, num_detections)
def generate_feed_dict(graph: tf.Graph, node: Node):
"""
The first value in the return tuple is True if all inputs for the node has constant values.
The second returned value is mapping of placeholder tensor to the numpy arrays with the values for these
placeholders.
:param graph: the TensorFlow Graph to generate feed dictionary to.
:param node: the node which represents TensorFlow sub-graph of operations.
:return: pair where the first element is a flag that specifies that all node inputs are constants and a dictionary
where key is the input Tensor object and the value is the tensor value.
"""
all_constants = True
feed_dict = dict()
for in_data_node_name, edge_attrs in get_inputs(node.graph, node.id):
if 'control_flow_edge' in edge_attrs and edge_attrs[
'control_flow_edge']:
continue
value = node.in_node(edge_attrs['in']).value
if value is None:
all_constants = False
placeholder_pb = node['pbs'][edge_attrs['placeholder_name']]
value = np.ones(
shape=tf_tensor_shape(placeholder_pb.attr['shape'].shape),
dtype=tf_dtype_extractor(placeholder_pb.attr['dtype'].type))
feed_dict[graph.get_tensor_by_name(edge_attrs['placeholder_name'] +
":0")] = value
return all_constants, feed_dict
def _get_tensor_by_parameter_name(graph: tf.Graph,
parameter_name: str) -> tf.Tensor:
nucleotide_var_scopes_with_parameters = [
ScopeNames.MODEL,
ScopeNames.POSTPROCESSING,
]
nucleotide_var_scope = parameter_name.split("//", maxsplit=1)[0]
tensor_name = ":".join([parameter_name, "0"])
tensor = None
for each_var_scope in nucleotide_var_scopes_with_parameters:
tensor_name_with_var_scope = "/".join(
[each_var_scope, nucleotide_var_scope, tensor_name])
try:
tensor = graph.get_tensor_by_name(tensor_name_with_var_scope)
break
except KeyError:
continue
if tensor is None:
raise ValueError("Model parameter with name {} does not exist!".format(
parameter_name))
if tensor.op.type != 'PlaceholderWithDefault':
msg = ("Model parameter tensor operation should be of type "
"PlaceholderWithDefault! (found {})").format(tensor.op.type)
raise ValueError(msg)
return tensor
def input_to_feed_dict(graph: tf.Graph, input_data: Union[dict, xr.Dataset]) \
-> Dict[Union[Union[tf.Tensor, tf.Operation], Any], Any]:
"""
Converts some input data to a feedable dict for Tensorflow sessions based on the placeholders in a tf.Graph
:param graph: tf.Graph object
:param input_data: either xr.Dataset or some dict{"placeholder": data}
:return: dict{"placeholder:0", data} for all placeholder names in `input_data`
"""
placeholders = {
op.name: op
for op in graph.get_operations()
if op.type.lower().startswith("placeholder")
}
if isinstance(input_data, xr.Dataset):
keys = input_data.variables.keys()
else:
keys = input_data.keys()
keys = set(keys).intersection(placeholders.keys())
retval = {}
for k in keys:
retval[graph.get_tensor_by_name(k + ":0")] = input_data[k]
return retval
def _get_transformed_tensor(src_tensor: tf.Tensor,
dst_graph: tf.Graph,
dst_scope: str = '') -> tf.Tensor:
dst_tensor_name = src_tensor.name
if dst_scope:
dst_tensor_name = f'{dst_scope}/{dst_tensor_name}'
return dst_graph.get_tensor_by_name(dst_tensor_name)
def get_loss_tensor(self, graph: tf.Graph) -> tf.Tensor:
"""
Note: if you give your loss component a different name, you must overwrite this method.
:param graph:
:return:
"""
return graph.get_tensor_by_name('{}:0'.format(_Labels.LOSS_LABEL))
def _build_tensor_info(graph: tf.Graph, info: NodeInfo) -> TensorInfo:
if info is not None:
tensor = graph.get_tensor_by_name(info.tensor)
return TensorInfo(dtype=tf.dtypes.as_dtype(
tensor.dtype).as_datatype_enum,
tensor_shape=tf.TensorShape(tensor.shape).as_proto(),
name=info.tensor)
else:
return None
def create_tensor_dict(detection_graph: tensorflow.Graph) -> dict:
tensor_dict = {}
with tensorflow.compat.v1.Session(graph=detection_graph):
ops = detection_graph.get_operations()
all_tensor_names = {output.name for op in ops for output in op.outputs}
for key in ['num_detections', 'detection_boxes', 'detection_scores', 'detection_classes']:
tensor_name = key + ':0'
if tensor_name in all_tensor_names:
tensor_dict[key] = detection_graph.get_tensor_by_name(tensor_name)
return tensor_dict
def label_image(detection_graph: tensorflow.Graph, tensor_dict: dict, image_np: numpy.ndarray) -> dict:
with tensorflow.compat.v1.Session(graph=detection_graph) as sess:
image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')
image_np_expanded = numpy.expand_dims(image_np, axis=0)
output_dict = sess.run(tensor_dict, feed_dict={image_tensor: image_np_expanded})
output_dict['num_detections'] = int(output_dict['num_detections'][0])
output_dict['detection_classes'] = output_dict['detection_classes'][0].astype(numpy.int64)
output_dict['detection_boxes'] = output_dict['detection_boxes'][0]
output_dict['detection_scores'] = output_dict['detection_scores'][0]
return output_dict
def get_io_tensor_by_node_name(graph: tf.Graph, input_nodes, output_nodes,
input_indices=None, output_indices=None):
"""
Get graph input and output tensors by their corresponding operation names
Args:
graph: A tf.Graph object.
input_nodes: A list of the names of all the input nodes.
output_nodes: A list of the names of all the output nodes.
input_indices: A list of integers with the length same as input_nodes,
specifying which tensor should be returned from the outputs of an
operation. Defaults to None, which converts to a list of zeroes.
e.g. If input_nodes = ['node_a', 'node_b']
input_indices = [0, 1]
Then ['node_a:0', 'node_b:1'] will be the tensors searched.
output_indices: A list of integers with the length same as output_nodes.
Returns:
Two lists of tf.Tensor objects, corresponding to inputs and outputs.
"""
input_tensors = []
output_tensors = []
if not input_indices:
input_indices = [0] * len(input_nodes)
if not output_indices:
output_indices = [0] * len(output_nodes)
assert len(input_nodes) == len(input_indices)
assert len(output_nodes) == len(output_indices)
for node, index in zip(input_nodes, input_indices):
tensor_name = node_to_tensor(node, index)
try:
input_tensors.append(graph.get_tensor_by_name(tensor_name))
except KeyError as e:
print(e)
for node, index in zip(output_nodes, output_indices):
tensor_name = node_to_tensor(node, index)
try:
output_tensors.append(graph.get_tensor_by_name(tensor_name))
except KeyError as e:
print(e)
return input_tensors, output_tensors
def _parse_graph_info(graph_def):
"""Parse GraphDef
Fetch input tensors and output tensors name for reconstructing
graph in uTensor Context object
Argument
========
- graph_def <tf.GraphDef>: a GraphDef object
Return
======
- graph_nodes <defaultdict>: a dict with key as operation name and
value as a defaultdict with keys 'input_tensor' and 'output_tensor'
which maps to a set of input/output tensor names respectively
Note
====
- thought the output tensor names is irrelevent for TensorFlow, but it
is neccessary for uTensor
"""
OperationInfo = namedtuple('OperationInfo',
field_names=[
'input_tensor', 'output_tensor', 'op_type',
'output_content', 'op_attr'
])
graph = Graph()
with graph.as_default(): # pylint: disable=E1129
import_graph_def(graph_def, name="")
graph_info = {}
with Session(graph=graph):
for node in graph_def.node:
op = graph.get_operation_by_name(node.name)
input_tensor = [(t.name, t.dtype, _parse_shape(t.shape))
for t in op.inputs]
output_tensor = [(t.name, t.dtype, _parse_shape(t.shape))
for t in op.outputs]
op_type = node.op
output_content = {}
op_attr = node.attr
if node.op in ["Const"]:
for tensor_name, _, _ in output_tensor:
tensor = graph.get_tensor_by_name(tensor_name)
output_content[tensor_name] = tensor.eval()
graph_info[node.name] = OperationInfo(input_tensor, output_tensor,
op_type, output_content,
op_attr)
return graph_info
def create_input_feed_dict(graph: tf.Graph,
input_op_names_list: List,
input_data: Union[np.ndarray, List, Tuple],
training=False) -> Dict:
"""
Creates feed dictionary [op_name] = data for session.run
:param graph: tf.Graph
:param input_op_names_list: list of input op names
:param input_data: either single numpy array, list or tuple of numpy array
:param training: True if graph is in training mode, false otherwise
:return: feed_dict
"""
feed_dict = {}
# single input
if isinstance(input_data, np.ndarray):
input_data_list = [input_data]
# list of multiple inputs
elif isinstance(input_data, list):
input_data_list = input_data
# tuple of multiple inputs
elif isinstance(input_data, tuple):
input_data_list = list(input_data)
else:
raise ValueError(
'Session run return value should be either numpy array, list or tuple'
)
if not len(input_op_names_list) == len(input_data_list):
raise ValueError(
'There is mismatch between number of input op names and input data!'
)
for inp_op_name, inp_data in zip(input_op_names_list, input_data_list):
inp_tensor = graph.get_tensor_by_name(inp_op_name + ':0')
feed_dict[inp_tensor] = inp_data
# Identify and set all training tensors to True or False depending on training parameter
for training_tensor in get_training_tensors(graph):
feed_dict[training_tensor] = training
return feed_dict
def tensor_dependency(graph: tf.Graph, name: str, ops: List[str],
dtypes: List[str]):
"""
Given a Tensorflow graph, a tensor name in the graph, and list of ops and dtypes to prune, return if this
tensor depends on any of the given ops and dtypes.
Recursive search over the graph starting from this tensor to determine dependency on any of the ops or dtypes.
"""
tensor = graph.get_tensor_by_name(name)
# check if this tensor depends on any of the listed dtypes, or if the op that created it is in the list of ops
if tensor.dtype.name.lower() in dtypes or tensor.op.type.lower() in ops:
return True
# if this tensor's op has inputs, traverse the graph to see if it depends on any of the dtypes or ops
for op_input in tensor.op.inputs:
if tensor_dependency(graph, op_input.name, ops, dtypes):
return True
# otherwise return false, it doesn't depend on any of the listed ops or dtypes :)
return False
def _parse_graph_nodes(graph_def: GraphDef) -> defaultdict:
"""Parse GraphDef
Fetch input tensors and output tensors name for reconstructing
graph in uTensor Context object
Argument
========
- graph_def <tf.GraphDef>: a GraphDef object
Return
======
- graph_nodes <defaultdict>: a dict with key as operation name and
value as a defaultdict with keys 'input_tensor' and 'output_tensor'
which maps to a set of input/output tensor names respectively
Note
====
- thought the output tensor names is irrelevent for TensorFlow, but it
is neccessary for uTensor
"""
graph = Graph()
with graph.as_default(): # pylint: disable=E1129
import_graph_def(graph_def, name="")
graph_info = defaultdict(lambda: {"output_content": {}})
with Session(graph=graph):
for node in graph_def.node:
op = graph.get_operation_by_name(node.name)
op_info = graph_info[node.name]
op_info["input_tensor"] = [(t.name, t.dtype, _parse_shape(t.shape))
for t in op.inputs]
op_info["output_tensor"] = [
(t.name, t.dtype, _parse_shape(t.shape)) for t in op.outputs
]
op_info["op_type"] = node.op
if node.op in ["Const"]:
for out_tensor, _, _ in op_info["output_tensor"]:
tensor = graph.get_tensor_by_name(out_tensor)
op_info["output_content"][tensor.name] = tensor.eval()
return graph_info
def from_dict(graph: tf.Graph, dictionary: dict) -> 'TrainSpec':
return TrainSpec(loss=graph.get_tensor_by_name(dictionary['loss']),
train_op=graph.get_operation_by_name(
dictionary['train_op']),
create_viz_op=False)
def from_dict(graph: tf.Graph, dictionary: dict) -> 'PredictSpec':
return PredictSpec(
output={
key: graph.get_tensor_by_name(tensor)
for key, tensor in dictionary.items()
})
def attach(self, tf_graph: tf.Graph) -> 'MatrixInitializer':
return MatrixInitializer(
self.__param_name, tf_graph.get_tensor_by_name(self.__indices),
tf_graph.get_tensor_by_name(self.__values),
tf_graph.get_tensor_by_name(self.__update_op))
def getTensor(graph: tf.Graph, tensor_name: str) -> tf.Tensor:
t = graph.get_tensor_by_name(tensor_name + ":0")
return t
count_file = sys.argv[4]
except IndexError:
count_file = None
#create new session
graph = Graph()
sess = Session(graph=graph)
#restore model
saved_model.loader.load(sess, [saved_model.tag_constants.SERVING], model_dir)
#get restored model ops and tensors
model_info = joblib.load(osp.join(model_dir, 'model_info.pkl'))
model = dict()
model.update(
{k: graph.get_tensor_by_name(v)
for k, v in model_info['inputs'].items()})
model.update(
{k: graph.get_tensor_by_name(v)
for k, v in model_info['outputs'].items()})
#inputs
inp = model["obs"]
#outputs
pi = model["pi"]
val = model["val"]
logp_pi = model["logp_pi"]
out = [pi, val, logp_pi]
if count_file:
def predict_images(detection_graph: tf.Graph, image_path: str, output_path: str, output_csv_path: str,
threshold: float = 0.3, save_csv: bool = True) -> Tuple[np.ndarray]:
"""Predict detection on image
Args:
detection_graph (tf.Graph): Graph of model to detect
image_path (str): path to image
output_path (str): output folder to write detected images to
output_csv_path (str): output folder to write csv of detections to
threshold (float, optional): detection threshold. Defaults to 0.3.
save_csv (bool, optional): whether csv files of detection should be saved. Defaults to True.
Returns:
Tuple[np.ndarray]: tuple of np arrays (all_boxes, all_scores, all_classes, all_num_detections)
"""
data = pd.DataFrame(columns=[
'filename', 'width', 'height', 'class', 'score', 'xmin', 'ymin', 'xmax', 'ymax'])
all_boxes, all_scores, all_classes, all_num_detections = [], [], [], []
with detection_graph.as_default():
with tf.Session(graph=detection_graph) as sess:
for img in sorted(glob.glob(image_path)):
image_np, orig_w, orig_h = image_load_encode(img)
# Expand dimensions since the model expects images to have shape: [1, None, None, 3]
image_np_expanded = np.expand_dims(image_np, axis=0)
#print('Image expanded: ', image_np.shape, image_np_expanded.shape)
image_tensor = detection_graph.get_tensor_by_name(
'image_tensor:0')
# Each box represents a part of the image where a particular object was detected.
boxes = detection_graph.get_tensor_by_name('detection_boxes:0')
# Each score represent how level of confidence for each of the objects.
# Score is shown on the result image, together with the class label.
scores = detection_graph.get_tensor_by_name(
'detection_scores:0')
classes = detection_graph.get_tensor_by_name(
'detection_classes:0')
num_detections = detection_graph.get_tensor_by_name(
'num_detections:0')
# Actual detection.
(boxes, scores, classes, num_detections) = sess.run(
[boxes, scores, classes, num_detections],
feed_dict={image_tensor: image_np_expanded})
#print('Boxes: ', boxes, 'scores', scores, 'classes', classes, 'num dets', num_detections)
if save_csv:
all_boxes.append(boxes)
all_scores.append(scores)
all_classes.append(classes)
all_num_detections.append(num_detections)
boxes = boxes[0] * np.array([[512, 512, 512, 512]])
scores = scores[0]
classes = classes[0]
num_detections = int(num_detections[0])
# convert boxes to xmin, ymin, xmax, ymax. Currently it is ymin, xmin, ymax, xmax
boxes = boxes[:, [1, 0, 3, 2]]
# find out where scores are greater than at threshold and change everything according to that
thresh_indices = np.where(scores >= threshold)[0]
boxes = boxes[thresh_indices]
scores = scores[thresh_indices]
classes = classes[thresh_indices]
boxes, scores = postprocess(boxes, scores, theta=args.theta)
# Visualization of the results of a detection, but only if output_path is provided
if output_path is not None:
image_np = draw_boxes(
image_np, boxes, scores, disable_thresh=True)
orig_name = img.split('/')[-1].split('\\')[-1]
img_output_path = os.path.join(output_path, orig_name)
cv2.imwrite(img_output_path, image_np)
# always saving data to dataframe
if save_csv:
_ = write_to_df(data, img, orig_w, orig_h, output_csv_path,
'spine', boxes, scores, disable_thresh=True)
print('[INFO] Finished detection of image '+img+'.')
return all_boxes, all_scores, all_classes, all_num_detections
def get_variables_from_tf(graph: Graph, tf_graph: tf.Graph,
session: tf.Session) -> Dict[str, np.ndarray]:
return session.run({
name: tf_graph.get_tensor_by_name(name)
for name, _ in graph.variables.items()
})
def _get_tensors_by_name(graph: tf.Graph, names: List[str]) -> List[tf.Tensor]:
return [graph.get_tensor_by_name(f'{name}:0') for name in names]
def get_read_training(cls, graph: tf.Graph) -> tf.Tensor:
return graph.get_tensor_by_name('{}:0'.format(_Labels.READ_TRAINING_LABEL))
def get_global_step(cls, graph: tf.Graph) -> tf.Tensor:
return graph.get_tensor_by_name('{}:0'.format(_Labels.GLOBAL_STEP_LABEL))
