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 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 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 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 __init__(self, keras_model_path, inputshape, in_nodes, dest_nodes): if LooseVersion(tensorflow.__version__) < LooseVersion('1.8.0'): raise ImportError( 'Your TensorFlow version %s is outdated. ' 'MMdnn requires tensorflow>=1.8.0' % tensorflow.__version__) super(TensorflowParser2, self).__init__() self.weight_loaded = True import tensorflow as tf from tensorflow.python.framework.convert_to_constants import convert_variables_to_constants_v2 model = tf.keras.models.load_model(keras_model_path, compile=False) full_model = tf.function(lambda x: model(x)) full_model = full_model.get_concrete_function(tf.TensorSpec(model.inputs[0].shape, model.inputs[0].dtype)) frozen_func = convert_variables_to_constants_v2(full_model) frozen_func.graph.as_graph_def() g = frozen_func.graph from tensorflow.python.client.session import Session from tensorflow.python.training.saver import export_meta_graph with Session(graph = g) as sess: tempdir = tempfile.mkdtemp() meta_graph_def = export_meta_graph(filename=os.path.join(tempdir, 'my-model.meta')) model = meta_graph_def.graph_def shutil.rmtree((tempdir)) self.tf_graph = TensorflowGraph(model) self.tf_graph.build()
def config_tensorflow(): config = ConfigProto( gpu_options=GPUOptions(per_process_gpu_memory_fraction=0.8) ) config.gpu_options.allow_growth = True session = Session(config=config) set_session(session)
def test_run_cond_tf(self): true_fn = lambda: (constant(2),) false_fn = lambda: (constant(3),) with Session() as sess: out = multiple_dispatch.run_cond(constant(True), true_fn, false_fn) self.assertEqual(sess.run(out), 2) out = multiple_dispatch.run_cond(constant(False), true_fn, false_fn) self.assertEqual(sess.run(out), 3)
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()
def test_run_while_tf(self): cond_fn = lambda x, t, s: x > t body_fn = lambda x, t, s: (x * s, t, s) with Session() as sess: x, _, _ = multiple_dispatch.run_while(cond_fn, body_fn, [constant(3.0), 1.0, 0.5]) self.assertEqual(sess.run(x), 0.75) x, _, _ = multiple_dispatch.run_while(cond_fn, body_fn, [constant(3.0), 4.0, 0.5]) self.assertEqual(sess.run(x), 3.0)
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 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()
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
def test_dynamic_is_tf(self): with Session().as_default(): a = constant([2.0]) also_a = a not_actually_a = constant([2.0]) should_be_true1 = multiple_dispatch.dynamic_is(a, also_a) should_be_false1 = multiple_dispatch.dynamic_is_not(a, also_a) should_be_true2 = multiple_dispatch.dynamic_is_not(a, not_actually_a) should_be_false2 = multiple_dispatch.dynamic_is(a, not_actually_a) self.assertTrue(should_be_true1) self.assertTrue(should_be_true2) self.assertFalse(should_be_false1) self.assertFalse(should_be_false2)
def _default_session(): """ Returns the default session or a newly created session If no default session is available, creates a new session. Returns: ``Session``: returns the default session if available or a newly created session otherwise. """ session = ops.get_default_session() if session is None: session = Session() return session
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 prepare_session(self, master, checkpoint_dir=None, saver=None, config=None, **_): logger = get_logger() logger.info('prepare_session') session = Session(master, graph=self._graph, config=config) self._session_init_fn(session) if saver and checkpoint_dir: ckpt = get_checkpoint_state(checkpoint_dir) if ckpt and ckpt.model_checkpoint_path: # pylint: disable=no-member logger.info('restoring from %s', ckpt.model_checkpoint_path) # pylint: disable=no-member saver.restore(session, ckpt.model_checkpoint_path) # pylint: disable=no-member saver.recover_last_checkpoints( ckpt.all_model_checkpoint_paths) # pylint: disable=no-member else: logger.info('no valid checkpoint in %s', checkpoint_dir) return session
def test_list_append_tf(self): a = constant(3.0) l = tl.TensorList(a.shape, a.dtype) l.append(a) c1 = l.count() l.append(a) c2 = l.count() _ = l.pop() c3 = l.count() a2 = l.pop() c4 = l.count() with Session() as sess: c1, c2, c3, c4, a, a2 = self.evaluate([c1, c2, c3, c4, a, a2]) self.assertEqual(c1, 1) self.assertEqual(c2, 2) self.assertEqual(c3, 1) self.assertEqual(c4, 0) self.assertEqual(a, a2)
def train(self): learning_rate = self._learning_rate init_learning_rate = self._init_learning_rate logits, labels = self.model() print('labels: ', labels) print('logits: ', logits) equals = tf.cast(tf.equal(tf.argmax(labels, axis=1), tf.argmax(logits, axis=1)), dtype=tf.float32) accuracy = tf.reduce_mean(equals) loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(labels=labels, logits=logits)) optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate) train_op = optimizer.minimize(loss) with Session() as sess: import time sess.run(tf.global_variables_initializer()) tmp_learning_rate = init_learning_rate feed_dict = {self._is_training: True, self._batch_size:128} sess.run([self._train_init_op.initializer, self._test_init_op.initializer], feed_dict=feed_dict) start_time = time.time() for iteration in range(100000): if iteration % 25000 == 0 or iteration % 50000 == 0 or iteration % 75000 == 0: tmp_learning_rate *= 0.1 feed_dict = {self._is_training: True, learning_rate: tmp_learning_rate, self._batch_size: 128} _, loss_value = sess.run([train_op, loss], feed_dict=feed_dict) train_accuracy_value = sess.run([accuracy], feed_dict=feed_dict) if iteration % 1000 == 0: sess.run(self._test_init_op.initializer) feed_dict = {self._is_training: False, learning_rate: tmp_learning_rate, self._batch_size: 10000} test_accuracy_value = sess.run([accuracy], feed_dict=feed_dict) print('iteration: %d, learning rate: %f, loss: %f, train accuracy: %f, test accuracy: %f' % (iteration, tmp_learning_rate, loss_value, train_accuracy_value[0], test_accuracy_value[0])) print('total time: %d' % (time.time() - start_time))
def check_float_graph(input_graph_def, input_fn, q_config, s_config): """Check if float graph and input_fn is validate before quantization""" graph = ops.Graph() with graph.as_default(): importer.import_graph_def(input_graph_def, name='') print("INFO: Checking Float Graph...") input_tensors = [ op.outputs[0] for op in graph.get_operations() if op.type == 'Placeholder' ] output_tensors = [ graph.get_tensor_by_name(name + ':0') for name in gen_quantized_node_names(graph, q_config.output_nodes) ] with Session(graph=graph, config=s_config) as sess: inputs = input_fn(iter=0) feed_dict = gen_feed_dict(input_tensors, inputs) sess.run(output_tensors, feed_dict) print("INFO: Float Graph Check Done.")
def setUp(self): super(QuantizeTest, self).setUp() with Session(graph=Graph()) as session: with session.graph.as_default(): # initial [-1, 1) random matrix x = constant(2 * random((1, 4096)) - 1, dtype=float32, name='c1') y = constant(2 * random((4096, 1)) - 1, dtype=float32, name='c2') # matmul to scalar z = matmul(x, y, name='c3') self._desire_z = session.run(z) self._quantized_raw = quantize_graph_def(session.graph_def, output_nodes=['c3'], only='raw') self._quantized_simple = quantize_graph_def(session.graph_def, only='simple') self._quantized_full = quantize_graph_def(session.graph_def)
def calibrate_frozen(input_graph_def, input_fn, q_config, s_config): """Transform float graph to quantized graph and do calibration""" temp_path = os.path.join(q_config.output_dir, "temp") if not os.path.exists(temp_path): os.makedirs(temp_path) # Calibration calib_graph_def = CreateQuantizeCalibrationGraphDef( input_graph_def, q_config) graph = ops.Graph() with graph.as_default(): importer.import_graph_def(calib_graph_def, name='') print("INFO: Calibrating for {} iterations...".format( q_config.calib_iter)) input_tensors = [ op.outputs[0] for op in graph.get_operations() if op.type == 'Placeholder' ] output_tensors = [ graph.get_tensor_by_name(name + ':0') for name in gen_quantized_node_names(graph, q_config.output_nodes) ] with Session(graph=graph, config=s_config) as sess: progress = ProgressBar() for i in progress(range(0, q_config.calib_iter)): inputs = input_fn(iter=i) feed_dict = gen_feed_dict(input_tensors, inputs) sess.run(output_tensors, feed_dict) print("INFO: Calibration Done.") # Quantized Evaluation quantize_eval_graph_def = CreateQuantizeEvaluationGraphDef( calib_graph_def, q_config) save_pb_file(quantize_eval_graph_def, os.path.join(q_config.output_dir, "quantize_eval_model.pb")) shutil.rmtree(temp_path) return quantize_eval_graph_def
def deploy_checkpoint(input_meta_graph_def, input_checkpoint, q_config): if not checkpoint_management.checkpoint_exists(input_checkpoint): raise ValueError("Input checkpoint '" + input_checkpoint + "' does not exits.") if gfile.IsDirectory(input_checkpoint): input_checkpoint = checkpoint_management.latest_checkpoint( input_checkpoint) if not os.path.exists(q_config.output_dir): os.makedirs(q_config.output_dir) quantize_eval_graph_def = None if input_meta_graph_def: quantize_eval_graph_def = input_meta_graph_def.graph_def else: raise ValueError("You need to provide a `MetaGraphDef` for deploy.") q_config.output_nodes = get_quantized_nodes(quantize_eval_graph_def, q_config.output_nodes) saver = saver_lib.import_meta_graph(input_meta_graph_def, clear_devices=True) with Session() as sess: saver.restore(sess, input_checkpoint) frozen_graph_def = graph_util.convert_variables_to_constants( sess, quantize_eval_graph_def, q_config.output_nodes) if not os.path.exists(os.path.join(q_config.output_dir, "deploy")): os.makedirs(os.path.join(q_config.output_dir, "deploy")) quantize_deploy_graph_def = CreateQuantizeDeployGraphDef( frozen_graph_def, q_config) save_pb_file(quantize_deploy_graph_def, os.path.join(q_config.output_dir, "deploy/deploy_model.pb")) print("INFO: Quantize deploy graph are generated in: {}".format( os.path.join(q_config.output_dir, "deploy"))) return
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)
batch_size = self._batch_size with tf.name_scope(name=name_scope): dataset = Dataset.from_tensor_slices((x, y)) dataset = dataset.shuffle(buffer_size=batch_size * 10) \ .repeat() \ .map(map_func=map_fn, num_parallel_calls=8) \ .batch(batch_size=batch_size) \ .prefetch(buffer_size=batch_size * 10) init_op = dataset.make_initializable_iterator(shared_name='init_op') next_op = init_op.get_next(name='next_op') return init_op, next_op if __name__=='__main__': is_training = tf.placeholder(tf.bool, shape=(), name='is_training') dataset = Cifar10Dataset(batch_size=128) train_init_op, train_next_op = dataset.get_train_dataset() test_init_op, test_next_op = dataset.get_test_dataset() print(train_next_op) print(test_next_op) input = cond(is_training, true_fn=lambda: train_next_op, false_fn=lambda: test_next_op, name='input') import time with Session() as sess: sess.run([train_init_op.initializer, test_init_op.initializer]) start_time = time.time() for _ in range(1000): input_value=sess.run([input], feed_dict={is_training: True}) print(input_value[0][0].shape) print('total time: %d' % (time.time() - start_time))
import numpy as np from tensorflow.keras.applications.imagenet_utils import preprocess_input, decode_predictions from tensorflow.keras.models import load_model from tensorflow.keras.preprocessing import image from django.http import JsonResponse from rest_framework.decorators import api_view from rest_framework.response import Response from tensorflow.python.client.session import Session from tensorflow.python.framework.ops import Graph from .serializers import FormSubmitSerializer, MedicineDetectSerializer MODEL_PATH = 'model/model_inception.h5' model_graph = Graph() with model_graph.as_default(): tf_session = Session() with tf_session.as_default(): model = load_model(MODEL_PATH) @api_view(['POST']) def formsubmit(request): serializer = FormSubmitSerializer(data=request.data) if serializer.is_valid(): serializer.save() MedicineName = request.POST['MedicineName'] Introduction = request.POST['Introduction'] WhenToTake = request.POST['WhenToTake'] SideEffects = request.POST['SideEffects']
import gym import numpy as np from tensorflow.core.protobuf.config_pb2 import ConfigProto, GPUOptions from tensorflow.python.client.session import Session from tensorflow.python.keras.backend import set_session from tensorflow.python.keras.models import load_model if __name__ == "__main__": config = ConfigProto(gpu_options=GPUOptions( per_process_gpu_memory_fraction=0.8)) config.gpu_options.allow_growth = True session = Session(config=config) set_session(session) model = load_model("working_model") env = gym.make("CartPole-v1") for t in range(200): state = np.reshape(env.reset(), [1, 4]) step = 0 while True: step += 1 env.render() action = np.argmax(model.predict(state)) observation, _, done, _ = env.step(action) observation = np.reshape(observation, [1, 4]) state = observation
def CreateQuantizeDeployGraph(graph=None, checkpoint='', config=None): """Python wrapper for the decent_q create deploy graph tool. Args: graph: the graph to be quantized, default graph will be used if set None. checkpoint: the checkpoint path config: the QuantizeConfig Returns: Transformed Graph(as default) for quantize deploy. """ if config is None: raise ValueError("Please set the QuantizeConfig.") elif not isinstance(config, QuantizeConfig): raise ValueError("Config shoulb be a QuantizeConfig object.") # Create the output_dir if not os.path.exists(config.output_dir): try: os.makedirs(config.output_dir) except Exception as e: print(e) if graph is None: graph = get_default_graph() quantize_eval_graph_def = graph.as_graph_def() if os.path.isdir(checkpoint): checkpoint = checkpoint_management.latest_checkpoint(checkpoint) else: pass print("INFO: Creating quantize eval model from: {}".format(checkpoint)) step_in_ckpt = checkpoint.rsplit("-")[-1] # Freeze the checkpoint into the graph config.output_nodes = get_quantized_nodes(quantize_eval_graph_def, config.output_nodes) saver = saver_lib.Saver() with Session() as sess: saver.restore(sess, checkpoint) frozen_graph_def = graph_util.convert_variables_to_constants( sess, quantize_eval_graph_def, config.output_nodes) # Convert folded batchnorms frozen_quantize_eval_graph_def = ConvertFoldedBatchnorms( frozen_graph_def, config) # Deploy quantize_deploy_graph_def = CreateQuantizeDeployGraphDef( frozen_quantize_eval_graph_def, config) # Save the model # for quantize finetune model, replace input node with placeholder # replaced_graph_def = frozen_quantize_eval_graph_def for target_node_name, shape in zip(config.input_nodes, config.input_shapes): frozen_quantize_eval_graph_def = SetInputNodesAsPlaceholder( frozen_quantize_eval_graph_def, target_node_name, shape) frozen_quantize_eval_path = os.path.join( config.output_dir, "quantize_eval_model_{}_{}.pb".format( step_in_ckpt, time.strftime("%Y%m%d%H%M%S", time.localtime()))) save_pb_file(frozen_quantize_eval_graph_def, frozen_quantize_eval_path) print("INFO: Quantize eval model is generated in: {}".format( frozen_quantize_eval_path)) deploy_path = os.path.join( config.output_dir, "deploy_model_{}_{}.pb".format( step_in_ckpt, time.strftime("%Y%m%d%H%M%S", time.localtime()))) save_pb_file(quantize_deploy_graph_def, deploy_path) print("INFO: Deploy model is generated in: {}".format(deploy_path)) return
def create_session(self): """ create tensorflow session """ self.sess = Session(config=self.config)
def dump(input_graph_def, input_fn, output_dir, max_dump_batches, dump_float, s_config, dump_input_tensors=''): """Dump weights and activation data""" w_q_map = dict() a_q_map = dict() for node in input_graph_def.node: if node.op == "FixNeuron": if node.name.endswith("wquant"): w_q_map[node.name] = int(node.attr['quantize_pos'].i) else: a_q_map[node.name] = int(node.attr['quantize_pos'].i) if not os.path.exists(output_dir): os.makedirs(output_dir) graph = ops.Graph() with graph.as_default(): if dump_input_tensors: # TODO: Support multi input tensors image = array_ops.placeholder(dtypes.float32, shape=(None, None, None, 3), name="image_tensor") importer.import_graph_def(input_graph_def, name='', input_map={dump_input_tensors: image}) else: importer.import_graph_def(input_graph_def, name='') # Get fetches w_fetch_tensors = [] w_fetch_names = [] a_fetch_tensors = [] a_fetch_names = [] for op in graph.get_operations(): if dump_float: try: a_fetch_tensors.append(op.outputs[0]) a_fetch_names.append(op.name) except KeyError: continue elif op.type == "FixNeuron": if op.name.endswith("wquant"): w_fetch_tensors.append(op.outputs[0]) w_fetch_names.append(op.name) else: a_fetch_tensors.append(op.outputs[0]) a_fetch_names.append(op.name) # Dump weights/biases print("INFO: Start Dumping for {} batches".format(max_dump_batches)) with Session(config=s_config) as sess: dump_folder = os.path.join(output_dir, "dump_results_weights") if not os.path.exists(dump_folder): os.makedirs(dump_folder) print("INFO: Dumping weights/biases...") w_fetch_results = sess.run(w_fetch_tensors) index = 0 for name, res in zip(w_fetch_names, w_fetch_results): index = index + 1 filename = os.path.join(dump_folder, name.replace("/", "_")) print("INFO: Dumping ({}/{}): {}".format( index, len(w_fetch_names), name)) res = res.flatten() if name in w_q_map: res = res * 2**w_q_map[name] res.astype(np.int8).tofile(filename + ".bin") np.savetxt(filename + ".txt", res.astype(np.int8), fmt="%s", delimiter=",") # Build feed_dict input_tensors = [ op.outputs[0] for op in graph.get_operations() if op.type == 'Placeholder' ] # Run inference and dump activations print("INFO: Start Dumping for {} batches".format(max_dump_batches)) with Session(config=s_config) as sess: for i in range(max_dump_batches): dump_folder = os.path.join(output_dir, "dump_results_" + str(i)) if not os.path.exists(dump_folder): os.makedirs(dump_folder) print("INFO: Dumping for batch: {}/{} ...".format( i + 1, max_dump_batches)) inputs = input_fn(iter=i) feed_dict = gen_feed_dict(input_tensors, inputs) a_fetch_results = sess.run(a_fetch_tensors, feed_dict) index = 0 for name, res in zip(a_fetch_names, a_fetch_results): index = index + 1 filename = os.path.join(dump_folder, name.replace("/", "_")) print("INFO: Dumping ({}/{}): {}".format( index, len(a_fetch_names), name)) res = res.flatten() if dump_float: res.tofile(filename + "_float.bin") np.savetxt(filename + "_float.txt", res, fmt="%s", delimiter=",") if name in a_q_map: res = res * 2**a_q_map[name] res.astype(np.int8).tofile(filename + ".bin") np.savetxt(filename + ".txt", res.astype(np.int8), fmt="%s", delimiter=",") print("INFO: Dump results are saved in {}.".format(output_dir)) return