def main(argv):
del argv # Unused
if FLAGS.enable_eager:
tf.enable_eager_execution()
tf.config.set_soft_device_placement(True)
config_params = FLAGS.config_param or []
config_params += train_eval.get_gin_override_params(FLAGS.output_dir)
base_config_path = os.path.dirname(FLAGS.config_path[0])
gin.add_config_file_search_path(base_config_path)
gin.parse_config_files_and_bindings(FLAGS.config_path, config_params)
if FLAGS.num_virtual_gpus > -1:
gpus = tf.config.experimental.list_physical_devices("GPU")
total_gpu_mem_limit = 8192
per_gpu_mem_limit = total_gpu_mem_limit / FLAGS.num_virtual_gpus
virtual_gpus = [
tf.config.experimental.VirtualDeviceConfiguration(
memory_limit=per_gpu_mem_limit)
] * FLAGS.num_virtual_gpus
tf.config.experimental.set_virtual_device_configuration(
gpus[0], virtual_gpus)
logical_gpus = tf.config.experimental.list_logical_devices("GPU")
print(len(gpus), "Physical GPUs,", len(logical_gpus), "Logical GPUs")
train_eval.train_eval_loop(
offline_train=FLAGS.offline_train,
offline_train_data_dir=FLAGS.offline_train_data_dir)
def cfr_train(unused_arg):
exploit_history = list()
exploit_idx = list()
tf.enable_eager_execution()
game = pyspiel.load_game(FLAGS.game, {"players": pyspiel.GameParameter(2)})
agent_name = "cfr"
cfr_solver = cfr.CFRSolver(game)
checkpoint = datetime.now()
for ep in range(FLAGS.episodes):
cfr_solver.evaluate_and_update_policy()
if ep % 100 == 0:
delta = datetime.now() - checkpoint
conv = exploitability.exploitability(game,
cfr_solver.average_policy())
exploit_idx.append(ep)
exploit_history.append(conv)
print(
"Iteration {} exploitability {} - {} seconds since last checkpoint"
.format(ep, conv, delta.seconds))
checkpoint = datetime.now()
pickle.dump([exploit_idx, exploit_history],
open(
FLAGS.game + "_" + agent_name + "_" + str(FLAGS.episodes) +
".dat", "wb"))
now = datetime.now()
policy = cfr_solver.average_policy()
agent_name = "cfr"
for pid in [1, 2]:
policy_to_csv(
game, policy,
f"policies/policy_" + now.strftime("%m-%d-%Y_%H-%M") + "_" +
agent_name + "_" + str(pid + 1) + "_+" + str(ep) + "episodes.csv")
def main(argv):
_ = argv
tf.logging.set_verbosity(tf.logging.INFO)
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
tf.enable_eager_execution(config=config)
run_experiment()
def make_prediction(img, MODEL_PATH):
tf.enable_eager_execution()
to_predict = preprocess(img)
x_img = to_predict.shape[0]
y_img = to_predict.shape[1]
if len(to_predict.shape) == 3:
z_img = to_predict.shape[2]
else:
z_img = 1
PIXEL_COUNT = x_img * y_img * z_img
LABEL_COUNT = 1
to_predict_reshape = np.reshape(to_predict, (1, x_img * y_img * z_img))
g = tf.Graph()
with g.as_default():
session = tf.InteractiveSession()
model = build_model(PIXEL_COUNT, LABEL_COUNT)
saver = tf.train.Saver()
saver.restore(session, MODEL_PATH)
predictions = model.output.eval(
session=session,
feed_dict={model.x_placeholder: to_predict_reshape})
session.close()
box_image, x, y, width, height = plot_images(
to_predict, (predictions + 1) * (64, 32, 64, 32))
plate = result(to_predict, x, y, height, width)
return box_image, plate
def image_callback(msg):
print("Received an image!")
cv2_img = bridge.imgmsg_to_cv2(msg, "bgr8")
# try:
# except (CvBridgeError, e):
# print(e)
# else:
# print("ERROR!!!")
cv2_img = cv2.resize(cv2_img, (224, 224))
X = cv2_img.reshape(1, 224, 224, 3)
global sess
global graph
tf.enable_eager_execution()
with graph.as_default():
set_session(sess)
Y = model.predict(X)
angularVelocity = Y
print(angularVelocity)
pubCommand = rospy.Publisher('/cmd_vel', Twist)
global command
command = Twist()
command.linear.x = 0.05
command.linear.y = 0.0
command.linear.z = 0.0
command.angular.z = angularVelocity / 2
pubCommand.publish(command)
cv2.waitKey(1)
def _main() -> None:
"""スクリプトのエントリポイント
"""
import logging
logging.basicConfig(level=logging.INFO)
tfv1.enable_eager_execution()
raw_train, raw_validation, _, metadata = datasets.get_batch_dataset(shuffle_seed=0)
base_learning_rate = 0.0001
model = network_ft.MobileNetV2FT()
model.compile(
optimizer=tf.keras.optimizers.RMSprop(lr=base_learning_rate),
loss="binary_crossentropy",
metrics=["accuracy"],
)
# initial model accuracy
loss0, accuracy0 = model.evaluate(raw_validation, steps=20)
logger.info(f"initial loss: {loss0:.2f}, acc: {accuracy0:.2f}")
# training
checkpoint = utils.load_checkpoints(model, save_dir="_data/ckpt_finetuning")
history = model.fit(
raw_train, epochs=2, validation_data=raw_validation, callbacks=[checkpoint]
)
utils.plot_history(history)
def degre_tf(tensor_obj):
tf.enable_eager_execution()
tensor_obj = tf.reshape(tensor_obj, (30, 35, 35))
shapes = tensor_obj.get_shape().as_list()
pivot_np = np.zeros((shapes[0], shapes[1]))
deg = tf.Variable(pivot_np)
for i in range(shapes[0]): # testing for one sample
#G = nx.Graph()
graph_tensor = tensor_obj[i]
#graph_tensor = tf.Variable(graph_tensor, dtype=tf.float64)
graph_tensor = graph_tensor.numpy()
G = nx.from_numpy_matrix(graph_tensor)
'''
for x in range(shapes[1]):
G.add_node(x) ## adding 35 nodes in the graph
for x in range(shapes[1]): # or: for x in range(shapes[1])
for y in range(shapes[2]):
my_tensor=graph_tensor[x][y]
print('my tensor is',my_tensor)
#gt=tf.Variable(graph_tensor[x][y],dtype=tf.float64)
if tf.math.not_equal(graph_tensor[x][y], 0):
G.add_edge(x,y,weight=graph_tensor[x][y])
'''
dict = nx.degree_centrality(G)
#dict=nx.closeness_centrality(G,distance='weight',wf_improved=False)
#dict=nx.eigenvector_centrality_numpy(G, weight='weight')
#dict=nx.betweenness_centrality(G, weight= 'weight', endpoints=False,normalized=True)# default settings
for z in range(shapes[1]):
pivot_np[i][z] = dict.get(z)
print('degrees are', pivot_np)
deg.assign(pivot_np)
tf.cast(deg, tf.float32)
return deg
def _main() -> None:
"""簡易動作テスト用スクリプト
"""
import logging
import tensorflow.compat.v1 as tfv1
logger = logging.getLogger(__name__)
logging.basicConfig(level=logging.INFO)
tfv1.enable_eager_execution()
# base model
model = MobileNetV2FT()
model.base.summary()
# additional model
base_learning_rate = 0.0001
model.build((32, 160, 160, 3))
model.compile(
optimizer=tf.keras.optimizers.RMSprop(lr=base_learning_rate),
loss="binary_crossentropy",
metrics=["accuracy"],
)
model.summary()
logger.info(f"trainable variables = {len(model.trainable_variables)}")
def eager_execution_test():
#--------------------
# Eager execution provides an imperative interface to TensorFlow.
# With eager execution enabled, TensorFlow functions execute operations immediately (as opposed to adding to a graph to be executed later in a tf.compat.v1.Session) and return concrete values (as opposed to symbolic references to a node in a computational graph).
tf.enable_eager_execution()
print('6 + 7 = ', tf.multiply(6, 7).numpy())
def main(_):
# Enables eager context for TF 1.x. TF 2.x will use eager by default.
# This is used to conveniently get a representative dataset generator using
# TensorFlow training input helper.
tf.enable_eager_execution()
model_builder = get_model_builder(FLAGS.model_name)
with tf.Graph().as_default(), tf.Session() as sess:
images = tf.placeholder(tf.float32,
shape=(1, FLAGS.image_size, FLAGS.image_size,
3),
name="images")
logits, endpoints = model_builder.build_model(images, FLAGS.model_name,
False)
if FLAGS.endpoint_name:
output_tensor = endpoints[FLAGS.endpoint_name]
else:
output_tensor = tf.nn.softmax(logits)
restore_model(sess, FLAGS.ckpt_dir, FLAGS.enable_ema)
if FLAGS.output_saved_model_dir:
signature_def_map = {
"serving_default":
tf.compat.v1.saved_model.signature_def_utils.
predict_signature_def({"input": images},
{"output": output_tensor})
}
builder = tf.compat.v1.saved_model.Builder(
FLAGS.output_saved_model_dir)
builder.add_meta_graph_and_variables(
sess, ["serve"], signature_def_map=signature_def_map)
builder.save()
print("Saved model written to %s" % FLAGS.output_saved_model_dir)
converter = tf.lite.TFLiteConverter.from_session(
sess, [images], [output_tensor])
if FLAGS.quantize:
if not FLAGS.data_dir:
raise ValueError(
"Post training quantization requires data_dir flag to point to the "
"calibration dataset. To export a float model, set "
"--quantize=False.")
converter.representative_dataset = tf.lite.RepresentativeDataset(
representative_dataset_gen)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.inference_input_type = tf.lite.constants.QUANTIZED_UINT8
converter.inference_output_type = tf.lite.constants.QUANTIZED_UINT8
converter.target_spec.supported_ops = [
tf.lite.OpsSet.TFLITE_BUILTINS_INT8
]
tflite_buffer = converter.convert()
tf.gfile.GFile(FLAGS.output_tflite, "wb").write(tflite_buffer)
print("tflite model written to %s" % FLAGS.output_tflite)
def setUp(self):
super().setUp()
self._solver_cls = deep_evolution_solver.MutationPredictorSolver
tf.enable_eager_execution()
self.problem = simple_ising_model.AlternatingChainIsingModel(
length=20, vocab_size=4)
self.vocab_size = self.problem.domain.vocab_size
self.length = self.problem.domain.length
def main(argv):
logging.info('Running main.')
if len(argv) > 1:
raise app.UsageError('Too many command-line arguments.')
# This is on by default in TF 2.0.
tf_old.enable_eager_execution()
train_and_validate()
def _main() -> None:
"""簡易テスト用スクリプト
"""
import tensorflow.compat.v1 as tfv1
tfv1.enable_eager_execution()
raw_train, _ = get_dataset()
for idx, image in enumerate(raw_train.take(2)):
_show_and_save_image(tf.reshape(image, (28, 28)), f"image_{idx}",
f"_data/image_{idx}.png")
def rcfr_train(unused_arg):
tf.enable_eager_execution()
game = pyspiel.load_game(FLAGS.game, {"players": pyspiel.GameParameter(2)})
models = [
rcfr.DeepRcfrModel(
game,
num_hidden_layers=1,
num_hidden_units=64 if FLAGS.game == "leduc_poker" else 13,
num_hidden_factors=1,
use_skip_connections=True) for _ in range(game.num_players())
]
patient = rcfr.RcfrSolver(game, models, False, True)
exploit_history = list()
exploit_idx = list()
def _train(model, data):
data = data.shuffle(1000)
data = data.batch(12)
#data = data.repeat(1)
optimizer = tf.keras.optimizers.Adam(lr=0.005, amsgrad=True)
for x, y in data:
optimizer.minimize(
lambda: tf.losses.huber_loss(y, model(x)), # pylint: disable=cell-var-from-loop
model.trainable_variables)
agent_name = "rcfr"
checkpoint = datetime.now()
for iteration in range(FLAGS.episodes):
if (iteration % 100) == 0:
delta = datetime.now() - checkpoint
conv = pyspiel.exploitability(game, patient.average_policy())
exploit_idx.append(iteration)
exploit_history.append(conv)
print(
"[RCFR] Iteration {} exploitability {} - {} seconds since last checkpoint"
.format(iteration, conv, delta.seconds))
checkpoint = datetime.now()
patient.evaluate_and_update_policy(_train)
pickle.dump([exploit_idx, exploit_history],
open(
FLAGS.game + "_" + agent_name + "_" + str(FLAGS.episodes) +
".dat", "wb"))
now = datetime.now()
policy = patient.average_policy()
for pid in [1, 2]:
policy_to_csv(
game, policy, f"policies/policy_" +
now.strftime("%m-%d-%Y_%H-%M") + "_" + agent_name + "_" +
str(pid + 1) + "_+" + str(FLAGS.episodes) + "episodes.csv")
def _main() -> None:
"""簡易動作用スクリプト
"""
import logging
import tensorflow.compat.v1 as tfv1
logging.basicConfig(level=logging.INFO)
tfv1.enable_eager_execution()
dataset_train, _ = dataset.get_batch_dataset()
train(dataset_train, epochs=2)
utils.save_gif("_data/", "image_at_epoch_*", "_data/dcgan.gif")
def main(_):
tf.enable_eager_execution()
tf.logging.set_verbosity(tf.logging.INFO)
required_flags = ['input_tfrecord_paths', 'output_tfrecord_path',
'inference_graph']
for flag_name in required_flags:
if not getattr(FLAGS, flag_name):
raise ValueError('Flag --{} is required'.format(flag_name))
if FLAGS.gpu_device:
os.environ["CUDA_VISIBLE_DEVICES"] = str(FLAGS.gpu_device)
output_folder = "/"
output_folder = output_folder.join(FLAGS.output_tfrecord_path.split("/")[:-1])
if not os.path.exists(output_folder):
os.mkdir(output_folder)
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
input_tfrecord_paths = [
v for v in FLAGS.input_tfrecord_paths.split(',') if v]
tf.logging.info('Reading input from %d files', len(input_tfrecord_paths))
serialized_example_tensor, image_tensor = detection_inference.build_input(
input_tfrecord_paths, num_additional_channels=FLAGS.num_additional_channels)
tf.logging.info('Reading graph and building model...')
(detected_boxes_tensor, detected_scores_tensor,
detected_labels_tensor) = detection_inference.build_inference_graph(
image_tensor, FLAGS.inference_graph)
tf.logging.info('Running inference and writing output to {}'.format(
FLAGS.output_tfrecord_path))
sess.run(tf.local_variables_initializer())
tf.train.start_queue_runners()
with tf.python_io.TFRecordWriter(
FLAGS.output_tfrecord_path) as tf_record_writer:
try:
for counter in itertools.count():
tf.logging.log_every_n(tf.logging.INFO, 'Processed %d images...', 10,
counter)
tf_example = detection_inference.infer_detections_and_add_to_example(
serialized_example_tensor, detected_boxes_tensor,
detected_scores_tensor, detected_labels_tensor,
FLAGS.discard_image_pixels)
tf_record_writer.write(tf_example.SerializeToString())
except tf.errors.OutOfRangeError:
tf.logging.info('Finished processing records')
def check_dataset(input_fn, params):
tf.enable_eager_execution()
dataset = input_fn(params)
dataset_iter = dataset.make_one_shot_iterator()
tensor, _ = next(dataset_iter)
enc = fetch_encoder(params)
for p in tensor[:1]:
txt = enc.decode(p)
print('-' * 50)
print(txt[:500], '\n\n...\n\n', txt[-500:])
print('-' * 50)
exit()
def main(_):
tf.enable_eager_execution()
envs = [
'HalfCheetah-v1', 'Hopper-v1', 'Ant-v1', 'Walker2d-v1', 'Reacher-v1'
]
for ienv, env in enumerate(envs):
print('Processing environment %d of %d: %s' %
(ienv + 1, len(envs), env))
h5_filename = os.path.join(FLAGS.src_data_dir, '%s.h5' % env)
trajectories = h5py.File(h5_filename, 'r')
if (set(trajectories.keys()) != set(
['a_B_T_Da', 'len_B', 'obs_B_T_Do', 'r_B_T'])):
raise ValueError('Unexpected key set in file %s' % h5_filename)
replay_buffer = ReplayBuffer()
if env.find('Reacher') > -1:
max_len = 50
else:
max_len = 1000
for i in range(50):
print(' Processing trajectory %d of 50 (len = %d)' %
(i + 1, trajectories['len_B'][i]))
for j in range(trajectories['len_B'][i]):
mask = 1
if j + 1 == trajectories['len_B'][i]:
if trajectories['len_B'][i] == max_len:
mask = 1
else:
mask = 0
replay_buffer.push_back(
trajectories['obs_B_T_Do'][i][j],
trajectories['a_B_T_Da'][i][j],
trajectories['obs_B_T_Do'][i][(j + 1) %
trajectories['len_B'][i]],
[trajectories['r_B_T'][i][j]], [mask],
j == trajectories['len_B'][i] - 1)
replay_buffer_var = contrib_eager_python_tfe.Variable(
'', name='expert_replay_buffer')
saver = contrib_eager_python_tfe.Saver([replay_buffer_var])
odir = os.path.join(FLAGS.dst_data_dir, env)
print('Saving results to checkpoint in directory: %s' % odir)
tf.gfile.MakeDirs(odir)
replay_buffer_var.assign(pickle.dumps(replay_buffer))
saver.save(os.path.join(odir, 'expert_replay_buffer'))
def neurd_train(unudes_arg):
tf.enable_eager_execution()
game = pyspiel.load_game(FLAGS.game, {"players": pyspiel.GameParameter(2)})
models = []
for _ in range(game.num_players()):
models.append(
neurd.DeepNeurdModel(game,
num_hidden_layers=1,
num_hidden_units=13,
num_hidden_factors=8,
use_skip_connections=True,
autoencode=False))
solver = neurd.CounterfactualNeurdSolver(game, models)
def _train(model, data):
neurd.train(model,
data,
batch_size=100,
step_size=1,
threshold=2,
autoencoder_loss=(None))
exploit_history = list()
for ep in range(FLAGS.episodes):
solver.evaluate_and_update_policy(_train)
if ep % 100 == 0:
conv = pyspiel.exploitability(game, solver.average_policy())
exploit_history.append(conv)
print("Iteration {} exploitability {}".format(ep, conv))
now = datetime.now()
policy = solver.average_policy()
agent_name = "neurd"
for pid in [1, 2]:
policy_to_csv(
game, policy,
f"policies/policy_" + now.strftime("%m-%d-%Y_%H-%M") + "_" +
agent_name + "_" + str(pid + 1) + "_+" + str(ep) + "episodes.csv")
plt.plot([i for i in range(len(exploit_history))], exploit_history)
plt.ylim(0.01, 1)
plt.yticks([1, 0.1, 0.01])
plt.yscale("log")
plt.xscale("log")
plt.show()
def main():
tfv1.enable_eager_execution()
logger.info(f"execute eagerly = {tf.executing_eagerly()}")
logger.info(f"is gpu available = {tf.test.is_gpu_available()}")
logger.info("get dataset...")
train, _ = datasets.get_dataset()
logger.info("learning...")
network = model.MNISTModel()
trainer = model.Trainer()
checkpoint = model.Checkpoint(network=network, optimizer=trainer.optimizer)
start_learning = time.time()
start(network, trainer, train, 5, checkpoint)
end_learning = time.time()
logger.info(f"learning time: {end_learning - start_learning} sec")
def main():
tfv1.enable_eager_execution()
logger.info(f"execute eagerly = {tf.executing_eagerly()}")
logger.info(f"is gpu available = {tf.test.is_gpu_available()}")
logger.info("get dataset...")
_, test = datasets.get_dataset()
logger.info("predicting...")
network = model.MNISTModel()
predictor = model.Predictor()
model.Checkpoint(network=network)
start(network, predictor, test)
logger.info(
f"loss: {predictor.predict_loss.result()}, accuracy: {predictor.predict_accuracy.result()}"
)
def _main() -> None:
"""簡易動作テスト用スクリプト
"""
import tensorflow.compat.v1 as tfv1
tfv1.enable_eager_execution()
# base model
model = MobileNetV2FE()
model.base.summary()
# additional model
base_learning_rate = 0.0001
model.compile(
optimizer=tf.keras.optimizers.RMSprop(lr=base_learning_rate),
loss="binary_crossentropy",
metrics=["accuracy"],
)
model.build((32, 160, 160, 3))
model.summary()
def main(_):
flags.mark_flags_as_required(["task"])
if FLAGS.module_import:
import_modules(FLAGS.module_import)
gin.parse_config_files_and_bindings(FLAGS.gin_file, FLAGS.gin_param)
total_examples = 0
tf.enable_eager_execution()
task = t5.data.TaskRegistry.get(FLAGS.task)
ds = task.get_dataset(sequence_length=sequence_length(),
split=FLAGS.split,
use_cached=False,
shuffle=False)
keys = re.findall(r"{([\w+]+)}", FLAGS.format_string)
def _example_to_string(ex):
key_to_string = {}
for k in keys:
if k in ex:
v = ex[k].numpy().tolist()
if (FLAGS.detokenize
and v and isinstance(v, list)
and isinstance(v[0], int)):
s = task.output_features[k].vocabulary.decode([abs(i) for i in v])
elif isinstance(v, bytes):
s = v.decode("utf-8")
else:
s = " ".join(str(i) for i in v)
key_to_string[k] = s
else:
key_to_string[k] = ""
return FLAGS.format_string.format(**key_to_string)
for ex in ds:
print(_example_to_string(ex))
total_examples += 1
if total_examples == FLAGS.max_examples:
return
def main(_):
flags.mark_flags_as_required(["task"])
if FLAGS.module_import:
import_modules(FLAGS.module_import)
gin.parse_config_files_and_bindings(FLAGS.gin_file, FLAGS.gin_param)
total_examples = 0
tf.enable_eager_execution()
task = t5.data.TaskRegistry.get(FLAGS.task)
# Do a load to make sure the files exist before grabbing file path
task.tfds_dataset.load(FLAGS.split, shuffle_files=False)
files = task.tfds_dataset.files(FLAGS.split)
def _example_to_string(ex):
key_to_string = {}
for k in ("inputs", "targets"):
if k in ex:
v = ex[k].numpy()
key_to_string[k] = (
" ".join(str(i) for i in v) if FLAGS.tokenize
else v.decode("utf-8"))
else:
key_to_string[k] = ""
return FLAGS.format_string.format(**key_to_string)
for shard_path in files:
logging.info("Processing shard: %s", shard_path)
ds = task.tfds_dataset.load_shard(shard_path)
ds = task.preprocess_text(ds)
if FLAGS.tokenize:
ds = t5.data.encode_string_features(
ds, task.output_features, keys=task.output_features,
copy_plaintext=True)
ds = task.preprocess_tokens(ds, sequence_length())
for ex in ds:
print(_example_to_string(ex))
total_examples += 1
if total_examples == FLAGS.max_examples:
return
def main(_):
# Enables eager context for TF 1.x. TF 2.x will use eager by default.
# This is used to conveniently get a representative dataset generator using
# TensorFlow training input helper.
tf.enable_eager_execution()
converter = tf.lite.TFLiteConverter.from_saved_model(
FLAGS.saved_model_dir,
input_arrays=[FLAGS.input_name],
output_arrays=[FLAGS.output_name])
# Chooses a tf.lite.Optimize mode:
# https://www.tensorflow.org/api_docs/python/tf/lite/Optimize
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = tf.lite.RepresentativeDataset(
representative_dataset_gen)
if FLAGS.require_int8:
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
tflite_buffer = converter.convert()
tf.gfile.GFile(FLAGS.output_tflite, "wb").write(tflite_buffer)
print("tflite model written to %s" % FLAGS.output_tflite)
def check_dataset(input_fn):
tf.enable_eager_execution()
dataset = input_fn(params)
dataset_iter = dataset.make_one_shot_iterator()
tensor, _ = next(dataset_iter)
enc = fetch_encoder(params)
for p in tensor[:1]:
txt = enc.decode(p)
#txt = enc.decode(tensor)
max_id = tf.reduce_max(tensor)
min_id = tf.reduce_min(tensor)
print(tensor)
print(tensor.shape)
print('-' * 50)
print(txt[:500], '\n...\n', txt[-500:])
print('-' * 50)
print('min token id: ', min_id)
print('max token id: ', max_id)
exit()
def main(unused_argv):
tf.enable_eager_execution()
# WARNING: do not set tf.debugging.set_log_device_placement(True)
# This can cause an error when using Eager Execution and SavedModels.
examples = generate_realm_examples_with_model_refresh()
if FLAGS.local_debug:
featurizer = load_featurizer()
profile.reset()
start_time = time.time()
for i, (query, cands, _) in enumerate(examples):
if i % 50 == 0:
print('Example', i)
print('Total time elapsed: {}'.format(time.time() -
start_time))
print(query)
print('Originating doc UID: {}'.format(query.orig_doc_uid))
for cand in cands:
print('Doc UID: {}'.format(cand.uid))
print(
featurizer.tokenizer.token_ids_to_str(
cand.title_token_ids))
print(
featurizer.tokenizer.token_ids_to_str(
cand.body_token_ids))
print()
if i == 1000:
break
profile.print_report()
else:
preprocessing.push_examples(
example_generator=(tf_ex for query, cands, tf_ex in examples),
port=FLAGS.port,
max_queue_size=FLAGS.max_queue_size,
queue_timeout=30.0)
default=None,
choices=[None, "ZLIB", "GZIP"],
help='compression the dataset is compressed with')
args = parser.parse_args()
from src.createtask import create_registry
create_registry(os.path.join(args.dir, args.train),
os.path.join(args.dir, args.val), args.taskname,
args.compression)
args.tpu_address = f"grpc://{args.tpu_address}:8470"
if args.tpu_address != None:
tpu = tf.distribute.cluster_resolver.TPUClusterResolver(
tpu=args.tpu_address)
tf.enable_eager_execution()
tf.config.experimental_connect_to_cluster(tpu)
tf.tpu.experimental.initialize_tpu_system(tpu)
print("All devices: ", tf.config.list_logical_devices('TPU'))
tf.disable_v2_behavior()
tf.get_logger().propagate = False
py_logging.root.setLevel('INFO')
@contextmanager
def tf_verbosity_level(level):
og_level = tf.logging.get_verbosity()
tf.logging.set_verbosity(level)
yield
tf.logging.set_verbosity(og_level)
def load_tf_graph_def(graph_file_name: str = "", is_binary: bool = True, checkpoint: str = "",
model_dir: str = "", saved_model_tags: list = [], meta_graph_file: str = "",
user_output_node_names_list: list = []):
# As a provisional solution, use a native TF methods to load a model protobuf
graph_def = tf_v1.GraphDef()
if isinstance(graph_file_name, str) and (re.match('.*\.(ckpt|meta)$', graph_file_name)):
print('[ WARNING ] The value for the --input_model command line parameter ends with ".ckpt" or ".meta" '
'extension.\n'
'It means that the model is not frozen.\n'
'To load non frozen model to Model Optimizer run:'
'\n\n1. For "*.ckpt" file:'
'\n- if inference graph is in binary format'
'\npython3 mo_tf.py --input_model "path/to/inference_graph.pb" --input_checkpoint "path/to/*.ckpt"'
'\n- if inference graph is in text format'
'\npython3 mo_tf.py --input_model "path/to/inference_graph.pbtxt" --input_model_is_text '
'--input_checkpoint "path/to/*.ckpt"'
'\n\n2. For "*.meta" file:'
'\npython3 mo_tf.py --input_meta_graph "path/to/*.meta"')
variables_values = {}
try:
if graph_file_name and not meta_graph_file and not checkpoint:
# frozen graph
return read_file_to_graph_def(graph_def, graph_file_name, is_binary), variables_values, 'tf'
if graph_file_name and not meta_graph_file and checkpoint:
# inference graph and checkpoint
graph_def = read_file_to_graph_def(graph_def, graph_file_name, is_binary)
outputs = get_output_node_names_list(graph_def, user_output_node_names_list)
if os.path.isfile(checkpoint):
graph_def = freeze_checkpoint(graph_def=graph_def, checkpoint=checkpoint, output_node_names=outputs)
elif os.path.isdir(checkpoint):
graph_def, variables_values = freeze_checkpoints(graph_def=graph_def, checkpoint_dir=checkpoint,
output_node_names=outputs)
# we are sure that checkpoint is existing file or directory due to cli_parser configuration
return graph_def, variables_values, 'tf'
if not graph_file_name and meta_graph_file:
meta_graph_file = deducing_metagraph_path(meta_graph_file)
input_meta_graph_def = read_file_to_graph_def(tf_v1.MetaGraphDef(), meta_graph_file, is_binary)
# pylint: disable=no-member
with tf_v1.Session() as sess:
restorer = tf_v1.train.import_meta_graph(input_meta_graph_def)
restorer.restore(sess, re.sub('\.meta$', '', meta_graph_file))
outputs = get_output_node_names_list(input_meta_graph_def.graph_def, user_output_node_names_list)
graph_def = tf_v1.graph_util.convert_variables_to_constants(sess, input_meta_graph_def.graph_def,
outputs)
return graph_def, variables_values, 'tf'
if model_dir:
# saved model directory
try:
env_setup = get_environment_setup("tf")
# enable eager execution temporarily while TensorFlow 2 model is being loaded
tf_v1.enable_eager_execution()
# code to extract GraphDef for TF 2.0 SavedModel format
# tf.saved_model.load function throws TypeError for TF 1.x SavedModel format in case TF 1.x installed
imported = tf.saved_model.load(model_dir, saved_model_tags) # pylint: disable=E1120
# to get a signature by key throws KeyError for TF 1.x SavedModel format in case TF 2.x installed
concrete_func = imported.signatures[tf.saved_model.DEFAULT_SERVING_SIGNATURE_DEF_KEY]
# the aggressive inlining parameter needs to freeze a table of embeddings for Keras Embedding operation
# and a model with Embedding operation cannot properly converted to IR without this function parameter
if "tensorflow" in env_setup and env_setup["tensorflow"] >= LooseVersion("2.2.0"):
frozen_func = convert_variables_to_constants_v2(concrete_func,
lower_control_flow=False,
aggressive_inlining=True) # pylint: disable=E1123
else:
frozen_func = convert_variables_to_constants_v2(concrete_func,
lower_control_flow=False) # pylint: disable=E1123
graph_def = frozen_func.graph.as_graph_def(add_shapes=True)
# disable eager execution since next steps are executed with a graph in non-eager mode
tf_v1.disable_eager_execution()
return graph_def, variables_values, 'tf2'
except (TypeError, KeyError):
# disable eager execution since TensorFlow 1 model is handled
tf_v1.disable_eager_execution()
# code to extract GraphDef for TF 1.0 SavedModel format
tags = saved_model_tags if saved_model_tags is not None else [tf_v1.saved_model.tag_constants.SERVING]
with tf_v1.Session() as sess:
meta_graph_def = tf_v1.saved_model.loader.load(sess, tags, model_dir)
outputs = get_output_node_names_list(meta_graph_def.graph_def, user_output_node_names_list)
graph_def = tf_v1.graph_util.convert_variables_to_constants(sess, meta_graph_def.graph_def, outputs)
return graph_def, variables_values, 'tf'
except Exception as e:
raise FrameworkError('SavedModel format load failure: {}', e) from e
except Exception as e:
raise FrameworkError('Cannot load input model: {}', e) from e
raise Error("Unknown configuration of input model parameters")
import os
import os.path as osp
import argparse
import tensorflow
import tensorflow.compat.v1 as tf
import numpy as np
CURRENT_DIR = osp.dirname(__file__)
sys.path.append(osp.join(CURRENT_DIR, '../..'))
from utils.misc_utils import load_cfgs
from siamese_datasets.dataloader import DataLoader
tf.enable_eager_execution()
tensorflow.executing_eagerly()
TF_MAJOR_VERSION = int(tf.__version__.split(".")[0])
if TF_MAJOR_VERSION == 1:
import tensorflow.contrib.slim as slim
from tensorflow.contrib import quantize as contrib_quantize
else:
import tf_slim as slim
tf.disable_v2_behavior()
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='')
parser.add_argument(
'--frozen_graph_model',
