def test_op(self): """Tests merged summary with different types of data.""" name = "my_mesh" tensor_data = test_utils.get_random_mesh( 100, add_faces=True, add_colors=True ) config_dict = {"foo": 1} with tf.compat.v1.Graph().as_default(): tensor_summary = summary.op( name, tensor_data.vertices, faces=tensor_data.faces, colors=tensor_data.colors, config_dict=config_dict, ) with self.test_session() as sess: proto = self.pb_via_op(tensor_summary) self.verify_proto(proto, name) plugin_metadata = metadata.parse_plugin_metadata( proto.value[0].metadata.plugin_data.content ) self.assertEqual( json.dumps(config_dict, sort_keys=True), plugin_metadata.json_config, )
def run(): """Runs session with a mesh summary.""" # Mesh summaries only work on TensorFlow 1.x. if int(tf.__version__.split(".")[0]) > 1: raise ImportError("TensorFlow 1.x is required to run this demo.") # Flag mesh_path is required. if FLAGS.mesh_path is None: raise ValueError( "Flag --mesh_path is required and must contain path to PLY file." ) # Camera and scene configuration. config_dict = {"camera": {"cls": "PerspectiveCamera", "fov": 75}} # Read sample PLY file. vertices, colors, faces = demo_utils.read_ascii_ply(FLAGS.mesh_path) # Add batch dimension. vertices = np.expand_dims(vertices, 0) faces = np.expand_dims(faces, 0) colors = np.expand_dims(colors, 0) # Create placeholders for tensors representing the mesh. step = tf.placeholder(tf.int32, ()) vertices_tensor = tf.placeholder(tf.float32, vertices.shape) faces_tensor = tf.placeholder(tf.int32, faces.shape) colors_tensor = tf.placeholder(tf.int32, colors.shape) # Change colors over time. t = tf.cast(step, tf.float32) / _MAX_STEPS transformed_colors = t * (255 - colors) + (1 - t) * colors meshes_summary = mesh_summary.op( "mesh_color_tensor", vertices=vertices_tensor, faces=faces_tensor, colors=transformed_colors, config_dict=config_dict, ) # Create summary writer and session. writer = tf.summary.FileWriter(FLAGS.logdir) sess = tf.Session() for i in range(_MAX_STEPS): summary = sess.run( meshes_summary, feed_dict={ vertices_tensor: vertices, faces_tensor: faces, colors_tensor: colors, step: i, }, ) writer.add_summary(summary, global_step=i)
def add_summary(self, data, phase, data_type, name): if(data_type == 'scalar'): self.tensorboard_ops[phase].append(tf.summary.scalar(name, data)) log_message('module_base', '---Scalar {} added to tensorboard.---'.format(name)) elif(data_type == 'image'): self.tensorboard_ops[phase].append(tf.summary.image(name, data)) log_message('module_base', '---Image {} added to tensorboard.---'.format(name)) elif(data_type == 'voxel'): #dereferenced packed data with "**" self.tensorboard_ops[phase].append(mesh_summary.op(name, **data))#vertices = data['vertices'], config_dict = data['config_dict'])) log_message('module_base', '---Voxel {} added to tensorboard.---'.format(name)) else: raise NotImplementedError()
def mesh_summary(self, tag, vertices, faces=None, colors=None, step=0): """Log a list of mesh images.""" if colors is None: colors = tf.constant(np.zeros_like(vertices)) vertices = tf.constant(vertices) if faces is not None: faces = tf.constant(faces) meshes_summares=[] for i in range(vertices.shape[0]): meshes_summares.append(meshsummary.op( tag, vertices=vertices, faces=faces, colors=colors, config_dict=self.config_dict)) sess = tf.Session() summaries = sess.run(meshes_summares) for summary in summaries: self.writer.add_summary(summary, step)
def setUp(self): # We use numpy.random to generate meshes. We seed to avoid non-determinism # in this test. np.random.seed(17) # Log dir to save temp events into. self.log_dir = self.get_temp_dir() # Create mesh summary. with tf.compat.v1.Graph().as_default(): tf_placeholder = tf.compat.v1.placeholder sess = tf.compat.v1.Session() point_cloud = test_utils.get_random_mesh(1000) point_cloud_vertices = tf_placeholder(tf.float32, point_cloud.vertices.shape) mesh_no_color = test_utils.get_random_mesh(2000, add_faces=True) mesh_no_color_extended = test_utils.get_random_mesh(2500, add_faces=True) mesh_no_color_vertices = tf_placeholder(tf.float32, [1, None, 3]) mesh_no_color_faces = tf_placeholder(tf.int32, [1, None, 3]) mesh_color = test_utils.get_random_mesh(3000, add_faces=True, add_colors=True) mesh_color_vertices = tf_placeholder(tf.float32, mesh_color.vertices.shape) mesh_color_faces = tf_placeholder(tf.int32, mesh_color.faces.shape) mesh_color_colors = tf_placeholder(tf.uint8, mesh_color.colors.shape) self.data = [ point_cloud, mesh_no_color, mesh_no_color_extended, mesh_color ] # In case when name is present and display_name is not, we will reuse name # as display_name. Summaries below intended to test both cases. self.names = ["point_cloud", "mesh_no_color", "mesh_color"] summary.op(self.names[0], point_cloud_vertices, description="just point cloud") summary.op(self.names[1], mesh_no_color_vertices, faces=mesh_no_color_faces, display_name="name_to_display_in_ui", description="beautiful mesh in grayscale") summary.op(self.names[2], mesh_color_vertices, faces=mesh_color_faces, colors=mesh_color_colors, description="mesh with random colors") merged_summary_op = tf.compat.v1.summary.merge_all() self.runs = ["bar"] self.steps = 20 bar_directory = os.path.join(self.log_dir, self.runs[0]) with tensorboard_test_util.FileWriterCache.get( bar_directory) as writer: writer.add_graph(sess.graph) for step in range(self.steps): # Alternate between two random meshes with different number of # vertices. no_color = mesh_no_color if step % 2 == 0 else mesh_no_color_extended with patch.object(time, 'time', return_value=step): writer.add_summary(sess.run(merged_summary_op, feed_dict={ point_cloud_vertices: point_cloud.vertices, mesh_no_color_vertices: no_color.vertices, mesh_no_color_faces: no_color.faces, mesh_color_vertices: mesh_color.vertices, mesh_color_faces: mesh_color.faces, mesh_color_colors: mesh_color.colors, }), global_step=step) # Start a server that will receive requests. self.multiplexer = event_multiplexer.EventMultiplexer({ "bar": bar_directory, }) self.context = base_plugin.TBContext(logdir=self.log_dir, multiplexer=self.multiplexer) self.plugin = mesh_plugin.MeshPlugin(self.context) # Wait until after plugin construction to reload the multiplexer because the # plugin caches data from the multiplexer upon construction and this affects # logic tested later down. # TODO(https://github.com/tensorflow/tensorboard/issues/2579): Eliminate the # caching of data at construction time and move this Reload() up to just # after the multiplexer is created. self.multiplexer.Reload() wsgi_app = application.TensorBoardWSGI([self.plugin]) self.server = werkzeug_test.Client(wsgi_app, wrappers.BaseResponse) self.routes = self.plugin.get_plugin_apps()
'fov': 75 }, 'lights': [{ 'cls': 'AmbientLight', 'color': '#ffffff', 'intensity': 0.75, }, { 'cls': 'DirectionalLight', 'color': '#ffffff', 'intensity': 0.75, 'position': [0, -1, 2], }], 'material': { 'cls': 'MeshStandardMaterial', 'roughness': 1, 'metalness': 0 } } log_dir = '/home/yu/PycharmProjects/feastnet/Direction/data' # vertices_tensor = tf.placeholder(tf.float32, [1,None,3]) sess = tf.Session() for i in range(3): feed_dict, epoch_end = rf.get_feed() vertices_tensor = tf.expand_dims(feed_dict['input'], 0) print(vertices_tensor.shape) meshes_summary = mesh_summary.op('mesh_color_tensor', vertices=vertices_tensor, config_dict=config_dict) writer = tf.summary.FileWriter(log_dir) writer.add_summary(meshes_summary)
model.build_model() # Summary the variables ptraps = tf.summary.scalar('Particle Loss', model.train_particleLoss) ptraprs = tf.summary.scalar('Particle Reconstruct Loss', model.train_error) ptrapss = tf.summary.scalar('Particle Simulation Loss', model.train_particleSimLoss) vals = tf.summary.scalar('Validation Loss', model.val_particleLoss, collections=None) ptrapfs = tf.summary.scalar('Particle HQPool Loss', model.train_HQPLoss) ptrapps = tf.summary.scalar('Particle Pool Align Loss', model.train_PALoss) from tensorboard.plugins.mesh import summary as mesh_summary pc_rec = mesh_summary.op('Reconstruction', vertices=tf.expand_dims(model.val_rec[0, :, :], 0), colors=tf.constant([[[109, 131, 70]]], shape=[1, args.voxel_size, 3])) pc_gt = mesh_summary.op('Ground truth', vertices=tf.expand_dims(model.val_gt[0, :, :], 0), colors=tf.constant([[[0, 154, 214]]], shape=[1, args.voxel_size, 3])) merged_train = tf.summary.merge([ptraps, ptraprs, ptrapss, ptrapfs, ptrapps]) merged_val = tf.summary.merge([vals]) merged_mesh = tf.summary.merge([pc_rec, pc_gt]) # merged_train = tf.summary.merge_all() # Create session config = tf.ConfigProto() config.gpu_options.allow_growth = True sess = tf.Session(config=config)
def training(sess): print('load data from: ', flags.data_dir) if 'mnist' in flags.data_dir: train_data = read_mnist_data(os.path.join(flags.data_dir, 'mnist_train.csv')) valid_data = read_mnist_data(os.path.join(flags.data_dir, 'mnist_test.csv')) elif 'modelnet40' in flags.data_dir: train_data, valid_data, _ = read_modelnet40_data(flags.data_dir, flags.num_pt) else: print('data path unrecognised!') return batch_size = flags.batch_size model = network(sess, flags) init_temp = 1. final_temp = 0.01 decay = (final_temp/init_temp)**(1./float(flags.max_epoch)) trainable_var = tf.trainable_variables() part_var = [] print('Trainable var list: ') for idx, v in enumerate(trainable_var): print(' var {:3}: {:20} {}'.format(idx, str(v.get_shape()), v.name)) init_op = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) sess.run(init_op) model_dir = os.path.join(flags.model_dir, flags.model_name) if not os.path.exists(model_dir): os.makedirs(model_dir) saver = tf.train.Saver(max_to_keep=1, save_relative_paths=True) if flags.load_model: checkpoint = tf.train.get_checkpoint_state(model_dir) if checkpoint and checkpoint.model_checkpoint_path: saver.restore(sess, checkpoint.model_checkpoint_path) print('model loaded: ', checkpoint.model_checkpoint_path ) else: print('model not found') summary_writer = tf.summary.FileWriter(model_dir, sess.graph) xyz_ph = tf.placeholder(tf.float32, shape=[flags.batch_size, flags.num_pt, 3], name='xyz_ph') rgb_ph = tf.placeholder(tf.float32, shape=[flags.batch_size, flags.num_pt, 3], name='rgb_ph') point_summary = mesh_summary.op('point_cloud', vertices=xyz_ph, colors=rgb_ph) train_acc_ph = tf.placeholder(tf.float32, shape=[], name='train_acc_ph') train_acc_summary = tf.summary.scalar('train_acc', train_acc_ph) test_acc_ph = tf.placeholder(tf.float32, shape=[], name='test_acc_ph') test_acc_summary = tf.summary.scalar('test_acc', test_acc_ph) temp_summary = tf.summary.scalar('temperature', model.t) merged = tf.summary.merge_all() start_time = time.time() print('start training') temp = init_temp for epoch in range(flags.max_epoch): # training loss_list = [] acc_list = [] opt_time = [] end_flag = False random.shuffle(train_data) bar = progressbar.ProgressBar(maxval=len(train_data)/batch_size+len(valid_data)/batch_size, \ widgets=[progressbar.Bar('=', '[', ']'), ' ', progressbar.Percentage()]) all_t = 0 for t in range(int(len(train_data)/batch_size)): batch_data = get_a_batch(train_data, t*batch_size, batch_size) acc, loss, _ = model.train(batch_data, temp) loss_list.append(loss) acc_list.append(acc) all_t += 1 bar.update(all_t) loss_train = np.mean(loss_list) acc_train = np.mean(acc_list) # validating loss_list = [] acc_list = [] end_flag = False pos = 0 for t in range(int(len(valid_data)/batch_size)): batch_data = get_a_batch(valid_data, t*batch_size, batch_size) acc, loss, sampled_points, score = model.validate(batch_data, temp) loss_list.append(loss) acc_list.append(acc) all_t += 1 bar.update(all_t) bar.finish() loss_valid = np.mean(loss_list) acc_valid = np.mean(acc_list) points_rgb = (np.stack([score, np.zeros_like(score), np.zeros_like(score)], axis=2)*255).astype(int) points_xyz = batch_data[0] info_train = '| Epoch:{:3d}'.format(epoch) + \ '| TrainLoss: {:2.5f}'.format(loss_train) + \ '| TestLoss: {:2.5f}'.format(loss_valid) + \ '| TrainAcc: {:2.5f}'.format(acc_train) + \ '| TestAcc: {:2.5f}'.format(acc_valid) + \ '| Time(min): {:2.1f}'.format((time.time() - start_time)/60.) + \ '| Temp: {:1.5f}'.format(temp) print(info_train) summary = sess.run(merged, feed_dict={xyz_ph: points_xyz, rgb_ph: points_rgb, train_acc_ph: acc_train, test_acc_ph: acc_valid, model.t: temp}) summary_writer.add_summary(summary, epoch) if flags.save_model and epoch == flags.max_epoch-1: saver.save(sess, os.path.join(model_dir, 'network') , global_step=epoch) if flags.sample_mode in ['normal', 'determine', 'concrete']: temp *= decay
def setUp(self): # We use numpy.random to generate meshes. We seed to avoid non-determinism # in this test. np.random.seed(17) # Log dir to save temp events into. self.log_dir = self.get_temp_dir() # Create mesh summary. tf.compat.v1.reset_default_graph() sess = tf.compat.v1.Session() point_cloud = test_utils.get_random_mesh(1000) point_cloud_vertices = tf.compat.v1.placeholder(tf.float32, point_cloud.vertices.shape) mesh_no_color = test_utils.get_random_mesh(2000, add_faces=True) mesh_no_color_vertices = tf.compat.v1.placeholder( tf.float32, mesh_no_color.vertices.shape) mesh_no_color_faces = tf.compat.v1.placeholder(tf.int32, mesh_no_color.faces.shape) mesh_color = test_utils.get_random_mesh( 3000, add_faces=True, add_colors=True) mesh_color_vertices = tf.compat.v1.placeholder(tf.float32, mesh_color.vertices.shape) mesh_color_faces = tf.compat.v1.placeholder(tf.int32, mesh_color.faces.shape) mesh_color_colors = tf.compat.v1.placeholder(tf.uint8, mesh_color.colors.shape) self.data = [point_cloud, mesh_no_color, mesh_color] # In case when name is present and display_name is not, we will reuse name # as display_name. Summaries below intended to test both cases. self.names = ["point_cloud", "mesh_no_color", "mesh_color"] summary.op( self.names[0], point_cloud_vertices, description="just point cloud") summary.op( self.names[1], mesh_no_color_vertices, faces=mesh_no_color_faces, display_name="name_to_display_in_ui", description="beautiful mesh in grayscale") summary.op( self.names[2], mesh_color_vertices, faces=mesh_color_faces, colors=mesh_color_colors, description="mesh with random colors") merged_summary_op = tf.compat.v1.summary.merge_all() self.runs = ["bar"] self.steps = 20 bar_directory = os.path.join(self.log_dir, self.runs[0]) with tensorboard_test_util.FileWriterCache.get(bar_directory) as writer: writer.add_graph(sess.graph) for step in range(self.steps): writer.add_summary( sess.run( merged_summary_op, feed_dict={ point_cloud_vertices: point_cloud.vertices, mesh_no_color_vertices: mesh_no_color.vertices, mesh_no_color_faces: mesh_no_color.faces, mesh_color_vertices: mesh_color.vertices, mesh_color_faces: mesh_color.faces, mesh_color_colors: mesh_color.colors, }), global_step=step) # Start a server that will receive requests. self.multiplexer = event_multiplexer.EventMultiplexer({ "bar": bar_directory, }) self.context = base_plugin.TBContext( logdir=self.log_dir, multiplexer=self.multiplexer) self.plugin = mesh_plugin.MeshPlugin(self.context) wsgi_app = application.TensorBoardWSGIApp( self.log_dir, [self.plugin], self.multiplexer, reload_interval=0, path_prefix="") self.server = werkzeug_test.Client(wsgi_app, wrappers.BaseResponse) self.multiplexer.Reload() self.routes = self.plugin.get_plugin_apps()
points_f = result points = np.concatenate([points_v, points_f], axis=1) colors_v = np.ones_like(points_v) * [0, 0, 255] colors_f = np.ones_like(points_f) * [0, 255, 0] colors = np.concatenate([colors_v, colors_f], axis=1) # %% tf.compat.v1.disable_eager_execution() points_tensor = tf.compat.v1.placeholder(tf.float32, points.shape) colors_tensor = tf.compat.v1.placeholder(tf.int32, colors.shape) summary = mesh_summary.op( 'v_color_tensor', vertices=points_tensor, colors=colors_tensor, config_dict=config_dict ) # Create summary writer and session. writer = tf.compat.v1.summary.FileWriter(log_dir) sess = tf.compat.v1.Session() # %% summaries = sess.run([summary], feed_dict={ points_tensor: points, colors_tensor: colors, }) # Save summaries. for summary in summaries: