def _run_function_for_calibration_graph_mode(
sess: session.Session, signature_def: meta_graph_pb2.SignatureDef,
representative_dataset: repr_dataset.RepresentativeDataset) -> None:
"""Runs the representative dataset through a function for calibration.
NOTE: This is intended to be run in graph mode (TF1).
The function is identified by the SignatureDef.
Args:
sess: The Session object to run the function in.
signature_def: A SignatureDef that identifies a function by specifying the
inputs and outputs.
representative_dataset: The representative dataset to run through the
function.
"""
output_tensor_names = [
output_tensor_info.name
for output_tensor_info in signature_def.outputs.values()
]
sample_validator = _create_sample_validator(
expected_input_keys=signature_def.inputs.keys())
for sample in map(sample_validator, representative_dataset):
# Create a mapping from input tensor name to the input tensor value.
# ex) "Placeholder:0" -> [0, 1, 2]
feed_dict = _create_feed_dict_from_input_data(sample, signature_def)
sess.run(output_tensor_names, feed_dict=feed_dict)
def create_resource_split_graph(
sess: Session,
input_value: Any,
input_dtype: Any,
num_outputs: int,
num_splits: List[int],
paddings: Optional[List[int]] = None) -> List[Tensor]:
variable = resource_variable_ops.ResourceVariable(
initial_value=input_value, dtype=input_dtype)
sess.run(variables.variables_initializer([variable]))
return gen_tpu_ops.read_variable_xla_split_nd(variable.handle,
input_dtype,
num_outputs,
num_splits,
paddings=paddings)
def copy_variable_to_graph(org_instance, to_graph, scope=''):
"""Given a `Variable` instance from one `Graph`, initializes and returns
a copy of it from another `Graph`, under the specified scope
(default `""`).
Args:
org_instance: A `Variable` from some `Graph`.
to_graph: The `Graph` to copy the `Variable` to.
scope: A scope for the new `Variable` (default `""`).
Returns:
The copied `Variable` from `to_graph`.
Raises:
TypeError: If `org_instance` is not a `Variable`.
"""
if not isinstance(org_instance, Variable):
raise TypeError(str(org_instance) + ' is not a Variable')
#The name of the new variable
if scope != '':
new_name = (scope + '/' + org_instance.name[:org_instance.name.index(':')])
else:
new_name = org_instance.name[:org_instance.name.index(':')]
#Get the collections that the new instance needs to be added to.
#The new collections will also be a part of the given scope,
#except the special ones required for variable initialization and
#training.
collections = []
for name, collection in org_instance.graph._collections.items():
if org_instance in collection:
if (name == ops.GraphKeys.GLOBAL_VARIABLES or
name == ops.GraphKeys.TRAINABLE_VARIABLES or scope == ''):
collections.append(name)
else:
collections.append(scope + '/' + name)
#See if it's trainable.
trainable = (
org_instance in org_instance.graph.get_collection(
ops.GraphKeys.TRAINABLE_VARIABLES))
#Get the initial value
with org_instance.graph.as_default():
temp_session = Session()
init_value = temp_session.run(org_instance.initialized_value())
#Initialize the new variable
with to_graph.as_default():
new_var = Variable(
init_value,
trainable,
name=new_name,
collections=collections,
validate_shape=False)
return new_var
def copy_variable_to_graph(org_instance, to_graph, scope=""):
"""Given a `Variable` instance from one `Graph`, initializes and returns
a copy of it from another `Graph`, under the specified scope
(default `""`).
Args:
org_instance: A `Variable` from some `Graph`.
to_graph: The `Graph` to copy the `Variable` to.
scope: A scope for the new `Variable` (default `""`).
Returns:
The copied `Variable` from `to_graph`.
Raises:
TypeError: If `org_instance` is not a `Variable`.
"""
if not isinstance(org_instance, Variable):
raise TypeError(str(org_instance) + " is not a Variable")
#The name of the new variable
if scope != "":
new_name = (scope + '/' +
org_instance.name[:org_instance.name.index(':')])
else:
new_name = org_instance.name[:org_instance.name.index(':')]
#Get the collections that the new instance needs to be added to.
#The new collections will also be a part of the given scope,
#except the special ones required for variable initialization and
#training.
collections = []
for name, collection in org_instance.graph._collections.items():
if org_instance in collection:
if (name == ops.GraphKeys.VARIABLES
or name == ops.GraphKeys.TRAINABLE_VARIABLES
or scope == ''):
collections.append(name)
else:
collections.append(scope + '/' + name)
#See if its trainable.
trainable = (org_instance in org_instance.graph.get_collection(
ops.GraphKeys.TRAINABLE_VARIABLES))
#Get the initial value
with org_instance.graph.as_default():
temp_session = Session()
init_value = temp_session.run(org_instance.initialized_value())
#Initialize the new variable
with to_graph.as_default():
new_var = Variable(init_value,
trainable,
name=new_name,
collections=collections,
validate_shape=False)
return new_var
def create_resource_roundtrip_graph(
sess: Session,
value: Any,
dtype: Any,
num_partitions: List[int],
paddings: Optional[List[int]] = None) -> Tensor:
variable = resource_variable_ops.ResourceVariable(initial_value=value,
dtype=dtype)
sess.run(variables.variables_initializer([variable]))
split = gen_tpu_ops.read_variable_xla_split_nd(variable.handle,
dtype,
np.prod(num_partitions),
num_partitions,
paddings=paddings)
concat = gen_tpu_ops.assign_variable_xla_concat_nd(variable.handle, split,
num_partitions,
paddings)
with control_dependencies([concat]):
return math_ops.equal(variable.read_value(),
constant_op.constant(value, dtype=dtype))
def create_resource_concat_graph(
sess: Session,
input_values: List[Any],
input_dtype: Any,
num_concats: List[int],
paddings: Optional[List[int]] = None,
output_shape: Optional[List[int]] = None) -> Tensor:
variable_shape = [] if output_shape is None else output_shape
variable = resource_variable_ops.ResourceVariable(initial_value=np.zeros(
variable_shape, dtype=input_dtype),
dtype=input_dtype)
sess.run(variables.variables_initializer([variable]))
const_input_ops = [
constant_op.constant(i, dtype=input_dtype) for i in input_values
]
concat = gen_tpu_ops.assign_variable_xla_concat_nd(variable.handle,
const_input_ops,
num_concats, paddings)
with control_dependencies([concat]):
return variable.read_value()
class DetectionApiNmsPerformer(NmsPerformerBase):
def __init__(self):
self.sess = None
self.config = ConfigProto()
self.config.gpu_options.allow_growth = True
def create_session(self):
"""
create tensorflow session
"""
self.sess = Session(config=self.config)
def nms_single_class(self, boxes, scores, input_metadata):
""" see NmsPerformerBase """
# define nms function params
# This is not supposed to be in the request! we insert a default value for safety.
score_thresh = SCORE_THRESH
iou_thresh = input_metadata.get('nmsThresh', 0.6)
max_output_size = boxes.shape[0]
# expand to adapt to expected input dimensions
boxes = boxes[:, np.newaxis, :]
scores = scores[:, np.newaxis]
# convert to tensors
boxes = tf.constant(boxes, tf.float32)
scores = tf.constant(scores, tf.float32)
# create nms graph node
nms_node = multiclass_non_max_suppression(boxes, scores, score_thresh,
iou_thresh, max_output_size)
# run nms evaluation
self.sess.run(nms_node.get())
nms_boxes = nms_node.data['boxes'].eval(session=self.sess)
nms_scores = nms_node.data['scores'].eval(session=self.sess)
return nms_boxes, nms_scores
class DeepLabModel(object):
"""Class to load deeplab model and run inference."""
INPUT_TENSOR_NAME = 'ImageTensor:0'
OUTPUT_TENSOR_NAME = 'SemanticPredictions:0'
INPUT_SIZE = 513
FROZEN_GRAPH_NAME = 'frozen_inference_graph'
def __init__(self, tarball_path):
# """Creates and loads pretrained deeplab model."""
self.graph = tf.Graph()
graph_def = None
# Extract frozen graph from tar archive.
tar_file = tarfile.open(tarball_path)
for tar_info in tar_file.getmembers():
if self.FROZEN_GRAPH_NAME in os.path.basename(tar_info.name):
file_handle = tar_file.extractfile(tar_info)
graph_def = GraphDef.FromString(file_handle.read())
break
tar_file.close()
if graph_def is None:
raise RuntimeError('Cannot find inference graph in tar archive.')
with self.graph.as_default():
tf.import_graph_def(graph_def, name = '')
self.sess = Session(graph = self.graph)
def run(self, image):
"""Runs inference on a single image.
Args:
image: A PIL.Image object, raw input image.
Returns:
resized_image: RGB image resized from original input image.
seg_map: Segmentation map of `resized_image`.
"""
width, height = image.size
resize_ratio = 1.0 * self.INPUT_SIZE / max(width, height)
target_size = (int(resize_ratio * width), int(resize_ratio * height))
resized_image = image.convert('RGB').resize(target_size, Image.ANTIALIAS)
batch_seg_map = self.sess.run(
self.OUTPUT_TENSOR_NAME,
feed_dict = {self.INPUT_TENSOR_NAME: [np.asarray(resized_image)]})
seg_map = batch_seg_map[0]
return resized_image, seg_map
def end(self, session: session_lib.Session):
if self._save_thread:
logging.info("Waiting for any pending checkpoints to finish.")
self._save_thread.join()
if self._write_graph_thread:
logging.info("Waiting for any pending write_graph to finish.")
self._write_graph_thread.join()
last_step = session.run(self._global_step_tensor)
if self._last_checkpoint_step != last_step:
self._save(session, last_step, asynchronous=False)
for l in self._listeners:
l.end(session, last_step)
def test_hash(hash_func):
# random_str = generate_random_ascii_str()
random_str = []
with open(RANDOM_STRING_FILE, 'rb') as f:
for line in f:
random_str.append(line.strip())
nums = len(random_str)
num_batches = int(nums / BATCH_SIZE)
# result = hash_method(input=random_str, num_buckets=HASH_SIZE, name="test_hash")
print("Num of random string is {}".format(len(random_str)))
print("Hash size is {}".format(HASH_SIZE))
print("HASH_SIZE / NUMS_RANDOM_STR is {}".format(HASH_SIZE / nums))
x_input_str = placeholder(dtype=tf_string,
shape=[
None,
],
name='input_str')
result = hash_func(input=x_input_str,
num_buckets=HASH_SIZE,
name="test_hash")
RESULT = []
sess = Session()
t0 = time.time()
for i in xrange(num_batches):
if i != num_batches - 1:
batch_i = random_str[i * BATCH_SIZE:(i + 1) * BATCH_SIZE]
else:
batch_i = random_str[i * BATCH_SIZE:]
result_i = sess.run(result, feed_dict={x_input_str: batch_i})
RESULT += result_i.tolist()
cost_t = time.time() - t0
conflict_nums = len(RESULT) - len(set(RESULT))
print("Calculate time is {}s".format(cost_t))
print("Conflict nums is {}".format(conflict_nums))
print("Conflict rate is {}".format(conflict_nums / len(RESULT)))
sess.close()
def after_create_session(self, session: session_lib.Session, coord: Any):
global_step = session.run(self._global_step_tensor)
# We do write graph and saver_def at the first call of before_run.
# We cannot do this in begin, since we let other hooks to change graph and
# add variables in begin. Graph is finalized after all begin calls.
def _write_graph_fn(self):
training_util.write_graph(
ops.get_default_graph().as_graph_def(add_shapes=True),
self._checkpoint_dir, "graph.pbtxt")
self._write_graph_thread = threading.Thread(target=_write_graph_fn,
args=[self])
self._write_graph_thread.start()
saver_def = self._get_saver().saver_def if self._get_saver() else None
graph = ops.get_default_graph()
meta_graph_def = meta_graph.create_meta_graph_def(
graph_def=graph.as_graph_def(add_shapes=True), saver_def=saver_def)
self._summary_writer.add_graph(graph)
self._summary_writer.add_meta_graph(meta_graph_def)
# The checkpoint saved here is the state at step "global_step".
self._save(session, global_step)
self._timer.update_last_triggered_step(global_step)
