def load(sess, checkpoint_dir):
import re
print(" [*] Reading checkpoints...")
# checkpoint_dir = os.path.join(checkpoint_dir, self.model_dir, self.model_name)
# saver = self.saver
ckpt = tf.train.get_checkpoint_state(checkpoint_dir)
# import the inspect_checkpoint library
from tensorflow.python.tools import inspect_checkpoint as chkp
if ckpt and ckpt.model_checkpoint_path:
ckpt_name = os.path.basename(ckpt.model_checkpoint_path)
# saver.restore(sess, os.path.join(checkpoint_dir, ckpt_name))
# print all tensors in checkpoint file
chkp.print_tensors_in_checkpoint_file(os.path.join(checkpoint_dir, ckpt_name), tensor_name='', all_tensors=False,all_tensor_names=True)
# chkp._count_total_params
# if not ckpt_name.find('best') == -1:
# counter = 0
# else:
# counter = int(next(re.finditer("(\d+)(?!.*\d)", ckpt_name)).group(0))
# print(" [*] Success to read {}".format(ckpt_name))
# return True, counter
else:
print(" [*] Failed to find a checkpoint")
def freeze_graph():
"""
Freeze tensorflow graph
Inputs: None
Ouutputs: None
"""
checkpoint = "model_to_freeze.ckpt"
saver = tf.train.import_meta_graph('model_to_freeze.ckpt.meta',
clear_devices=True)
graph = tf.get_default_graph()
input_graph_def = graph.as_graph_def()
print "Variables stored in checkpoint:"
print_tensors_in_checkpoint_file(file_name=checkpoint,
tensor_name='',
all_tensors='')
sess = tf.Session()
saver.restore(sess, checkpoint)
output_node_names = "densenet121/masked_logits,densenet121/probability"
output_graph_def = graph_util.convert_variables_to_constants(
sess, # The session
input_graph_def, # input_graph_def is useful for retrieving the nodes
output_node_names.split(","))
output_graph = "frozen_graph.pb"
with tf.gfile.GFile(output_graph, "wb") as f:
f.write(output_graph_def.SerializeToString())
sess.close()
os.remove('model_to_freeze.ckpt.meta')
os.remove('model_to_freeze.ckpt.index')
os.remove('model_to_freeze.ckpt.data-00000-of-00001')
def print_tensor_names(self):
ckpt = os.path.join(self.checkpoint_dir, 'model.ckpt') + '-' + repr(
self.restore_epoch)
print_tensors_in_checkpoint_file(file_name=ckpt,
tensor_name='',
all_tensors=False,
all_tensor_names=False)
def get_ckpt_alltensor_3():
savedir = './ckpt/' # 路径问题，最后加反斜杠，如果不加会认为斜杠后是文件名，而不是路径名
savefile = "model.ckpt"
print_tensors_in_checkpoint_file(os.path.join(savedir,savefile), #ckpt文件名字
None, # 如果为None,则默认为ckpt里的所有变量
True, # bool 是否打印所有的tensor，这里打印出的是tensor的值，一般不推荐这里设置为False
True) # bool 是否打印所有的tensor的name
def load_model(sess,
checkpoint_path,
root_file,
show_cp_content=True,
ignore_missing_vars=False):
"""warm-start the training.
"""
if not os.path.exists(checkpoint_path):
os.makedirs(checkpoint_path)
copyfile(root_file, checkpoint_path + '/' + root_file)
latest_ckpt = tf.train.latest_checkpoint(checkpoint_path)
if not latest_ckpt:
return tf.train.Saver()
print('restore from checkpoint: ' + checkpoint_path)
with HiddenPrints():
variables = slim.get_model_variables(
) # slim.get_variables_to_restore()
if show_cp_content:
print()
print(
'------------------------------------------------------------------------------'
)
print('variables stored in checkpoint:')
from tensorflow.python.tools.inspect_checkpoint import print_tensors_in_checkpoint_file
print_tensors_in_checkpoint_file(latest_ckpt, '', False)
print(
'------------------------------------------------------------------------------'
)
if ignore_missing_vars:
reader = tf.train.NewCheckpointReader(latest_ckpt)
saved_shapes = reader.get_variable_to_shape_map()
var_names = sorted([(var.name, var.name.split(':')[0])
for var in variables
if var.name.split(':')[0] in saved_shapes])
print('nr available vars in the checkpoint: %d' % len(var_names))
restore_vars = []
name2var = dict(
zip(map(lambda x: x.name.split(':')[0], variables), variables))
with tf.variable_scope('', reuse=True):
for var_name, saved_var_name in var_names:
curr_var = name2var[saved_var_name]
var_shape = curr_var.get_shape().as_list()
if var_shape == saved_shapes[saved_var_name]:
restore_vars.append(curr_var)
print('nr vars restored: %d' % len(restore_vars))
saver = tf.train.Saver(restore_vars)
else:
saver = tf.train.Saver(variables)
saver.restore(sess, latest_ckpt)
return saver
def load(self,
saver=None,
session: tf.compat.v1.Session = None,
allow_init=True):
if not session: session = self.session
if self.verb > 0: print()
for var in self.vars:
# look for checkpoint
latest_filename = 'checkpoint'
if saver: latest_filename += '_' + saver
ckpt = tf.train.latest_checkpoint(
checkpoint_dir=self.save_FD + '/' + var,
latest_filename=latest_filename) if self.save_FD else None
if ckpt:
if self.verb > 1:
print(f'\n >>> tensors @ckpt {ckpt}')
print_tensors_in_checkpoint_file(file_name=ckpt,
tensor_name='',
all_tensors=False)
self.savers[saver][var].restore(session, ckpt)
if self.verb > 0:
print(
f'Variables {var} restored from checkpoint {saver if saver else ""}'
)
else:
assert allow_init, 'Err: saver load failed: checkpoint not found and not allowInit'
session.run(tf.initializers.variables(self.vars[var]))
if self.verb > 0:
print(
f'No checkpoint found, variables {var} initialized with default initializer'
)
def print_weights_in_checkpoint(model_folder, cp_name):
load_path = os.path.join(model_folder, "{0}.ckpt".format(cp_name))
print_tensors_in_checkpoint_file(file_name=load_path,
tensor_name="",
all_tensors=True,
all_tensor_names=True)
def fn_inspect_checkpoint(ckpt_filepath, **kwargs):
name = kwargs.get('tensor_name', '')
if name == '':
all_tensors = True
else:
all_tensors = False
chkp.print_tensors_in_checkpoint_file(ckpt_filepath, name, all_tensors)
def restore(ckpt_dir, prefix):
with tf.Session() as sess:
# load meta
new_saver = tf.train.import_meta_graph(ckpt_dir + prefix + '.meta')
# restore model parameters
latest_checkpoint = tf.train.latest_checkpoint(ckpt_dir)
print_tensors_in_checkpoint_file(latest_checkpoint, all_tensors=False, all_tensor_names=True, tensor_name='')
input()
# checkpoint_path = os.path.join(model_dir, "model.ckpt")
reader = pywrap_tensorflow.NewCheckpointReader(latest_checkpoint)
var_to_shape_map = reader.get_variable_to_shape_map()
for key in var_to_shape_map:
print("tensor_name: ", key)
input()
print(reader.get_tensor(key)) # Remove this is you want to print only variable name
new_saver.restore(sess, latest_checkpoint)
# restore variables.
logits = tf.get_collection("logits")[0]
visits_weights = tf.get_collection("visits_betas")[0]
codes_weights = tf.get_collection("codes_alphas")[0]
preds = tf.get_collection("preds")[0]
probs = tf.get_collection("probs")[0]
accuracy = tf.get_collection("accuracy")[0]
loss = tf.get_collection("cross_entropy")[0]
def train_step(sess, train_op, loss, summaries, global_step, writer,
params, saver, steps, loss_sum):
'''
Helper function for training the model
'''
if params['log_step'] is not None:
#If it's a logging step
_, loss_val, sumr, global_step_val = sess.run(
[train_op, loss, summaries, global_step])
writer.add_summary(sumr, global_step_val)
loss_sum += loss_val
steps += 1
# log and reset averages
if global_step_val % params[
'log_step'] == 0 or global_step_val == params['steps']:
tf.logging.info('step: {}; loss: {}'.format(
global_step_val, loss_sum / steps))
save_dir = os.path.join(params['model_dir'], 'model.ckpt')
saver.save(sess, save_dir)
loss_sum = 0
steps = 0
#Save a checkpoint if this is the last step
if global_step_val == params[
'steps'] or global_step_val == params['steps'] - 1:
chkp.print_tensors_in_checkpoint_file(os.path.join(
params['model_dir'], 'model.ckpt'),
tensor_name='',
all_tensors=False,
all_tensor_names=True)
else:
#If it's a non-logging step
_, sumr, global_step_val = sess.run(
[train_op, summaries, global_step])
writer.add_summary(sumr, global_step_val)
return steps, loss_sum
def check_model(model_file):
from tensorflow.python.tools import inspect_checkpoint as chkp
# print all tensors in checkpoint file
chkp.print_tensors_in_checkpoint_file(model_file,
tensor_name='',
all_tensors=True)
def find_mbti_type(sentence_chunks, glove_vectors, sess, W1, b1, W2, b2):
if sess is None:
sess = tf.Session()
checkpoint = tf.train.latest_checkpoint('../models')
saver = tf.train.import_meta_graph(checkpoint + '.meta')
saver.restore(sess, checkpoint)
sess.run(tf.global_variables_initializer())
print_tensors_in_checkpoint_file(file_name='../models/baseline.ckpt',
tensor_name='',
all_tensors=True)
results = []
for chunk in sentence_chunks:
input = get_embedding_baseline(chunk, glove_vectors)
x_arr = np.array(input).astype(np.float32)
x_arr = x_arr.reshape(1, GLOVE_DIMENSION)
if W1 is None:
W1 = tf.get_default_graph().get_tensor_by_name("W1:0")
if b1 is None:
b1 = tf.get_default_graph().get_tensor_by_name("b1:0")
if W2 is None:
W2 = tf.get_default_graph().get_tensor_by_name("W2:0")
if b2 is None:
b2 = tf.get_default_graph().get_tensor_by_name("b2:0")
ymid = tf.matmul(x_arr, W1) + b1
yhat = tf.add(tf.matmul(ymid, W2), b2)
predict = tf.argmax(yhat, 1)
mbti_result = reverse_mbti_index[sess.run(predict)[0]]
print(mbti_result)
results.append(mbti_result)
return results
def load_checkpoint(sess, checkpoint_path):
saver = tf.train.Saver(tf.global_variables())
print(checkpoint_path)
ckpt = tf.train.get_checkpoint_state(checkpoint_path)
tf.logging.info('Loading model %s.', ckpt.model_checkpoint_path)
saver.restore(sess, ckpt.model_checkpoint_path)
chkp.print_tensors_in_checkpoint_file(checkpoint_path, tensor_name='', all_tensors=True)
def inspect_tensor_name():
chkp.print_tensors_in_checkpoint_file(
file_name=
"/home/jiatian/project/segdec-net-jim2019/output/segdec_train/KolektorSDD-dilate=5/full-size_cross-entropy/fold_0/model.ckpt-6599",
tensor_name=None, # 如果为None,则默认为ckpt里的所有变量
all_tensors=False, # bool 是否打印所有的tensor，这里打印出的是tensor的值，一般不推荐这里设置为False
all_tensor_names=True) # bool 是否打印所有的tensor的name
def print_tensor_in_ckpt(ckpt_folder,
all_tensor_values=False,
all_tensor_names=False):
""" This function print the list of tensors in checkpoint file.
Example:
from GeneralTools.graph_func import print_tensor_in_ckpt
ckpt_folder = '/home/richard/PycharmProjects/myNN/Results/cifar_ckpt/sngan_hinge_2e-4_nl'
print_tensor_in_ckpt(ckpt_folder)
:param ckpt_folder:
:param all_tensor_values: Boolean indicating whether to print the values of all tensors.
:param all_tensor_names: Boolean indicating whether to print all tensor names.
:return:
"""
from tensorflow.python.tools.inspect_checkpoint import print_tensors_in_checkpoint_file
if not isinstance(ckpt_folder,
str): # if list, use the name of the first file
ckpt_folder = ckpt_folder[0]
output_folder = os.path.join(FLAGS.DEFAULT_OUT, ckpt_folder)
print(output_folder)
ckpt = tf.train.get_checkpoint_state(output_folder)
print(ckpt)
print_tensors_in_checkpoint_file(file_name=ckpt.model_checkpoint_path,
tensor_name='',
all_tensors=all_tensor_values,
all_tensor_names=all_tensor_names)
def extract_checkpoint(load_file, save_file, architecture='small'):
print_tensors_in_checkpoint_file(file_name=load_file, tensor_name='', all_tensors=False)
c1b, c1k, c2b, c2k, d1b, d1k, d2b, d2k = get_weight_vars(architecture)
saver = tf.train.Saver()
with tf.Session() as sess:
# saver.restore(sess, "models_fmnist/nonprivate_lr005/model.ckpt-14040")
saver.restore(sess, load_file)
c1b_mat = c1b.eval()
c1k_mat = c1k.eval()
c2b_mat = c2b.eval()
c2k_mat = c2k.eval()
d1b_mat = d1b.eval()
d1k_mat = d1k.eval()
d2b_mat = d2b.eval()
d2k_mat = d2k.eval()
np.savez(save_file,
c1b=c1b_mat, c1k=c1k_mat,
c2b=c2b_mat, c2k=c2k_mat,
d1b=d1b_mat, d1k=d1k_mat,
d2b=d2b_mat, d2k=d2k_mat)
dump = np.load(save_file)
print(dump['c1b'])
def _print_checkpt_vars(path):
# For debugging
from tensorflow.python.tools.inspect_checkpoint import (
print_tensors_in_checkpoint_file)
print_tensors_in_checkpoint_file(path,
all_tensor_names=True,
all_tensors=False,
tensor_name='')
def inspect_ckpt_v2(checkpoint):
# 'all_tensors' indicates whether to print all tensors (include tensor name and value).
# 'all_tensor_names' indicates whether to print all tensor names.
# If both arguments are False, then print the tensor names and shapes in the checkpoint file.
chkp.print_tensors_in_checkpoint_file(checkpoint,
tensor_name='',
all_tensors=False,
all_tensor_names=True)
def test_dataSet(model_name, dataset_dir, process_name, batch_size):
print_tensors_in_checkpoint_file(models_path,None,False,True)
test_dataset = datasets.get_dataset(process_name, dataset_dir,
'test', batch_size=batch_size)
test_iterator = test_dataset.make_initializable_iterator()
test_images, test_labels = test_iterator.get_next()
labels = np.loadtxt(labels_filename, str, delimiter='\t')
with tf.name_scope("inputs"):
is_training = tf.placeholder(tf.bool)
images = tf.placeholder(
dtype=tf.float32, shape=[None, resize_height, resize_width, depths], name='inputs')
labels = tf.placeholder(dtype=tf.int32, shape=[None, class_nums], name='label')
with tf.name_scope("net"):
logits,endpoints = net.inference(inputs=images, num_classes=class_nums,
is_training=is_training, dropout_keep_prob=1.0)
# 将输出结果进行softmax分布,再求最大概率所属类别
with tf.name_scope('Output'):
score = tf.nn.softmax(logits,name='predict')
class_id = tf.argmax(score, 1)
correct_prediction = tf.equal(class_id, tf.argmax(labels, 1))
saver = tf.train.Saver()
init_op = [tf.global_variables_initializer(), tf.local_variables_initializer()]
layer5_mv = tf.get_default_graph().get_tensor_by_name('layer4/conv/conv_2/batch_normalization/moving_mean:0')
layer5_va = tf.get_default_graph().get_tensor_by_name('layer4/conv/conv_2/batch_normalization/moving_variance:0')
with tf.Session() as sess:
sess.run(init_op)
saver.restore(sess, model_name)
sess.run(test_iterator.initializer)
num_correct, num_samples = 0, 0
while True:
try:
test_batch_images, test_batch_labels \
= sess.run([test_images, test_labels])
score_val, correct_pred,class_index \
= sess.run([ score,correct_prediction,class_id],
feed_dict={is_training: False,
images: test_batch_images,
labels: test_batch_labels})
mv_val, va_val = sess.run([ layer5_mv,layer5_va],
feed_dict={is_training: False,
images: test_batch_images,
labels: test_batch_labels})
num_correct += correct_pred.sum()
num_samples += correct_pred.shape[0]
# print("mv{0}".format(mv_val))
# print("va{0}".format(va_val))
# print(str(score_val)+" " + str(class_index))
except tf.errors.OutOfRangeError:
break
acc = float(num_correct) / num_samples
return acc
def main():
# ckpt_fn = os.path.join('../official-pretrained', 'model.ckpt')
ckpt_fn = tf.train.latest_checkpoint('../models/8x8')
# print all tensors in checkpoint file
chkp.print_tensors_in_checkpoint_file(ckpt_fn,
tensor_name='',
all_tensors=False)
return
def check_vars_of_ckpt(args, name):
#We first take in the checkpoint name and directory for either digits, drums or piano
ckpt_name = os.path.join(args.model_path, args.sname1, name + '.ckpt')
#In-built command for printing only the names of the variables contained within the checkpoint file
#This command can also be used to print the name of a specific tensor
print_tensors_in_checkpoint_file(ckpt_name,
all_tensors=True,
tensor_name='')
def inspect_checkpoint(inspect_checkpoint_path):
""" Print nodes in checkpoint"""
chkp.print_tensors_in_checkpoint_file(
file_name=inspect_checkpoint_path,
tensor_name=None, # 如果为None,则默认为ckpt里的所有变量
all_tensors=
False, # bool 是否打印所有的tensor，这里打印出的是tensor的值，一般不推荐这里设置为False
all_tensor_names=False
) # bool 是否console.WriteLine(files1[i]);打印所有的tensor的name
def restore(self, res_file):
from tensorflow.python.tools.inspect_checkpoint import print_tensors_in_checkpoint_file
print_tensors_in_checkpoint_file(res_file, None, False)
with self.graph.as_default():
for v in tf.global_variables():
print(v)
if self.saver is None:
self.saver = tf.train.Saver(tf.global_variables())
self.saver.restore(self.sess, res_file)
def dump_checkpoint_file(file):
reader = tf.train.NewCheckpointReader(file)
var_to_shape_map = reader.get_variable_to_shape_map()
print('file: %s' % file)
print('shape_map: %s' % var_to_shape_map)
print_tensors_in_checkpoint_file(file_name=file,
tensor_name='',
all_tensors=True)
print('\n')
def eval_once(saver, summary_writer, batch_predictions, batch_labels,
summary_op):
"""Run Eval once.
Args:
saver: Saver.
summary_writer: Summary writer.
loss: From the prediction
summary_op: Summary op.
"""
# Get the loss of mean of batch images
with tf.variable_scope("mean_loss_eval"):
mean_loss = comet_dnn.loss(batch_predictions, batch_labels)
# Get physics prediction
predictions = tf.squeeze(batch_predictions)
residual = predictions - batch_labels[:, 0]
# Add summary
tf.summary.histogram('/residual', residual)
# define global number of images
eval_index = 0
# It seems like by default it is getting the latest check point
ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir)
# Get path to the check point
path_to_ckpt = ckpt.model_checkpoint_path
global_step = path_to_ckpt.split('/')[-1].split('-')[-1]
eval_index = int(global_step)
with tf.Session() as sess:
# Check if we have the checkpoint and path exist
if ckpt and path_to_ckpt:
# Restores from checkpoint
saver.restore(sess, path_to_ckpt)
# Assuming model_checkpoint_path looks something like:
# /my-favorite-path/comet_dnn_train/model.ckpt-0,
# extract global_step from it.
print_tensors_in_checkpoint_file(file_name=path_to_ckpt,
tensor_name="",
all_tensors="",
all_tensor_names="")
# Open summary
print(eval_index)
summary = tf.Summary()
summary.ParseFromString(sess.run(summary_op))
# Add value to summary
loss = sess.run(mean_loss)
summary.value.add(tag='pt_residual @ 1', simple_value=loss)
#print("%d mean_loss %f " % (eval_index,loss))
# Add summary
summary_writer.add_summary(summary, eval_index)
eval_index = eval_index + 1
else:
print('No checkpoint file found')
return
def get_vars():
"""
get all variable in checkpoint path
Returns:
None
"""
latest_ckp = tf.train.latest_checkpoint(os.path.join('../models', '117M'))
print_tensors_in_checkpoint_file(latest_ckp,
all_tensors=True,
tensor_name='')
def get_ckpt_vars(path, path_is_folder=True, name='', with_data=False):
if path_is_folder: # pick the latest checkpoint
path = tf.train.latest_checkpoint(path)
with io.StringIO() as buf, redirect_stdout(buf):
inspect_checkpoint.print_tensors_in_checkpoint_file(
path, name, with_data)
entries = buf.getvalue().split('\n')
entries = filter(None, entries)
entries = [e.split(' ') for e in entries]
return entries
def print_tensors(checkfile):
print_tensors_in_checkpoint_file(checkfile,
all_tensors=True,
tensor_name='')
reader = pywrap_tensorflow.NewCheckpointReader(checkfile)
emb = reader.get_tensor("word_embedding/w")
print("Embedding")
print(emb)
print(emb.shape)
def main(_):
from tensorflow.python.tools.inspect_checkpoint import \
print_tensors_in_checkpoint_file
from slim_start import get_starter
name = FLAGS.name
starter = get_starter(name)
latest_ckp = starter.get_checkpoint()
print_tensors_in_checkpoint_file(latest_ckp,
tensor_name='',
all_tensors=False,
all_tensor_names=True)
def test_mobilenet_v1():
batch_size = 5
height, width = 224, 224
num_classes = 1001
img = cv2.imread('laska.png')
img_resize = cv2.resize(img, (height, width))
img_rgb = cv2.cvtColor(img_resize, cv2.COLOR_BGR2RGB).astype(np.float32)
# input_mat = np.random.rand(batch_size, height, width, 3).astype(np.float32)
input_mat = np.zeros(shape=(batch_size, height, width, 3),
dtype=np.float32)
# input_mat[0, :, :, :] = (img_rgb - 127) / 127.0
input_mat[0, :, :, :] = img_rgb / 255.0
print('input_mat[0]:', input_mat[0, :, :, :])
print('input_mat[1]:', input_mat[1, :, :, :])
# inputs = tf.random_uniform((batch_size, height, width, 3), name='input')
inputs = tf.convert_to_tensor(input_mat, name='input', dtype=tf.float32)
arg_scope = mobilenet_v1.mobilenet_v1_arg_scope(is_training=False,
weight_decay=0.0)
with slim.arg_scope(arg_scope):
logits, end_points = mobilenet_v1.mobilenet_v1(inputs,
num_classes,
is_training=False)
model_dir = '/Users/alexwang/data/mobilenet_v1_1.0_160'
checkpoint_path = os.path.join(model_dir, 'mobilenet_v1_1.0_160.ckpt')
print_tensors_in_checkpoint_file(checkpoint_path, None, False)
saver = tf.train.Saver()
# print all node in graph
# for tensor in tf.get_default_graph().as_graph_def().node:
# print(tensor.name)
input_get = tf.get_default_graph().get_tensor_by_name('input:0')
print('shape of input_get:{}'.format(input_get.shape))
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
predict = sess.run([end_points['Predictions']])
print(predict)
classes = np.argmax(predict[0], axis=1)
print(classes)
saver.restore(sess, checkpoint_path)
predict = sess.run([end_points['Predictions']])[0]
print('predict:', predict)
classes = np.argsort(predict, axis=1)
for predict_result in classes:
# print(predict_result[::-1][0:5])
class_names = [(label_names[i], predict[0][i])
for i in predict_result[::-1][0:5]]
print(class_names)
def estimate(estimate_x):
""" 预估
:param estimate_x:
:return: 无
"""
saver = tf.train.Saver()
print(estimate_x)
# 加载最新模型
print_tensors_in_checkpoint_file(FLAGS.model_file_dir, None, True)
with tf.Session() as sess:
saver.restore(sess, FLAGS.model_file_dir)
print("z=", sess.run(z, feed_dict={x: estimate_x}))
# 加载检查点
with tf.Session() as sess:
ckpt = tf.train.get_checkpoint_state(os.path.abspath(FLAGS.model_dir))
if ckpt and ckpt.all_model_checkpoint_paths: # 最新模型为：ckpt.model_checkpoint_path
print_tensors_in_checkpoint_file(ckpt.all_model_checkpoint_paths[0], None, True)
saver.restore(sess, ckpt.all_model_checkpoint_paths[0])
print("z=", sess.run(z, feed_dict={x: estimate_x}))
def return_variables(self):
chkp.print_tensors_in_checkpoint_file(self.variables_path + self.name ,tensor_name='Weights', all_tensors=True)
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# pylint: disable=C0103,C0111
import argparse
import os
from tensorflow.python.tools import inspect_checkpoint as chkp
parser = argparse.ArgumentParser(description="Print data in tensorflow checkpoint file.")
parser.add_argument("global_step", help="global step of the checkpoint file to print")
parser.add_argument("-n", metavar="tensor_name", default="",
help="name of the tensor in the checkpoint file to print "
"or print all tensors if not provided.")
args = parser.parse_args()
file_name = os.path.join("logs", "solver-net-{}".format(args.global_step))
tensor_name = args.n
all_tensors = True if args.n == "" else False
chkp.print_tensors_in_checkpoint_file(file_name, tensor_name=tensor_name, all_tensors=all_tensors)
PATH_TO_MODEL = os.path.join(PATH_TO_CKPT, MODEL_VERSION)
PATH_TO_WEIGHTS = 'numpy_weights'
PATH_TO_CONV1 = os.path.join(PATH_TO_WEIGHTS, 'conv1.weights.npz')
PATH_TO_CONV1_BIAS = os.path.join(PATH_TO_WEIGHTS, 'conv1.bias.npz')
PATH_TO_PRIMARY_CAPS = os.path.join(PATH_TO_WEIGHTS, 'primary_caps.weights.npz')
PATH_TO_PRIMARY_CAPS_BIAS = os.path.join(PATH_TO_WEIGHTS, 'primary_caps.bias.npz')
PATH_TO_DIGIT_CAPS = os.path.join(PATH_TO_WEIGHTS, 'digit_caps.weights.npz')
PATH_TO_FULLY_CONNECTED1 = os.path.join(PATH_TO_WEIGHTS, 'fully_connected1.weights.npz')
PATH_TO_FULLY_CONNECTED2 = os.path.join(PATH_TO_WEIGHTS, 'fully_connected2.weights.npz')
PATH_TO_FULLY_CONNECTED3 = os.path.join(PATH_TO_WEIGHTS, 'fully_connected3.weights.npz')
PATH_TO_FULLY_CONNECTED1_BIAS = os.path.join(PATH_TO_WEIGHTS, 'fully_connected1.bias.npz')
PATH_TO_FULLY_CONNECTED2_BIAS = os.path.join(PATH_TO_WEIGHTS, 'fully_connected2.bias.npz')
PATH_TO_FULLY_CONNECTED3_BIAS = os.path.join(PATH_TO_WEIGHTS, 'fully_connected3.bias.npz')
print_tensors_in_checkpoint_file(file_name=PATH_TO_MODEL, tensor_name='', all_tensors=False)
sess = tf.Session()
new_saver = tf.train.import_meta_graph(PATH_TO_MODEL + '.meta')
new_saver.restore(sess, tf.train.latest_checkpoint(PATH_TO_CKPT))
# Conv1_layer/Conv/weights (DT_FLOAT) [9,9,1,256]
weights = sess.run('Conv1_layer/Conv/weights:0')
with open(PATH_TO_CONV1, 'wb') as outfile:
np.save(outfile, weights)
# Conv1_layer/Conv/biases (DT_FLOAT) [256]
bias = sess.run('Conv1_layer/Conv/biases:0')
with open(PATH_TO_CONV1_BIAS, 'wb') as outfile:
np.save(outfile, bias)
