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 = tf1.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='')
config = tf1.ConfigProto()
# device_count = {'CPU': 0}
config.gpu_options.allow_growth = True
self.sess = tf1.Session(graph=self.graph, config=config)
def _evaluate_graph_def(self, graph_def, inputs, outputs, input_data):
"""Evaluates the GraphDef using Sessions."""
with tf.Graph().as_default() as graph:
tf.import_graph_def(graph_def, name="")
sess = tf.compat.v1.Session(graph=graph)
input_tensors = self._get_tensors(sess, inputs)
output_tensors = self._get_tensors(sess, outputs)
return sess.run(output_tensors,
feed_dict=dict(zip(input_tensors, input_data)))
def load_graph(model_file):
graph = tf.Graph()
graph_def = tf.GraphDef()
with open(model_file, "rb") as f:
graph_def.ParseFromString(f.read())
with graph.as_default():
tf.import_graph_def(graph_def)
return graph
def main(_):
# What model to download.
MODEL_NAME = FLAGS.model_name
# Path to frozen detection graph. This is the actual model that is used for the object detection.
PATH_TO_FROZEN_GRAPH = 'pretrained/' + MODEL_NAME + '/frozen_inference_graph.pb'
# List of the strings that is used to add correct label for each box.
PATH_TO_LABELS = os.path.join('data', FLAGS.data_label)
ACTIVITY = FLAGS.acivity
# PATH_TO_TEST_IMAGES_DIR = FLAGS.path_to_test_images_dir%ACTIVITY
BATCH = FLAGS.batch
outputfolder = FLAGS.output_dir % ACTIVITY
if not os.path.exists(outputfolder):
os.makedirs(outputfolder)
detection_graph = tf.Graph()
with detection_graph.as_default():
od_graph_def = tf.compat.v1.GraphDef()
with gfile.GFile(PATH_TO_FROZEN_GRAPH, 'rb') as fid:
serialized_graph = fid.read()
od_graph_def.ParseFromString(serialized_graph)
tf.import_graph_def(od_graph_def, name='')
category_index = label_map_util.create_category_index_from_labelmap(
PATH_TO_LABELS, use_display_name=True)
activity = 'swing'
numpy_dir = '/media/felicia/Data/object_detection/data/%s/' % activity
numpy_name = 'image_bbgame_swing'
len_num_shards = 6
# Size, in inches, of the output images.
for i in range(len_num_shards):
valid_boxes = []
valid_scores = []
valid_classes = []
numpy_path = os.path.join(
numpy_dir,
'%s-%s-of-%s.npy' % (numpy_name, str(i), str(len_num_shards)))
logging.info('Loading %s', numpy_path)
numpy_dict = np.load(numpy_path, allow_pickle=True)
numpy_dict = numpy_dict.item()
images = numpy_dict['images']
labels = numpy_dict['activity']
steps = numpy_dict['steps']
vd_names = numpy_dict['videos']
nbatch = len(images) // BATCH + (1 if len(images) % BATCH > 0 else 0)
for j in tqdm(range(nbatch)):
idx_st = j * BATCH
idx_ed = (j + 1) * BATCH if (j + 1) * BATCH < len(images) else len(
images)
image_batch = images[idx_st:idx_ed] # B*H*W*C
output_dict = run_inference_for_minibatch_images(
image_batch, detection_graph)
minibatch_boxes, minibatch_scores, minibatch_classes = valid_boxes_on_minibatch_images(
output_dict['detection_boxes'],
output_dict['detection_classes'],
output_dict['detection_scores'],
max_boxes,
min_score,
selected_class=1)
valid_boxes += minibatch_boxes
valid_scores += minibatch_scores
valid_classes += minibatch_classes
valid_output = {
'boxes': valid_boxes,
'scores': valid_scores,
'classes': valid_classes
}
output_filename = os.path.join(
outputfolder,
'%s-%s-of-%s.npy' % (FLAGS.name, str(i), str(len_num_shards)))
with open(output_filename, 'wb') as file:
np.save(file, valid_output)
def main():
#download google pre-trained neural network
local_zip_file = 'inception5h.zip'
if not os.path.exists(local_zip_file):
#download
model_url = urllib.request.urlopen(url)
with open(local_zip_file, 'wb') as output:
output.write(model_url.read())
#extract
with zipfile.ZipFile(local_zip_file, 'r') as zip_ref:
zip_ref.extractall(data_dir)
model_fn = 'tensorflow_inseption_graph.pb'
#Creating tf session and loading the model
graph = tf.Graph()
sess = tfc.InteractiveSession(graph=graph)
with tfc.gfile.FastGFile((local_zip_file), 'rb') as f:
graph_def = tf.io.gfile.GFile()
graph_def.ParseFromString(f.read())
t_input = tf.placeholder(np.float32, name='input') #define input tensor
imagenet_mean = 117.0
t_preprocessed = tf.expand_dims(t_input - imagenet_mean, 0)
tf.import_graph_def(graph_def, {'input': t_preprocessed})
layers = [
op.name for op in graph.get_operations()
if op.type == 'Cony2D' and 'import/' in op.name
]
feature_nums = [
int(graph.get_tensor_by_name(model_name + ':0').get_shape()[-1])
for name in layers
]
print('Number of layers: ', len(layers))
print('Total numbers of feature channels:', sum(feature_nums))
def render_deepdream(t_obj,
img0=img_noise,
iter_n=10,
step=1.5,
octave_n=4,
octave_scale=1.4):
t_score = tf.reduce_mean(t_obj) #defining optimization objective
t_grad = tf.gradients(t_score, t_input)[0]
#split the image into a number of octaves
img = img0
octaves = []
for _ in range(octave_n - 1):
hw = img.shape[:2]
lo = resize(img, np.int32(np.float32(hw) / octave_scale))
hi = img - resize(low, hw)
img = lo
octaves.append(hi)
#generate details octave by octave
for octave in range(octave_n):
if octave > 0:
hi = octaves[-octave]
img = resize(img, hi.shape[:2]) + hi
for _ in range(iter_n):
g = calc_grad_tiled(img, t_grad)
img += g * (step / (np.abs(g).mean() + 1e-7))
#output deep dreamed image
showarray(img / 255.0)
#Pick a layer to enchance my image
layer = 'mixed4d_3x3_bottleneck_pre_relu'
channel = 139
img0 = PIL.Image.open('image.jpg')
img0 = np.float32(img0)
#Apply gradient ascent to the layer
render_deepdream(tf.square(T('mixed4c')), img0)
