def init(f): global LOG_FOUT global MODEL global MODEL_CONF global TRAIN_FILES global TEST_FILES # IMPORT network module module = importlib.import_module(f['model']) MODEL = getattr(module, f['model']) MODEL_CONF = getattr(module, f['model'] + '_conf') MODEL_FILE = os.path.join(BASE_DIR, 'models', f['model'] + '.py') # MAKE log directory if not os.path.exists(f['log_dir']): os.mkdir(f['log_dir']) os.system('cp %s %s' % (MODEL_FILE, f['log_dir'])) # bkp of model def # CREATE log file LOG_FOUT = open(os.path.join(f['log_dir'], 'log_train.txt'), 'a') LOG_FOUT.write(dict2str(f)) # GET dataset files' list TRAIN_FILES = provider.getDataFiles( os.path.join(f['dataset_path'], 'train_files.txt')) TEST_FILES = provider.getDataFiles( os.path.join(f['dataset_path'], 'test_files.txt'))
def load_test_data(): """Load test data.""" cwd = Path(os.path.abspath(os.path.dirname(__file__))) data = cwd / 'data' hdf5_dir = (data / 'hdf5_data').as_posix() test_hdf5_dir = os.path.join(hdf5_dir, 'test') test_files = provider.getDataFiles( os.path.join(test_hdf5_dir, 'all_files.txt')) data_batch_list = [] label_batch_list = [] count = 0 for h5_filename in test_files: data_batch, label_batch = provider.load_h5(h5_filename) # data_batch = provider.jitter_point_cloud(data_batch) print(f'h5_filename = {h5_filename}') print(f'data_batch.shape = {data_batch.shape}') count += data_batch.shape[0] data_batch_list.append(data_batch) label_batch_list.append(label_batch) data_batches = np.concatenate(data_batch_list, 0) label_batches = np.concatenate(label_batch_list, 0) print(f'data_batches.shape = {data_batches.shape}') print(f'label_batches.shape = {label_batches.shape}') test_idxs = list(range(0, count)) print(f'len(test_idxs) = {len(test_idxs)}') test_data = data_batches[test_idxs, ...] test_label = label_batches[test_idxs] print( f'test_data.shape, test_label.shape = {test_data.shape}, {test_label.shape}' ) return test_data, test_label
def load_train_data(start, stop): cwd = Path(os.path.abspath(os.path.dirname(__file__))) data = cwd / 'data' hdf5_dir = (data / 'hdf5_data').as_posix() train_hdf5_dir = os.path.join(hdf5_dir, 'train') files = provider.getDataFiles(os.path.join(train_hdf5_dir, 'all_files.txt')) data_batch_list = [] label_batch_list = [] count = 0 for h5_filename in files[start:stop]: data_batch, label_batch = provider.load_h5(h5_filename) # data_batch = provider.jitter_point_cloud(data_batch) print(f'h5_filename = {h5_filename}') print(f'data_batch.shape = {data_batch.shape}') count += data_batch.shape[0] data_batch_list.append(data_batch) label_batch_list.append(label_batch) data_batches = np.concatenate(data_batch_list, 0) label_batches = np.concatenate(label_batch_list, 0) print(f'data_batches.shape = {data_batches.shape}') print(f'label_batches.shape = {label_batches.shape}') print(f'count = {count}') train_idxs = list(range(0, count)) train_data = data_batches[train_idxs, ...] train_label = label_batches[train_idxs] print( f'train_data.shape, train_label.shape = {train_data.shape}, {train_label.shape}' ) return train_data, train_label
def get_test_data(num_point=1024): print('get test num_point ', num_point) test_files = provider.getDataFiles( os.path.join(BASE_DIR, 'data/modelnet40_ply_hdf5_2048/test_files.txt')) print("test_file : {}".format(test_files)) data = (PlyDataset(filepath, num_point=num_point, augment=False) for filepath in test_files) return data
def get_test_dataset(num_point=1024): print('get test num_point ', num_point) test_files = provider.getDataFiles( os.path.join(BASE_DIR, 'data/modelnet40_ply_hdf5_2048/test_files.txt')) return ConcatenatedDataset( *(PlyDataset(filepath, num_point=num_point, augment=False) for filepath in test_files))
def __init__(self, train_test): all_files = provider.getDataFiles( 'indoor3d_sem_seg_hdf5_data/all_files.txt') room_filelist = [ line.rstrip() for line in open('indoor3d_sem_seg_hdf5_data/room_filelist.txt') ] self.data = [] self.label = [] for h5_filename in all_files: data_batch, label_batch = provider.loadDataFile(h5_filename) self.data.append(data_batch) self.label.append(label_batch) self.data = np.concatenate(self.data, 0) self.label = np.concatenate(self.label, 0) print(self.data.shape) print(self.label.shape) test_area = 'Area_' + str(6) train_idxs = [] test_idxs = [] for i, room_name in enumerate(room_filelist): if test_area in room_name: test_idxs.append(i) else: train_idxs.append(i) if train_test == "test": self.data = self.data[test_idxs, ...] self.label = self.label[test_idxs] else: self.data = self.data[train_idxs, ...] self.label = self.label[train_idxs] self.label = torch.tensor(self.label, dtype=torch.long)
def estimate(area): LOG_DIR = 'log{}'.format(area) num_classes = 13 file_path = "data/train_hdf5_file_list_woArea{}.txt".format(area) train_file_list = provider.getDataFiles(file_path) mean_ins_size = np.zeros(num_classes) ptsnum_in_gt = [[] for itmp in range(num_classes)] train_data = [] train_group = [] train_sem = [] for h5_filename in train_file_list: cur_data, cur_group, _, cur_sem = provider.loadDataFile_with_groupseglabel_stanfordindoor(h5_filename) cur_data = np.reshape(cur_data, [-1, cur_data.shape[-1]]) cur_group = np.reshape(cur_group, [-1]) cur_sem = np.reshape(cur_sem, [-1]) un = np.unique(cur_group) for ig, g in enumerate(un): tmp = (cur_group == g) sem_seg_g = int(stats.mode(cur_sem[tmp])[0]) ptsnum_in_gt[sem_seg_g].append(np.sum(tmp)) for idx in range(num_classes): mean_ins_size[idx] = np.mean(ptsnum_in_gt[idx]).astype(np.int) print(mean_ins_size) np.savetxt(os.path.join(LOG_DIR, 'mean_ins_size.txt'),mean_ins_size)
def get_data(): ALL_FILES = provider.getDataFiles( 'indoor3d_sem_seg_hdf5_data/all_files.txt') room_filelist = [ line.rstrip() for line in open('indoor3d_sem_seg_hdf5_data/room_filelist.txt') ] # Load ALL data data_batch_list = [] label_batch_list = [] for h5_filename in ALL_FILES: data_batch, label_batch = provider.loadDataFile(h5_filename) data_batch_list.append(data_batch) label_batch_list.append(label_batch) test_area = 'Area_' + str(FLAGS.test_area) train_idxs = [] test_idxs = [] for i, room_name in enumerate(room_filelist): if test_area in room_name: test_idxs.append(i) else: train_idxs.append(i) data_batches = np.concatenate(data_batch_list, 0) label_batches = np.concatenate(label_batch_list, 0) train_data = data_batches[train_idxs, ...] train_label = label_batches[train_idxs] test_data = data_batches[test_idxs, ...] test_label = label_batches[test_idxs] return train_data, train_label, test_data, test_label
def loadModelNet40(self): file_path_name = askopenfilenames() self.path_labelText.set(file_path_name[0].split('/')[-1]) self.display_count = 0 # ModelNet40 official train/test split TRAIN_FILES = provider.getDataFiles(file_path_name[0]) # Shuffle train files train_file_idxs = np.arange(0, len(TRAIN_FILES)) np.random.shuffle(train_file_idxs) for fn in range(len(TRAIN_FILES)): print("目前讀取的檔案是: %s" % (TRAIN_FILES[train_file_idxs[fn]], )) current_data, current_label = provider.loadDataFile( TRAIN_FILES[train_file_idxs[fn]]) current_data, current_label, _ = provider.shuffle_data( current_data, np.squeeze(current_label)) if fn == 0: point_cloud_collection = current_data else: point_cloud_collection = np.vstack( (point_cloud_collection, current_data)) self.POINT_CLOUD_SET_LIST = point_cloud_collection self.idxs = np.arange(0, len(self.POINT_CLOUD_SET_LIST)) print(self.idxs) np.random.shuffle(self.idxs) # Load model 進來後停止使用此button self.btn_loadModelNet40.configure(state='disabled') self.btn_loadMyOwnData.configure(state='normal') self.Confirm_btn.configure(state='normal') self.Confirm_btn_own_data.configure(state='disabled')
def load_data(test_area=6): # 读取点云数据 data_batch_list = [] label_batch_list = [] all_files = provider.getDataFiles(hyper_parameter.ALL_FILES_PATH) for h5_filename in all_files: file_path = provider.getPath(hyper_parameter.DATASET_PATH, h5_filename) data_batch, label_batch = provider.loadDataFile(file_path) data_batch_list.append(data_batch) label_batch_list.append(label_batch) data_batches = np.concatenate(data_batch_list, 0) label_batches = np.concatenate(label_batch_list, 0) # 划分训练集测试集 room_filelist_path = provider.getPath(hyper_parameter.DATASET_PATH, hyper_parameter.ROOM_FILELIST_PATH) room_filelist = provider.getDataFiles(room_filelist_path) test_area = 'Area_' + str(test_area) train_idxs = [] test_idxs = [] for i_, room_name in enumerate(room_filelist): if test_area in room_name: test_idxs.append(i_) else: train_idxs.append(i_) # 利用列表索引数组 train_data_ = data_batches[train_idxs, ...] train_label_ = label_batches[train_idxs] test_data_ = data_batches[test_idxs, ...] test_label_ = label_batches[test_idxs] train_tiles = train_data_.shape[0] test_tiles = test_data_.shape[0] train_points = train_data_.shape[0] * train_data_.shape[1] test_points = test_data_.shape[0] * test_data_.shape[1] print("*-*-*-*-*-*-*-*-Dataset-*-*-*-*-*-*-*-*-*") print("*-* Train block:", train_tiles, "Points:", train_points) print("*-* Test block:", test_tiles, " Points:", test_points) print("*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*") train_data_ = np.expand_dims(train_data_, -1) test_data_ = np.expand_dims(test_data_, -1) train_label_ = train_label_.astype(np.int32) test_label_ = test_label_.astype(np.int32) return train_data_.astype(np.float32), train_label_, test_data_.astype( np.float32), test_label_
def init(f): global LOG_FOUT global DUMP_FILES global TEST_FILES # MAKE log directory if not os.path.exists(f['visual_dir']): os.mkdir(f['visual_dir']) # CREATE log file LOG_FOUT = open(os.path.join(f['visual_dir'], 'log_visualization.txt'), 'w') LOG_FOUT.write(dict2str(f)) DUMP_FILES = provider.getDataFiles( \ os.path.join(BASE_DIR, os.path.join(f['dump_dir'], 'list_evaluate.txt'))) TEST_FILES = provider.getDataFiles( \ os.path.join(BASE_DIR, os.path.join(f['dataset_path'], 'test_files.txt')))
def main(config): symbol, arg_params, aux_params = mx.model.load_checkpoint( './model/' + config.model_load_prefix, config.model_load_epoch) model = mx.model.FeedForward(symbol, mx.gpu(0), arg_params=arg_params, aux_params=aux_params) kv = mx.kvstore.create(config.kv_store) BASE_DIR = os.path.dirname(os.path.abspath(__file__)) # ModelNet40 official train/test split TRAIN_FILES = provider.getDataFiles( \ os.path.join(BASE_DIR, config.train_files)) TEST_FILES = provider.getDataFiles( \ os.path.join(BASE_DIR, config.val_files)) _, val, _ = dummy_iterator(config.batch_size, config.num_points, TRAIN_FILES, TEST_FILES) print model.score(val)
def make_ModelNet_data_A_B(err_num, batch_size): ModelNet_TRAIN_FILES = provider.getDataFiles( '../data/modelnet40_ply_hdf5_2048/train_files.txt') class_data = {l: [] for l in range(40)} for data_set in ModelNet_TRAIN_FILES: file = h5py.File('..//' + data_set, 'r') data = file['data'][...] label = np.reshape(file['label'][...], -1) normal = file['normal'][...] for i in range(data.shape[0]): class_data[label[i]].append(data[i]) file.close() for i in range(40): class_data[i] = np.array(class_data[i]) j = 0 for data_set in ModelNet_TRAIN_FILES: print('making ModelNet_A_B_' + str(j) + '.h5') file = h5py.File('..//' + data_set, 'r') data_A = file['data'][...] label_A = file['label'][...] data_A, label_A, _ = provider.shuffle_data(data_A, label_A) ERR = err_num * int(data_A.shape[0] / 9843) data_B, label_B = provider.get_data_with_err_ModelNet( label_A, class_data, err_num) label_B = np.reshape(label_B, [-1, 1]) data_A_B = np.zeros([2 * data_A.shape[0], 2048, 3]) label_A_B = np.zeros([2 * data_A.shape[0], 1]) for i in range(int(data_A.shape[0] / (batch_size / 2))): data_A_B[int((i + 0) * batch_size):int((i + 0.5) * batch_size)] = data_A[int( (i + 0) * (batch_size / 2)):int((i + 1) * (batch_size / 2))] data_A_B[int((i + 0.5) * batch_size):int((i + 1) * batch_size)] = data_B[int( (i + 0) * (batch_size / 2)):int((i + 1) * (batch_size / 2))] label_A_B[int((i + 0) * batch_size):int( (i + 0.5) * batch_size)] = label_A[int( (i + 0) * (batch_size / 2)):int((i + 1) * (batch_size / 2))] label_A_B[int((i + 0.5) * batch_size):int((i + 1) * batch_size)] = label_B[int( (i + 0) * (batch_size / 2)):int((i + 1) * (batch_size / 2))] data_set_A_B = h5py.File('data/ModelNet_A_B_' + str(j) + '.h5', 'w') data_set_A_B['data'] = data_A_B data_set_A_B['label'] = label_A_B data_set_A_B.close() file.close() j += 1
def load_data( train_files, test_files, num_points=1024, shuffle=False, rotate=False, rotate_val=False, ): train_files = provider.getDataFiles(train_files) test_files = provider.getDataFiles(test_files) x_train, y_train = load( train_files, points=num_points, shuffle=shuffle, rotate=rotate ) x_test, y_test = load( test_files, points=num_points, shuffle=shuffle, rotate=rotate_val ) return (x_train, y_train), (x_test, y_test)
def load_config(filename): global globalConfig assert filename.endswith('.json') name = os.path.basename(filename)[:-5] with open(filename, 'r') as handle: dump_to_namespace(configGlobal, json.load(handle)) configGlobal.__dict__["name"] = name configGlobal.data.__dict__["basename"] = os.path.basename( configGlobal.data.basepath) configGlobal.logging.__dict__[ "logdir"] = configGlobal.logging.basedir + f'/{name}' if configGlobal.evaluation.has('special'): if configGlobal.evaluation.special.mode == 'icp': configGlobal.logging.__dict__[ "logdir"] = configGlobal.logging.basedir + f'/icp_{configGlobal.data.basename}/{name}' TRAIN_INDICES = provider.getDataFiles( f'{configGlobal.data.basepath}/split/train.txt') VAL_INDICES = provider.getDataFiles( f'{configGlobal.data.basepath}/split/val.txt') configGlobal.data.__dict__["ntrain"] = len(TRAIN_INDICES) configGlobal.data.__dict__["nval"] = len(VAL_INDICES)
def estimate_mean_thresholds(): with tf.Graph().as_default(): with tf.device('/gpu:' + str(GPU_INDEX)): pointclouds_pl, labels_pl, sem_labels_pl = placeholder_inputs(BATCH_SIZE, NUM_POINT) is_training_pl = tf.placeholder(tf.bool, shape=()) # Get model pred_sem, pred_ins = get_model(pointclouds_pl, is_training_pl, NUM_CLASSES) loader = tf.train.Saver() # Create a session config = tf.ConfigProto() config.gpu_options.allow_growth = True config.allow_soft_placement = True config.log_device_placement = True sess = tf.Session(config=config) is_training = False # Restore all the variables loader.restore(sess, MODEL_PATH) print("Model restored") train_file_list = provider.getDataFiles(ESTIMATE_FILE_PATH) ths = np.zeros(NUM_CLASSES) cnt = np.zeros(NUM_CLASSES) ths_ = np.zeros(NUM_CLASSES) for shape_idx in range(len(train_file_list)): h5_filename = train_file_list[shape_idx] print('Loading file ' + h5_filename) cur_data, cur_group, _, cur_sem = provider.loadDataFile_with_groupseglabel_stanfordindoor(h5_filename) num_data = cur_data.shape[0] for j in range(num_data): print("Processing: Shape [%d] Block[%d]" % (shape_idx, j)) pts = cur_data[j, ...] seg = cur_sem[j, ...] ins = cur_group[j, ...] feed_dict = { pointclouds_pl: np.expand_dims(pts, 0), is_training_pl: is_training } pred_ins_val = sess.run([pred_ins], feed_dict=feed_dict) pred_ins_val = np.squeeze(pred_ins_val, axis=0) dis_mat = np.expand_dims(pred_ins_val, axis=1) - np.expand_dims(pred_ins_val, axis=0) dis_mat = np.linalg.norm(dis_mat, ord=1, axis=2) ths, ths_, cnt = Get_Ths(dis_mat, seg, ins, ths, ths_, cnt) print(cnt) ths = [ths[i] / cnt[i] if cnt[i] != 0 else 0.2 for i in range(len(cnt))] print(ths) np.savetxt(os.path.join(LOG_DIR, 'mean_thresholds.txt'), ths)
def Load_Stanford_Sampled_Hdf5(test_area, channel_elementes=['xyz_1norm'], max_test_fn=None): CHANNEL_INDEXS, NUM_CHANNELS = get_channel_indexs(channel_elementes) ALL_FILES = provider.getDataFiles(DefaultPointFileList) room_filelist = [line.rstrip() for line in open(DefaultROOMFileList, 'r')] data_batch_list = [] label_batch_list = [] for i, h5_filename in enumerate(ALL_FILES): data_batch, label_batch = provider.loadDataFile(h5_filename) data_batch = data_batch[..., CHANNEL_INDEXS] data_batch_list.append(data_batch) label_batch_list.append(label_batch) data_batches = np.concatenate(data_batch_list, 0) label_batches = np.concatenate(label_batch_list, 0) if test_area > 0: test_area_str = 'Area_' + str(test_area) else: test_area_str = 'Area_' train_idxs = [] test_idxs = [] for i, room_name in enumerate(room_filelist): if test_area_str in room_name: test_idxs.append(i) else: train_idxs.append(i) if max_test_fn != None and len(test_idxs) > max_test_fn: if len(test_idxs) > max_test_fn: test_idxs = test_idxs[0:max_test_fn] if len(train_idxs) > max_test_fn * 5: train_idxs = train_idxs[0:max_test_fn * 5] print('\n!!! in small data scale: only read %d test files\n' % (max_test_fn)) train_data = data_batches[train_idxs, ...] train_label = label_batches[train_idxs] test_data = data_batches[test_idxs, ...] test_label = label_batches[test_idxs] return train_data, train_label, test_data, test_label
def visualize_fv_pc_clas(): num_points = 1024 n_classes = 40 clas = 'person' #Create new gaussian subdev = 5 variance = 0.04 export = False display = True exp_path = '/home/itzikbs/PycharmProjects/fisherpointnet/paper_images/' shape_names = provider.getDataFiles( \ os.path.join(BASE_DIR, 'data/modelnet' + str(n_classes) + '_ply_hdf5_2048/shape_names.txt')) shape_dict = {shape_names[i]: i for i in range(len(shape_names))} gmm = ult_functions.get_grid_gmm(subdivisions=[subdev, subdev, subdev], variance=variance) # compute fv w = tf.constant(gmm.weights_, dtype=tf.float32) mu = tf.constant(gmm.means_, dtype=tf.float32) sigma = tf.constant(gmm.covariances_, dtype=tf.float32) for clas in shape_dict: points = provider.load_single_model_class(clas=clas, ind=0, test_train='train', file_idxs=0, num_points=1024, n_classes=n_classes) points = np.expand_dims(points,0) points_tensor = tf.constant(points, dtype=tf.float32) # convert points into a tensor fv_tensor = tf_util.get_fv_minmax(points_tensor, w, mu, sigma, flatten=False) sess = tf_util.get_session(2) with sess: fv = fv_tensor.eval() # # visualize_single_fv_with_pc(fv_train, points, label_title=clas, # fig_title='fv_pc', type='paper', pos=[750, 800, 0, 0], export=export, # filename=BASE_DIR + '/paper_images/fv_pc_' + clas) visualize_fv(fv, gmm, label_title=[clas], max_n_images=5, normalization=True, export=export, display=display, filename=exp_path + clas+'_fv', n_scales=1, type='none', fig_title='Figure') visualize_pc(points, label_title=clas, fig_title='figure', export=export, filename=exp_path +clas+'_pc') plt.close('all')
def init(f): global LOG_FOUT global MODEL global MODEL_CONF global TEST_FILES global FLIST_FOUT # IMPORT network module sys.path.append(f['model_path']) module = importlib.import_module(f['model']) MODEL = getattr(module, f['model']) MODEL_CONF = getattr(module, f['model'] + '_conf') # MAKE log directory if not os.path.exists(f['dump_dir']): os.mkdir(f['dump_dir']) # CREATE log file LOG_FOUT = open(os.path.join(f['dump_dir'], 'log_evaluate.txt'), 'w') LOG_FOUT.write(dict2str(f)) FLIST_FOUT = open(os.path.join(f['dump_dir'], 'list_evaluate.txt'), 'w') TEST_FILES = provider.getDataFiles( \ os.path.join(BASE_DIR, os.path.join(f['dataset_path'], 'test_files.txt')))
MODEL_PATH = FLAGS.model_path GPU_INDEX = FLAGS.gpu MODEL = importlib.import_module(FLAGS.model) # import network module DUMP_DIR = FLAGS.dump_dir if not os.path.exists(DUMP_DIR): os.mkdir(DUMP_DIR) LOG_FOUT = open(os.path.join(DUMP_DIR, 'log_evaluate.txt'), 'w') LOG_FOUT.write(str(FLAGS)+'\n') NUM_CLASSES = 40 SHAPE_NAMES = [line.rstrip() for line in \ open(os.path.join(BASE_DIR, 'data/modelnet40_ply_hdf5_2048/shape_names.txt'))] HOSTNAME = socket.gethostname() # ModelNet40 official train/test split TRAIN_FILES = provider.getDataFiles( \ os.path.join(BASE_DIR, 'data/modelnet40_ply_hdf5_2048/train_files.txt')) TEST_FILES = provider.getDataFiles(\ os.path.join(BASE_DIR, 'data/modelnet40_ply_hdf5_2048/test_files.txt')) def log_string(out_str): LOG_FOUT.write(out_str+'\n') LOG_FOUT.flush() print(out_str) def evaluate(num_votes): is_training = False with tf.device('/gpu:'+str(GPU_INDEX)): pointclouds_pl, labels_pl = MODEL.placeholder_inputs(BATCH_SIZE, NUM_POINT) is_training_pl = tf.placeholder(tf.bool, shape=())
""" def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs, leave=False) def __iter__(self): return super().__iter__() def __del__(self): self.ascii = True self.dynamic_ncols = False self.ncols = 100 logger.info(self.__repr__()) return super().__del__() TRAIN_INDICES = provider.getDataFiles(f'{cfg.data.basepath}/split/train.txt') VAL_INDICES = provider.getDataFiles(f'{cfg.data.basepath}/split/val.txt') def get_learning_rate(batch): num_batches_per_epoch = len(TRAIN_INDICES) // cfg.training.batch_size if cfg.training.lr_extension.mode == 'decay': lr_decay_step = cfg.training.lr_extension.step if cfg.training.lr_extension.per == 'step': pass elif cfg.training.lr_extension.per == 'epoch': lr_decay_step *= cfg.training.batch_size * num_batches_per_epoch else: assert False
os.system('cp train.py %s' % (LOG_DIR)) # bkp of train procedure LOG_FOUT = open(os.path.join(LOG_DIR, 'log_train.txt'), 'w') LOG_FOUT.write(str(FLAGS)+'\n') MAX_NUM_POINT = 4096 NUM_CLASSES = 12 BN_INIT_DECAY = 0.5 BN_DECAY_DECAY_RATE = 0.5 #BN_DECAY_DECAY_STEP = float(DECAY_STEP * 2) BN_DECAY_DECAY_STEP = float(DECAY_STEP) BN_DECAY_CLIP = 0.99 HOSTNAME = socket.gethostname() ALL_FILES = provider.getDataFiles(os.path.join(ROOT_DIR,'data/indoor3d_sem_seg_hdf5_data/all_files.txt')) room_filelist = [line.rstrip() for line in open(os.path.join(ROOT_DIR,'data/indoor3d_sem_seg_hdf5_data/room_filelist.txt'))] # Create a session #config = tf.ConfigProto() #config.gpu_options.allow_growth = True #config.allow_soft_placement = True #config.log_device_placement = True #sess = tf.Session(config=config) # Restore variables from disk. #if FLAGS.checkpoint_dir is not None: # restoring from the checkpoint file #ckpt = tf.train.get_checkpoint_state(FLAGS.checkpoint_dir) #tf.train.Saver().restore(sess, ckpt.model_checkpoint_path, latest_filename= 'model.ckpt.index')
def train(): with tf.Graph().as_default(), tf.device('/cpu:0'): batch = tf.Variable(0, trainable=False) learning_rate = tf.train.exponential_decay( BASE_LEARNING_RATE, # base learning rate batch * batch_size, # global_var indicating the number of steps DECAY_STEP, # step size DECAY_RATE, # decay rate staircase=True # Stair-case or continuous decreasing ) learning_rate = tf.maximum(learning_rate, LEARNING_RATE_CLIP) bn_momentum = tf.train.exponential_decay( BN_INIT_DECAY, batch*batch_size, BN_DECAY_DECAY_STEP, BN_DECAY_DECAY_RATE, staircase=True) bn_decay = tf.minimum(BN_DECAY_CLIP, 1 - bn_momentum) lr_op = tf.summary.scalar('learning_rate', learning_rate) batch_op = tf.summary.scalar('batch_number', batch) bn_decay_op = tf.summary.scalar('bn_decay', bn_decay) trainer = tf.train.AdamOptimizer(learning_rate) # store tensors for different gpus tower_grads = [] pointclouds_phs = [] input_label_phs = [] seg_phs =[] is_training_phs =[] with tf.variable_scope(tf.get_variable_scope()): for i in range(FLAGS.num_gpu): with tf.device('/gpu:%d' % i): with tf.name_scope('%s_%d' % (TOWER_NAME, i)) as scope: pointclouds_phs.append(tf.placeholder(tf.float32, shape=(batch_size, point_num, 3))) # for points input_label_phs.append(tf.placeholder(tf.float32, shape=(batch_size, NUM_CATEGORIES))) # for one-hot category label seg_phs.append(tf.placeholder(tf.int32, shape=(batch_size, point_num))) # for part labels is_training_phs.append(tf.placeholder(tf.bool, shape=())) seg_pred = model.get_model(pointclouds_phs[-1], input_label_phs[-1], \ is_training=is_training_phs[-1], bn_decay=bn_decay, cat_num=NUM_CATEGORIES, \ part_num=NUM_PART_CATS, batch_size=batch_size, num_point=point_num, graphnum=graphnum, featnum = featnum, weight_decay=FLAGS.wd) loss, per_instance_seg_loss, per_instance_seg_pred_res \ = model.get_loss(seg_pred, seg_phs[-1]) total_training_loss_ph = tf.placeholder(tf.float32, shape=()) total_testing_loss_ph = tf.placeholder(tf.float32, shape=()) seg_training_acc_ph = tf.placeholder(tf.float32, shape=()) seg_testing_acc_ph = tf.placeholder(tf.float32, shape=()) seg_testing_acc_avg_cat_ph = tf.placeholder(tf.float32, shape=()) total_train_loss_sum_op = tf.summary.scalar('total_training_loss', total_training_loss_ph) total_test_loss_sum_op = tf.summary.scalar('total_testing_loss', total_testing_loss_ph) seg_train_acc_sum_op = tf.summary.scalar('seg_training_acc', seg_training_acc_ph) seg_test_acc_sum_op = tf.summary.scalar('seg_testing_acc', seg_testing_acc_ph) seg_test_acc_avg_cat_op = tf.summary.scalar('seg_testing_acc_avg_cat', seg_testing_acc_avg_cat_ph) tf.get_variable_scope().reuse_variables() grads = trainer.compute_gradients(loss) tower_grads.append(grads) grads = average_gradients(tower_grads) train_op = trainer.apply_gradients(grads, global_step=batch) saver = tf.train.Saver(tf.global_variables(), sharded=True, max_to_keep=20) config = tf.ConfigProto() config.gpu_options.allow_growth = True config.allow_soft_placement = True sess = tf.Session(config=config) # Resume model if possible if FLAGS.model_path != None: saver.restore(sess, FLAGS.model_path) else: init = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) sess.run(init) train_writer = tf.summary.FileWriter(SUMMARIES_FOLDER + '/train', sess.graph) test_writer = tf.summary.FileWriter(SUMMARIES_FOLDER + '/test') train_file_list = provider.getDataFiles(TRAINING_FILE_LIST) num_train_file = len(train_file_list) test_file_list = provider.getDataFiles(TESTING_FILE_LIST) num_test_file = len(test_file_list) fcmd = open(os.path.join(LOG_STORAGE_PATH, 'cmd.txt'), 'w') fcmd.write(str(FLAGS)) fcmd.close() # write logs to the disk flog = open(os.path.join(LOG_STORAGE_PATH, 'log.txt'), 'w') def train_one_epoch(train_file_idx, epoch_num): is_training = True for i in range(num_train_file): cur_train_filename = os.path.join(hdf5_data_dir, train_file_list[train_file_idx[i]]) printout(flog, 'Loading train file ' + cur_train_filename) cur_data, cur_labels, cur_seg = provider.load_h5_data_label_seg(cur_train_filename) cur_data, cur_labels, order = provider.shuffle_data(cur_data, np.squeeze(cur_labels)) cur_seg = cur_seg[order, ...] cur_labels_one_hot = convert_label_to_one_hot(cur_labels) num_data = len(cur_labels) num_batch = num_data // (FLAGS.num_gpu * batch_size) # For all working gpus total_loss = 0.0 total_seg_acc = 0.0 for j in range(num_batch): begidx_0 = j * batch_size endidx_0 = (j + 1) * batch_size feed_dict = { # For the first gpu pointclouds_phs[0]: cur_data[begidx_0: endidx_0, ...], input_label_phs[0]: cur_labels_one_hot[begidx_0: endidx_0, ...], seg_phs[0]: cur_seg[begidx_0: endidx_0, ...], is_training_phs[0]: is_training, } # train_op is for both gpus, and the others are for gpu_1 _, loss_val, per_instance_seg_loss_val, seg_pred_val, pred_seg_res \ = sess.run([train_op, loss, per_instance_seg_loss, seg_pred, per_instance_seg_pred_res], \ feed_dict=feed_dict) per_instance_part_acc = np.mean(pred_seg_res == cur_seg[begidx_0: endidx_0, ...], axis=1) average_part_acc = np.mean(per_instance_part_acc) total_loss += loss_val total_seg_acc += average_part_acc total_loss = total_loss * 1.0 / num_batch total_seg_acc = total_seg_acc * 1.0 / num_batch lr_sum, bn_decay_sum, batch_sum, train_loss_sum, train_seg_acc_sum = sess.run(\ [lr_op, bn_decay_op, batch_op, total_train_loss_sum_op, seg_train_acc_sum_op], \ feed_dict={total_training_loss_ph: total_loss, seg_training_acc_ph: total_seg_acc}) train_writer.add_summary(train_loss_sum, i + epoch_num * num_train_file) train_writer.add_summary(lr_sum, i + epoch_num * num_train_file) train_writer.add_summary(bn_decay_sum, i + epoch_num * num_train_file) train_writer.add_summary(train_seg_acc_sum, i + epoch_num * num_train_file) train_writer.add_summary(batch_sum, i + epoch_num * num_train_file) printout(flog, '\tTraining Total Mean_loss: %f' % total_loss) printout(flog, '\t\tTraining Seg Accuracy: %f' % total_seg_acc) def eval_one_epoch(epoch_num): is_training = False total_loss = 0.0 total_seg_acc = 0.0 total_seen = 0 total_seg_acc_per_cat = np.zeros((NUM_CATEGORIES)).astype(np.float32) total_seen_per_cat = np.zeros((NUM_CATEGORIES)).astype(np.int32) for i in range(num_test_file): cur_test_filename = os.path.join(hdf5_data_dir, test_file_list[i]) printout(flog, 'Loading test file ' + cur_test_filename) cur_data, cur_labels, cur_seg = provider.load_h5_data_label_seg(cur_test_filename) cur_labels = np.squeeze(cur_labels) cur_labels_one_hot = convert_label_to_one_hot(cur_labels) num_data = len(cur_labels) num_batch = num_data // batch_size # Run on gpu_1, since the tensors used for evaluation are defined on gpu_1 for j in range(num_batch): begidx = j * batch_size endidx = (j + 1) * batch_size feed_dict = { pointclouds_phs[0]: cur_data[begidx: endidx, ...], input_label_phs[0]: cur_labels_one_hot[begidx: endidx, ...], seg_phs[0]: cur_seg[begidx: endidx, ...], is_training_phs[0]: is_training} loss_val, per_instance_seg_loss_val, seg_pred_val, pred_seg_res \ = sess.run([loss, per_instance_seg_loss, seg_pred, per_instance_seg_pred_res], \ feed_dict=feed_dict) per_instance_part_acc = np.mean(pred_seg_res == cur_seg[begidx: endidx, ...], axis=1) average_part_acc = np.mean(per_instance_part_acc) total_seen += 1 total_loss += loss_val total_seg_acc += average_part_acc for shape_idx in range(begidx, endidx): total_seen_per_cat[cur_labels[shape_idx]] += 1 total_seg_acc_per_cat[cur_labels[shape_idx]] += per_instance_part_acc[shape_idx - begidx] total_loss = total_loss * 1.0 / total_seen total_seg_acc = total_seg_acc * 1.0 / total_seen test_loss_sum, test_seg_acc_sum = sess.run(\ [total_test_loss_sum_op, seg_test_acc_sum_op], \ feed_dict={total_testing_loss_ph: total_loss, \ seg_testing_acc_ph: total_seg_acc}) test_writer.add_summary(test_loss_sum, (epoch_num+1) * num_train_file-1) test_writer.add_summary(test_seg_acc_sum, (epoch_num+1) * num_train_file-1) printout(flog, '\tTesting Total Mean_loss: %f' % total_loss) printout(flog, '\t\tTesting Seg Accuracy: %f' % total_seg_acc) for cat_idx in range(NUM_CATEGORIES): if total_seen_per_cat[cat_idx] > 0: printout(flog, '\n\t\tCategory %s Object Number: %d' % (all_obj_cats[cat_idx][0], total_seen_per_cat[cat_idx])) printout(flog, '\t\tCategory %s Seg Accuracy: %f' % (all_obj_cats[cat_idx][0], total_seg_acc_per_cat[cat_idx]/total_seen_per_cat[cat_idx])) if not os.path.exists(MODEL_STORAGE_PATH): os.mkdir(MODEL_STORAGE_PATH) for epoch in range(FLAGS.start_epoch, TRAINING_EPOCHES): printout(flog, '\n<<< Testing on the test dataset ...') eval_one_epoch(epoch) printout(flog, '\n>>> Training for the epoch %d/%d ...' % (epoch, TRAINING_EPOCHES)) train_file_idx = np.arange(0, len(train_file_list)) np.random.shuffle(train_file_idx) train_one_epoch(train_file_idx, epoch) if epoch % 10 == 0: cp_filename = saver.save(sess, os.path.join(MODEL_STORAGE_PATH, 'epoch_' + str(epoch)+'.ckpt')) printout(flog, 'Successfully store the checkpoint model into ' + cp_filename) flog.flush() flog.close()
os.system('cp train.py %s' % (LOG_DIR)) # bkp of train procedure LOG_FOUT = open(os.path.join(LOG_DIR, 'log_train.txt'), 'w') LOG_FOUT.write(str(FLAGS)+'\n') MAX_NUM_POINT = 2048 NUM_CLASSES = 5 BN_INIT_DECAY = 0.5 BN_DECAY_DECAY_RATE = 0.5 BN_DECAY_DECAY_STEP = float(DECAY_STEP) BN_DECAY_CLIP = 0.99 HOSTNAME = socket.gethostname() # ModelNet40 official train/test split TRAIN_FILES = provider.getDataFiles( \ os.path.join(BASE_DIR, 'data/challenge1/colors_only_train_files.txt')) TEST_FILES = provider.getDataFiles(\ os.path.join(BASE_DIR, 'data/challenge1/colors_only_test_files.txt')) def log_string(out_str): LOG_FOUT.write(out_str+'\n') LOG_FOUT.flush() print(out_str) def get_learning_rate(batch): learning_rate = tf.train.exponential_decay( BASE_LEARNING_RATE, # Base learning rate. batch * BATCH_SIZE, # Current index into the dataset. DECAY_STEP, # Decay step. DECAY_RATE, # Decay rate.
MAX_NUM_POINT = 4096 #NUM_CLASSES = 13 with open("meta/class_names.txt", "r") as fr: NUM_CLASSES = len(fr.readlines()) print("NUM_CLASSES:", NUM_CLASSES) BN_INIT_DECAY = 0.5 BN_DECAY_DECAY_RATE = 0.5 BN_DECAY_DECAY_STEP = float(DECAY_STEP) BN_DECAY_CLIP = 0.99 HOSTNAME = socket.gethostname() ALL_FILES = provider.getDataFiles('indoor3d_sem_seg_hdf5_data/all_files.txt') room_filelist = [ line.rstrip() for line in open('indoor3d_sem_seg_hdf5_data/room_filelist.txt') ] print("room_filelist:", len(room_filelist)) # Load ALL data data_batch_list = [] label_batch_list = [] for h5_filename in ALL_FILES: data_batch, label_batch = provider.loadDataFile(h5_filename) data_batch_list.append(data_batch) label_batch_list.append(label_batch) data_batches = np.concatenate(data_batch_list, 0) label_batches = np.concatenate(label_batch_list, 0)
def train(): with tf.Graph().as_default(), tf.device('/cpu:0'): batch = tf.Variable(0, trainable=False) learning_rate = tf.train.exponential_decay( BASE_LEARNING_RATE, # base learning rate batch * batch_size, # global_var indicating the number of steps DECAY_STEP, # step size DECAY_RATE, # decay rate staircase=True # Stair-case or continuous decreasing ) learning_rate = tf.maximum(learning_rate, LEARNING_RATE_CLIP) bn_momentum = tf.train.exponential_decay( BN_INIT_DECAY, batch*batch_size, BN_DECAY_DECAY_STEP, BN_DECAY_DECAY_RATE, staircase=True) bn_decay = tf.minimum(BN_DECAY_CLIP, 1 - bn_momentum) lr_op = tf.summary.scalar('learning_rate', learning_rate) batch_op = tf.summary.scalar('batch_number', batch) bn_decay_op = tf.summary.scalar('bn_decay', bn_decay) trainer = tf.train.AdamOptimizer(learning_rate) # store tensors for different gpus tower_grads = [] pointclouds_phs = [] input_label_phs = [] seg_phs =[] is_training_phs =[] # 变量 with tf.variable_scope(tf.get_variable_scope()): for i in range(FLAGS.num_gpu): with tf.device('/gpu:%d' % i): with tf.name_scope('%s_%d' % (TOWER_NAME, i)) as scope: pointclouds_phs.append(tf.placeholder(tf.float32, shape=(batch_size, point_num, 3))) # for points 4*2048*3 input_label_phs.append(tf.placeholder(tf.float32, shape=(batch_size, NUM_CATEGORIES))) # for one-hot category label # 4*16 seg_phs.append(tf.placeholder(tf.int32, shape=(batch_size, point_num))) # for part labels # labels 4*2048 is_training_phs.append(tf.placeholder(tf.bool, shape=())) # 预测值 # seg_pred : B*N*part_num=4*2048*50 seg_pred = model.get_model(pointclouds_phs[-1], input_label_phs[-1], \ is_training=is_training_phs[-1], bn_decay=bn_decay, cat_num=NUM_CATEGORIES, \ part_num=NUM_PART_CATS, batch_size=batch_size, num_point=point_num, weight_decay=FLAGS.wd) # cat_num=16,part_num=50 # loss:这个batch的总的loss # per_instance_loss:每个点云的loss,shape=4 # per_instance_seg_pred_res : 每个点云的分割结果,由seg_pred取max得到的,shape=4*2048 loss, per_instance_seg_loss, per_instance_seg_pred_res \ = model.get_loss(seg_pred, seg_phs[-1]) # placeholder total_training_loss_ph = tf.placeholder(tf.float32, shape=()) total_testing_loss_ph = tf.placeholder(tf.float32, shape=()) seg_training_acc_ph = tf.placeholder(tf.float32, shape=()) seg_testing_acc_ph = tf.placeholder(tf.float32, shape=()) seg_testing_acc_avg_cat_ph = tf.placeholder(tf.float32, shape=()) # scalar total_train_loss_sum_op = tf.summary.scalar('total_training_loss', total_training_loss_ph) total_test_loss_sum_op = tf.summary.scalar('total_testing_loss', total_testing_loss_ph) seg_train_acc_sum_op = tf.summary.scalar('seg_training_acc', seg_training_acc_ph) seg_test_acc_sum_op = tf.summary.scalar('seg_testing_acc', seg_testing_acc_ph) seg_test_acc_avg_cat_op = tf.summary.scalar('seg_testing_acc_avg_cat', seg_testing_acc_avg_cat_ph) tf.get_variable_scope().reuse_variables() grads = trainer.compute_gradients(loss) tower_grads.append(grads) grads = average_gradients(tower_grads) # 计算平均梯度 train_op = trainer.apply_gradients(grads, global_step=batch) saver = tf.train.Saver(tf.global_variables(), sharded=True, max_to_keep=20) # 保存变量 config = tf.ConfigProto() config.gpu_options.allow_growth = True config.allow_soft_placement = True sess = tf.Session(config=config) init = tf.group(tf.global_variables_initializer(), tf.local_variables_initializer()) sess.run(init) train_writer = tf.summary.FileWriter(SUMMARIES_FOLDER + '/train', sess.graph) # 保存graph test_writer = tf.summary.FileWriter(SUMMARIES_FOLDER + '/test') train_file_list = provider.getDataFiles(TRAINING_FILE_LIST) # [train0.h5,train1.h5,...train5.h5] num_train_file = len(train_file_list) # 6 test_file_list = provider.getDataFiles(TESTING_FILE_LIST) # [ply_data_val0.h5] num_test_file = len(test_file_list) # 1 # 保存终端输入 fcmd = open(os.path.join(LOG_STORAGE_PATH, 'cmd.txt'), 'w') fcmd.write(str(FLAGS)) fcmd.close() # write logs to the disk flog = open(os.path.join(LOG_STORAGE_PATH, 'log.txt'), 'w') def train_one_epoch(train_file_idx, epoch_num): # 输入为打乱后的顺序 is_training = True # 遍历每一个train文件 for i in range(num_train_file): cur_train_filename = os.path.join(hdf5_data_dir, train_file_list[train_file_idx[i]]) # 获取当前的train的点云文件 printout(flog, 'Loading train file ' + cur_train_filename) cur_data, cur_labels, cur_seg = provider.load_h5_data_label_seg(cur_train_filename) cur_data, cur_labels, order = provider.shuffle_data(cur_data, np.squeeze(cur_labels)) cur_seg = cur_seg[order, ...] cur_labels_one_hot = convert_label_to_one_hot(cur_labels) num_data = len(cur_labels) num_batch = num_data // (FLAGS.num_gpu * batch_size) # For all working gpus num——batch代表这个train文件分几个batch total_loss = 0.0 total_seg_acc = 0.0 # 对每一个batch for j in range(num_batch): begidx_0 = j * batch_size # 第一个gpu endidx_0 = (j + 1) * batch_size begidx_1 = (j + 1) * batch_size # 第二个gpu endidx_1 = (j + 2) * batch_size feed_dict = { # For the first gpu pointclouds_phs[0]: cur_data[begidx_0: endidx_0, ...], # 4*2048*3 input_label_phs[0]: cur_labels_one_hot[begidx_0: endidx_0, ...], # 4*16 seg_phs[0]: cur_seg[begidx_0: endidx_0, ...], # 4*2048 ,每一个数都在0-49之间 is_training_phs[0]: is_training, # # For the second gpu # pointclouds_phs[1]: cur_data[begidx_1: endidx_1, ...], # input_label_phs[1]: cur_labels_one_hot[begidx_1: endidx_1, ...], # seg_phs[1]: cur_seg[begidx_1: endidx_1, ...], # is_training_phs[1]: is_training, } # train_op is for both gpus, and the others are for gpu_1 # 每一个batch的平均损失、每一个点云的损失、分割预测值 _, loss_val, per_instance_seg_loss_val, seg_pred_val, pred_seg_res \ = sess.run([train_op, loss, per_instance_seg_loss, seg_pred, per_instance_seg_pred_res], \ feed_dict=feed_dict) # per_instance_part_acc = np.mean(pred_seg_res == cur_seg[begidx_1: endidx_1, ...], axis=1) per_instance_part_acc = np.mean(pred_seg_res == cur_seg[begidx_0: endidx_0, ...], axis=1) # 每一个点云的分割精度 average_part_acc = np.mean(per_instance_part_acc) # 当前batch的平均精度 total_loss += loss_val total_seg_acc += average_part_acc # 至此,一个train文件遍历完成 total_loss = total_loss * 1.0 / num_batch # 每一个train文件都得到一个loss和seg_acc total_seg_acc = total_seg_acc * 1.0 / num_batch # 绘制图 lr_sum, bn_decay_sum, batch_sum, train_loss_sum, train_seg_acc_sum = sess.run(\ [lr_op, bn_decay_op, batch_op, total_train_loss_sum_op, seg_train_acc_sum_op], \ feed_dict={total_training_loss_ph: total_loss, seg_training_acc_ph: total_seg_acc}) train_writer.add_summary(train_loss_sum, i + epoch_num * num_train_file) # epoch_num是一个不断变化的值 train_writer.add_summary(lr_sum, i + epoch_num * num_train_file) train_writer.add_summary(bn_decay_sum, i + epoch_num * num_train_file) train_writer.add_summary(train_seg_acc_sum, i + epoch_num * num_train_file) train_writer.add_summary(batch_sum, i + epoch_num * num_train_file) printout(flog, '\tTanin_file: {},Training Total Mean_loss: {}'.format(i,total_loss)) # 每一个train文件的loss和acc printout(flog, '\t\tTanin_file: {} ,Training Seg Accuracy: {}'.format(i,total_seg_acc)) def eval_one_epoch(epoch_num): is_training = False total_loss = 0.0 total_seg_acc = 0.0 total_seen = 0 total_seg_acc_per_cat = np.zeros((NUM_CATEGORIES)).astype(np.float32) # [0. 0. ....0.] 16个0 total_seen_per_cat = np.zeros((NUM_CATEGORIES)).astype(np.int32) # [0 0 0 0 ...0] for i in range(num_test_file): # i= 0 num_test_file=1 cur_test_filename = os.path.join(hdf5_data_dir, test_file_list[i]) # ply_data_val0.h5 printout(flog, 'Loading test file ' + cur_test_filename) # ply_data_val0.h5 # 读取数据 # data = f['data'][:] # (1870, 2048, 3) # label = f['label'][:] # (1870,1) 1870个点云的类别0-15 # seg = f['pid'][:] # (1870, 2048) ,表示每一个点属于的类别0-49,一共50类点 cur_data, cur_labels, cur_seg = provider.load_h5_data_label_seg(cur_test_filename) cur_labels = np.squeeze(cur_labels) # shape:(1870,) cur_labels_one_hot = convert_label_to_one_hot(cur_labels) # 1870*16 num_data = len(cur_labels) # 1870个点云 num_batch = num_data // batch_size # 467个batch # Run on gpu_1, since the tensors used for evaluation are defined on gpu_1 for j in range(num_batch): # 0-466 begidx = j * batch_size endidx = (j + 1) * batch_size # feed_dict = { # pointclouds_phs[1]: cur_data[begidx: endidx, ...], # input_label_phs[1]: cur_labels_one_hot[begidx: endidx, ...], # seg_phs[1]: cur_seg[begidx: endidx, ...], # is_training_phs[1]: is_training} feed_dict = { pointclouds_phs[0]: cur_data[begidx: endidx, ...], # 4*2048*3 input_label_phs[0]: cur_labels_one_hot[begidx: endidx, ...], # 4*16 seg_phs[0]: cur_seg[begidx: endidx, ...], # 4*2048 is_training_phs[0]: is_training} # pred_seg_res:每个点的分割结果 shape:4*2048 # seg_pred_val:分割结果,概率编码 shape:4*2048*50 # per_instance_seg_loss_val: 每一个点云的损失 shape:(4,) # loss_val:当前batch的平均损失 shape:() loss_val, per_instance_seg_loss_val, seg_pred_val, pred_seg_res \ = sess.run([loss, per_instance_seg_loss, seg_pred, per_instance_seg_pred_res], \ feed_dict=feed_dict) per_instance_part_acc = np.mean(pred_seg_res == cur_seg[begidx: endidx, ...], axis=1) # 4个点云的每一个的分割精度 shape:(4,) average_part_acc = np.mean(per_instance_part_acc) # 4个点云的平均分割精度 total_seen += 1 # 以batch为单位 total_loss += loss_val total_seg_acc += average_part_acc # average_part_acc:当前batch的分割精度 for shape_idx in range(begidx, endidx): # 对当前batch中的每一个点云 total_seen_per_cat[cur_labels[shape_idx]] += 1 # 统计看过的每一类点云的数量 total_seg_acc_per_cat[cur_labels[shape_idx]] += per_instance_part_acc[shape_idx - begidx] # 统计每一类点云的精度 total_loss = total_loss * 1.0 / total_seen # 总的分割损失 total_seg_acc = total_seg_acc * 1.0 / total_seen # 总的平均分割精度,以batch为单位 # 绘制图 test_loss_sum, test_seg_acc_sum = sess.run(\ [total_test_loss_sum_op, seg_test_acc_sum_op], \ feed_dict={total_testing_loss_ph: total_loss, \ seg_testing_acc_ph: total_seg_acc}) test_writer.add_summary(test_loss_sum, (epoch_num+1) * num_train_file-1) test_writer.add_summary(test_seg_acc_sum, (epoch_num+1) * num_train_file-1) printout(flog, '\t\tTesting Total Mean_loss: %f' % total_loss) printout(flog, '\t\tTesting Seg Accuracy: %f' % total_seg_acc) for cat_idx in range(NUM_CATEGORIES): # 0-15 if total_seen_per_cat[cat_idx] > 0: # 如果看过这类物体,就打印看得数量 printout(flog, '\n\t\tCategory %s Object Number: %d' % (all_obj_cats[cat_idx][0], total_seen_per_cat[cat_idx])) printout(flog, '\t\tCategory %s Seg Accuracy: %f' % (all_obj_cats[cat_idx][0], total_seg_acc_per_cat[cat_idx]/total_seen_per_cat[cat_idx])) if not os.path.exists(MODEL_STORAGE_PATH): os.mkdir(MODEL_STORAGE_PATH) for epoch in range(TRAINING_EPOCHES): printout(flog, '\n<<< Testing on the test dataset ...') eval_one_epoch(epoch) # 评估 printout(flog, '\n>>> Training for the epoch %d/%d ...' % (epoch, TRAINING_EPOCHES)) train_file_idx = np.arange(0, len(train_file_list)) np.random.shuffle(train_file_idx) train_one_epoch(train_file_idx, epoch) # 训练 if epoch % 5 == 0: cp_filename = saver.save(sess, os.path.join(MODEL_STORAGE_PATH, 'epoch_' + str(epoch)+'.ckpt')) printout(flog, 'Successfully store the checkpoint model into ' + cp_filename) flog.flush() flog.close()
import pickle BASE_DIR = os.path.dirname(os.path.abspath(__file__)) sys.path.append(BASE_DIR) sys.path.append(os.path.join(BASE_DIR, 'models')) sys.path.append(os.path.join(BASE_DIR, 'ult_functions')) from ult_functions import utils as utils from ult_functions import visualization as visualization from ult_functions import tf_util as tf_util import provider # ModelNet40 official train/test split. MOdelNet10 requires separate downloading and sampling. MAX_N_POINTS = 512 NUM_CLASSES = 7 TRAIN_FILES = provider.getDataFiles( os.path.join(BASE_DIR, 'data/test_data_hdf5_512' + '/train_files.txt')) TEST_FILES = provider.getDataFiles( os.path.join(BASE_DIR, 'data/test_data_hdf5_512' + '/test_files.txt')) LABEL_MAP = provider.getDataFiles( os.path.join(BASE_DIR, 'data/test_data_hdf5_512' + '/shape_names.txt')) # ModelNet40 official train/test split. MOdelNet10 requires separate downloading and sampling. # MAX_N_POINTS = 2048 # NUM_CLASSES = 40 # TRAIN_FILES = provider.getDataFiles( \ # os.path.join(BASE_DIR, 'data/modelnet'+str(NUM_CLASSES)+'_ply_hdf5_'+ str(MAX_N_POINTS)+ '/train_files.txt')) # TEST_FILES = provider.getDataFiles(\ # os.path.join(BASE_DIR, 'data/modelnet'+str(NUM_CLASSES)+'_ply_hdf5_'+ str(MAX_N_POINTS)+ '/test_files.txt')) # LABEL_MAP = provider.getDataFiles(\
NUM_POINT = FLAGS.num_point BATCH_SIZE = FLAGS.batch NFEATURES = FLAGS.nfeat NUM_CATEGORIES = FLAGS.ncat #Only used to get how many parts per category print('#### Batch Size : {0}'.format(BATCH_SIZE)) print('#### Point Number: {0}'.format(NUM_POINT)) print('#### Using GPUs: {0}'.format(FLAGS.gpu)) if not os.path.exists(FLAGS.plot_path): os.mkdir(FLAGS.plot_path) print('### Starting evaluation') EVALUATE_FILES = provider.getDataFiles( os.path.join(H5_DIR, 'evaluate_files.txt')) print("Loading: ", os.path.join(H5_DIR, 'evaluate_files.txt')) def printout(flog, data): print(data) flog.write(data + '\n') def convert_label_to_one_hot(labels): label_one_hot = np.zeros((labels.shape[0], NUM_CATEGORIES)) for idx in range(labels.shape[0]): label_one_hot[idx, labels[idx] - MIN_LABEL] = 1 return label_one_hot
import os import sys BASE_DIR = os.path.dirname(os.path.abspath(__file__)) sys.path.append(BASE_DIR) sys.path.append(os.path.join(BASE_DIR, '../../VisionProcess')) from FileIO import FileIO import provider # load dataset TRAIN_FILES_VEC = [[],[]] TEST_FILES_VEC = [[],[]] for i in range(1): path = 'data/extracted_feature' # path = 'data/modelnet40_ply_hdf5_2048/' TRAIN_FILES_VEC[i] = provider.getDataFiles( \ os.path.join(BASE_DIR, path + '/train_files.txt')) TEST_FILES_VEC[i] = provider.getDataFiles(\ os.path.join(BASE_DIR, path + '/test_files.txt')) ## data are point cloud #data = np.array([], dtype=np.float32).reshape(0,2048,3) #label = np.array([], dtype=np.float32).reshape(0,1) ## data are features data = np.array([], dtype=np.float32).reshape(0,1024) label = np.array([], dtype=np.float32).reshape(0) for i in range(len(TEST_FILES_VEC[0])): data_temp, label_temp = FileIO.load_h5(TEST_FILES_VEC[0][i]) data = np.concatenate((data, data_temp), axis=0) label = np.concatenate((label, label_temp), axis=0)
import sys import time import numpy as np def random_shuffle(x): perm = np.arange(x.shape[0]) np.random.shuffle(perm) x = x[perm] return x, perm # Start start_time = time.time() print('Start testing') train_files = pv.getDataFiles('trainval_shape_voxel_data_list.txt') test_files = pv.getDataFiles('test_shape_voxel_data_list.txt') print('#train_files = {}'.format(train_files.shape[0])) print('#test_files = {}'.format(test_files.shape[0])) num_of_files = train_files.shape[0] train_files, _ = random_shuffle(train_files) print('|', end='') for fn in range(num_of_files): current_data, current_label = pv.loadDataFile(train_files[fn], 42) print('*', end='') sys.stdout.flush() print('|') print('total time: ', time.time() - start_time)
BATCH_SIZE = FLAGS.batch_size NUM_POINT = FLAGS.num_point MODEL_PATH = FLAGS.model_path # to change GPU_INDEX = FLAGS.gpu MODEL = importlib.import_module(FLAGS.model) # import network module DUMP_DIR = FLAGS.dump_dir if not os.path.exists(DUMP_DIR): os.mkdir(DUMP_DIR) LOG_FOUT = open(os.path.join(DUMP_DIR, 'log_evaluate.txt'), 'w') LOG_FOUT.write(str(FLAGS) + '\n') NUM_CLASSES = 40 SHAPE_NAMES = [line.rstrip() for line in \ open(os.path.join(BASE_DIR, 'data/modelnet40_ply_hdf5_2048/shape_names.txt'))] # ModelNet40 official train/test split TRAIN_FILES = provider.getDataFiles( \ os.path.join(BASE_DIR, 'data/modelnet40_ply_hdf5_2048/train_files.txt')) TEST_FILES = provider.getDataFiles(\ os.path.join(BASE_DIR, 'data/modelnet40_ply_hdf5_2048/test_files.txt')) def log_string(out_str): LOG_FOUT.write(out_str + '\n') LOG_FOUT.flush() print(out_str) def evaluate(num_votes=1): is_training = False with tf.device('/gpu: ' + str(GPU_INDEX)): pointclouds_pl, labels_pl = MODEL.placeholder_inputs(1, NUM_POINT)
os.system('cp train.py %s' % (LOG_DIR)) # bkp of train procedure LOG_FOUT = open(os.path.join(LOG_DIR, 'log_train.txt'), 'w') LOG_FOUT.write(str(FLAGS)+'\n') MAX_NUM_POINT = 4096 NUM_CLASSES = 13 BN_INIT_DECAY = 0.5 BN_DECAY_DECAY_RATE = 0.5 #BN_DECAY_DECAY_STEP = float(DECAY_STEP * 2) BN_DECAY_DECAY_STEP = float(DECAY_STEP) BN_DECAY_CLIP = 0.99 HOSTNAME = socket.gethostname() ALL_FILES = provider.getDataFiles('indoor3d_sem_seg_hdf5_data/all_files.txt') room_filelist = [line.rstrip() for line in open('indoor3d_sem_seg_hdf5_data/room_filelist.txt')] # Load ALL data data_batch_list = [] label_batch_list = [] for h5_filename in ALL_FILES: data_batch, label_batch = provider.loadDataFile(h5_filename) data_batch_list.append(data_batch) label_batch_list.append(label_batch) data_batches = np.concatenate(data_batch_list, 0) label_batches = np.concatenate(label_batch_list, 0) print(data_batches.shape) print(label_batches.shape) test_area = 'Area_'+str(FLAGS.test_area)