def object_aug(object_data, object_labels, object_seg): object_data1 = provider.jitter_point_cloud(object_data, sigma=0.001, clip=0.005) #给数据加噪一次 object_data2 = provider.jitter_point_cloud(object_data, sigma=0.001, clip=0.005) #给数据加噪两次 object_data = np.vstack((object_data1, object_data2)) object_labels = np.vstack((object_labels, object_labels)) object_seg = np.vstack((object_seg, object_seg)) #合并所有数据 for i in range(num_train_file): cur_train_filename = os.path.join(hdf5_data_dir, train_file_list[i]) cur_data, cur_labels, cur_seg = provider.loadDataFile_with_seg( cur_train_filename) object_data = np.vstack((object_data, cur_data)) object_labels = np.vstack((object_labels, cur_labels)) object_seg = np.vstack((object_seg, cur_seg)) object_data, object_labels, object_seg = provider.shuffle_data_with_seg( object_data, object_labels, object_seg) #将数据分成几个文件 n_object = object_data.shape[0] num_every_file = n_object // 8 for i in range(8): f = h5py.File(hdf5_data_dir + '/object_aug' + str(i) + '.h5', 'w') f['data'] = object_data[i * (num_every_file):(i + 1) * num_every_file, :, :] f['label'] = object_labels[i * (num_every_file):(i + 1) * num_every_file] f['pid'] = object_seg[i * (num_every_file):(i + 1) * num_every_file, :] f.close()
def train_one_epoch(self, sess, ops, train_writer): """ ops: dict mapping from string to tf ops """ is_training = True # Shuffle train samples train_idxs = np.arange(0, self.train_data.__len__( )) # train_idx ,idx is a list [1263, 396,1309 .... 41 398 495] np.random.shuffle(train_idxs) num_batches = int(math.ceil((1.0 * self.train_sz) / self.batch_sz)) self.log_string(str(datetime.now())) total_correct = 0 total_seen = 0 loss_sum = 0 for batch_idx in range(num_batches): start_idx = batch_idx * self.batch_sz end_idx = (batch_idx + 1) * self.batch_sz batch_data, batch_label, batch_smpw = self.get_batch_wdp( self.train_data, train_idxs, start_idx, end_idx) # Augment batched point clouds by rotation and jitter if FLAGS.extra_dims: aug_data = np.concatenate((provider.rotate_point_cloud_z( batch_data[:, :, 0:3]), batch_data[:, :, 3:]), axis=2) aug_data = np.concatenate((provider.jitter_point_cloud( aug_data[:, :, 0:3]), aug_data[:, :, 3:]), axis=2) else: aug_data = provider.rotate_point_cloud_z(batch_data) aug_data = provider.jitter_point_cloud(aug_data) feed_dict = { ops['pointclouds_pl']: aug_data, ops['labels_pl']: batch_label, ops['smpws_pl']: batch_smpw, ops['is_training_pl']: is_training, } summary, step, _, loss_val, pred_val = sess.run( [ ops['merged'], ops['step'], ops['train_op'], ops['loss'], ops['pred'] ], feed_dict=feed_dict) train_writer.add_summary(summary, step) # pred_val = np.argmax(pred_val, 2) correct = np.sum(pred_val == batch_label) total_correct += correct total_seen += (self.batch_sz * self.point_sz) loss_sum += loss_val if (batch_idx + 1) % 5 == 0: self.log_string(' -- %03d / %03d --' % (batch_idx + 1, num_batches)) self.log_string('mean loss: %f' % (loss_sum / 5)) self.log_string('accuracy: %f' % (total_correct / float(total_seen))) total_correct = 0 total_seen = 0 loss_sum = 0
def train_one_epoch(sess, ops, train_writer, epoch): """ ops: dict mapping from string to tf ops """ is_training = True batch_size = cfg.training.batch_size train_idxs = copy.deepcopy(TRAIN_INDICES) np.random.shuffle(train_idxs) num_batches = len(train_idxs) // batch_size loss_sum = 0 pbar = tqdm(range(num_batches), desc=f'train', postfix=dict(last_loss_str='')) for batch_idx in pbar: # logger.info('----- batch ' + str(batch_idx) + ' -----') start_idx = batch_idx * batch_size end_idx = (batch_idx + 1) * batch_size pcs1, pcs2, translations, rel_angles, pc1centers, pc2centers, pc1angles, pc2angles = provider.load_batch( train_idxs[start_idx:end_idx]) # Augment batched point clouds by jittering pcs1 = provider.jitter_point_cloud(pcs1) pcs2 = provider.jitter_point_cloud(pcs2) feed_dict = { ops['pcs1']: pcs1, ops['pcs2']: pcs2, ops['translations']: translations, ops['rel_angles']: rel_angles, ops['is_training_pl']: is_training, ops['pc1centers']: pc1centers, ops['pc2centers']: pc2centers, ops['pc1angles']: pc1angles, ops['pc2angles']: pc2angles, } summary, step, _, loss_val, pred_translations, pred_remaining_angle_logits = sess.run( [ ops['merged'], ops['step'], ops['train_op'], ops['loss'], ops['pred_translations'], ops['pred_remaining_angle_logits'] ], feed_dict=feed_dict) # step_in_epochs = float(epoch) + float(end_idx / len(train_idxs)) train_writer.add_summary(summary, step) # pred_val = np.argmax(pred_val, 1) # correct = np.sum(pred_val == current_label[start_idx:end_idx]) # total_correct += correct # total_seen += cfg.training.batch_size loss_sum += loss_val pbar.set_postfix(last_loss_str=f'{loss_val:.5f}') # if batch_idx == 0: # logger.info(np.concatenate([pred_val, transforms], axis=1)[:5,:]) logger.info('train mean loss: %f' % (loss_sum / float(num_batches))) # logger.info('accuracy: %f' % (total_correct / float(total_seen))) train_writer.flush()
def _augment_batch_data(self, batch_data): jittered_data = provider.random_scale_point_cloud(batch_data[:, :, 0:3]) jittered_data = provider.shift_point_cloud(jittered_data) jittered_data = provider.jitter_point_cloud(jittered_data) batch_data[:, :, 0:3] = jittered_data return provider.shuffle_points(batch_data)
def provide_data(): while (True): BATCH_SIZE = 32 current_data, current_label = provider.loadDataFile( './data/modelnet40_ply_hdf5_2048/train_all.h5') current_data, current_label, _ = provider.shuffle_data( current_data, np.squeeze(current_label)) current_label = np.squeeze(current_label) file_size = current_data.shape[0] num_batches = file_size // BATCH_SIZE for batch_idx in range(num_batches): start_idx = batch_idx * BATCH_SIZE end_idx = (batch_idx + 1) * BATCH_SIZE # mantipulation data rotated_data = provider.rotate_point_cloud( current_data[start_idx:end_idx, :, :]) jittered_data = provider.jitter_point_cloud(rotated_data) # mantipulate labe one_hot_labe = np.zeros((BATCH_SIZE, 40)) one_hot_labe[np.arange(BATCH_SIZE), current_label[start_idx:end_idx]] = 1 #out['data'] = jittered_data #out['labe'] = one_hot_labe yield jittered_data, one_hot_labe
def get_batch(self, data_aug=False): data, sem_label, ins_label = self.data_queue.get() if data_aug and self.split == 'train': data[:, :, 0:3] = provider.jitter_point_cloud(data[:, :, 0:3]) return data, sem_label, ins_label
def eval_one_epoch(sess, ops, test_writer): """ ops: dict mapping from string to tf ops """ is_training = True # Shuffle train files train_file_idxs = np.arange(0, len(TRAIN_FILES)) #np.random.shuffle(train_file_idxs) for fn in range(1): log_string('----' + str(fn) + '-----') current_data, current_label = provider.loadDataFile( TRAIN_FILES[train_file_idxs[3]]) current_data = current_data[:, 0:NUM_POINT, :] current_label = np.squeeze(current_label) file_size = current_data.shape[0] num_batches = file_size // BATCH_SIZE total_correct = 0 total_seen = 0 loss = 0 for batch_idx in range(1): start_idx = batch_idx * BATCH_SIZE end_idx = (batch_idx + 1) * BATCH_SIZE orig_pcs = current_data[start_idx:end_idx, :, :] orig_pcs = np.asarray([pc3nr1, pc3nr2]) # Augment batched point clouds by rotation and jittering #rotated_data = provider.rotate_point_cloud(orig_pcs) jittered_data = provider.jitter_point_cloud(orig_pcs) used_pcs = jittered_data feed_dict = { ops['pointclouds_pl']: orig_pcs, ops['goal_pcs']: orig_pcs, ops['labels_pl']: current_label[start_idx:end_idx], ops['is_training_pl']: is_training, } summary, step, _, loss_val, pred_val = sess.run( [ ops['merged'], ops['step'], ops['train_op'], ops['loss'], ops['pred'] ], feed_dict=feed_dict) test_writer.add_summary(summary, step) #pred_val = tf.convert_to_tensor(pred_val) #print(pred_val.get_shape().as_list()) #used_pcs_tensor = tf.convert_to_tensor(used_pcs) #print(used_pcs_tensor.get_shape().as_list()) #loss = tf.reduce_sum(tf.square(tf.subtract(pred_val, used_pcs_tensor))) #loss = tf.reduce_sum(tf.square(tf.subtract(pred_val, used_pcs_tensor))) plotPC(used_pcs[0]) plotPC(pred_val[0]) plotPC(used_pcs[1]) plotPC(pred_val[1]) loss = np.sum(np.square(np.subtract(pred_val, orig_pcs))) #print(loss.get_shape().as_list()) #tf.Print(loss, [loss]) log_string('mean loss: %f32' % loss)
def train_one_epoch(sess, ops, train_writer, adv=True): """ ops: dict mapping from string to tf ops """ is_training = True # 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)): log_string('----' + str(fn) + '-----') current_data, current_label = provider.loadDataFile(TRAIN_FILES[train_file_idxs[fn]]) current_data = current_data[:,0:NUM_POINT,:] # [:,0:NUM_POINT,:] current_data, current_label, _ = provider.shuffle_data(current_data, np.squeeze(current_label)) current_label = np.squeeze(current_label) file_size = current_data.shape[0] num_batches = file_size // BATCH_SIZE total_correct = 0 total_seen = 0 loss_sum = 0 for batch_idx in range(num_batches): start_idx = batch_idx * BATCH_SIZE end_idx = (batch_idx+1) * BATCH_SIZE # Augment batched point clouds by rotation and jittering rotated_data = provider.rotate_point_cloud(current_data[start_idx:end_idx, :, :]) jittered_data = provider.jitter_point_cloud(rotated_data) if adv == True: adv_data = perturb(jittered_data,current_label[start_idx:end_idx],sess,ops,EPS,ADV_STEP,EPS/10) feed_dict_adv = {ops['pointclouds_pl']: adv_data, ops['labels_pl']: current_label[start_idx:end_idx], ops['is_training_pl']: is_training, ops['is_outer']: True} summary, step, _, loss_val, pred_val, bn_decay = sess.run([ops['merged'], ops['step'], ops['train_op'], ops['loss'], ops['pred'], ops['bn_decay']], feed_dict=feed_dict_adv) else: feed_dict = {ops['pointclouds_pl']: jittered_data, ops['labels_pl']: current_label[start_idx:end_idx], ops['is_training_pl']: is_training,ops['is_outer']: True} summary, step, _, loss_val, pred_val, bn_decay = sess.run([ops['merged'], ops['step'], ops['train_op'], ops['loss'], ops['pred'], ops['bn_decay']], feed_dict=feed_dict) # log_string('bn_decay: %f' % bn_decay) train_writer.add_summary(summary, step) pred_val = np.argmax(pred_val, 1) correct = np.sum(pred_val == current_label[start_idx:end_idx]) total_correct += correct total_seen += BATCH_SIZE loss_sum += loss_val log_string('mean loss: %f' % (loss_sum / float(num_batches))) log_string('accuracy: %f' % (total_correct / float(total_seen)))
def _augment_pc(self, pc): """ Augments point cloud with jitter and dropout according to config Arguments: pc {np.ndarray} -- Nx3 point cloud Returns: np.ndarray -- augmented point cloud """ # not used because no artificial occlusion if 'occlusion_nclusters' in self._pc_augm_config and self._pc_augm_config[ 'occlusion_nclusters'] > 0: pc = self.apply_dropout( pc, self._pc_augm_config['occlusion_nclusters'], self._pc_augm_config['occlusion_dropout_rate']) if 'sigma' in self._pc_augm_config and self._pc_augm_config[ 'sigma'] > 0: pc = provider.jitter_point_cloud( pc[np.newaxis, :, :], sigma=self._pc_augm_config['sigma'], clip=self._pc_augm_config['clip'])[0] return pc[:, :3]
def train_one_epoch(sess, ops, train_writer): """ ops: dict mapping from string to tf ops """ is_training = True current_data, current_label, current_mask = data_utils.get_current_data_withmask_h5( TRAIN_DATA, TRAIN_LABELS, TRAIN_MASKS, NUM_POINT) current_label = np.squeeze(current_label) current_mask = np.squeeze(current_mask) num_batches = current_data.shape[0] // BATCH_SIZE total_correct = 0 total_seen = 0 loss_sum = 0 total_correct_seg = 0 classify_loss_sum = 0 seg_loss_sum = 0 for batch_idx in range(num_batches): start_idx = batch_idx * BATCH_SIZE end_idx = (batch_idx + 1) * BATCH_SIZE # Augment batched point clouds by rotation and jittering rotated_data = provider.rotate_point_cloud( current_data[start_idx:end_idx, :, :]) jittered_data = provider.jitter_point_cloud(rotated_data) feed_dict = { ops['pointclouds_pl']: jittered_data, ops['labels_pl']: current_label[start_idx:end_idx], ops['masks_pl']: current_mask[start_idx:end_idx], ops['is_training_pl']: is_training, } summary, step, _, loss_val, pred_val, seg_val, classify_loss, seg_loss = sess.run( [ ops['merged'], ops['step'], ops['train_op'], ops['loss'], ops['pred'], ops['seg_pred'], ops['classify_loss'], ops['seg_loss'] ], feed_dict=feed_dict) train_writer.add_summary(summary, step) pred_val = np.argmax(pred_val, 1) correct = np.sum(pred_val == current_label[start_idx:end_idx]) seg_val = np.argmax(seg_val, 2) seg_correct = np.sum(seg_val == current_mask[start_idx:end_idx]) total_correct_seg += seg_correct total_correct += correct total_seen += BATCH_SIZE loss_sum += loss_val classify_loss_sum += classify_loss seg_loss_sum += seg_loss log_string('mean loss: %f' % (loss_sum / float(num_batches))) log_string('classify mean loss: %f' % (classify_loss_sum / float(num_batches))) log_string('seg mean loss: %f' % (seg_loss_sum / float(num_batches))) log_string('accuracy: %f' % (total_correct / float(total_seen))) log_string('seg accuracy: %f' % (total_correct_seg / (float(total_seen) * NUM_POINT)))
def train_one_epoch(sess, ops, train_writer): """ ops: dict mapping from string to tf ops """ is_training = True # Shuffle train files train_file_idxs = np.arange(0, len(TRAIN_FILES)) # 每一次的5个train文件的顺序都是不一样的 np.random.shuffle(train_file_idxs) for fn in range(len(TRAIN_FILES)): # 对每一个train文件 log_string('----train file' + str(fn) + '-----') current_data, current_label = provider.loadDataFile( TRAIN_FILES[train_file_idxs[fn]]) current_data = current_data[:, 0: NUM_POINT, :] # 采样1024个点,current代表这个文件中所有的点云 current_data, current_label, _ = provider.shuffle_data( current_data, np.squeeze(current_label)) # 每个点云之间的顺序被打乱 current_label = np.squeeze(current_label) # 移除数组中单一维度的数据 file_size = current_data.shape[0] # 点云的总数 num_batches = file_size // BATCH_SIZE # 需要几个batch total_correct = 0 total_seen = 0 loss_sum = 0 for batch_idx in range(num_batches): start_idx = batch_idx * BATCH_SIZE end_idx = (batch_idx + 1) * BATCH_SIZE # Augment batched point clouds by rotation and jittering rotated_data = provider.rotate_point_cloud( current_data[start_idx:end_idx, :, :]) jittered_data = provider.jitter_point_cloud(rotated_data) jittered_data = provider.random_scale_point_cloud(jittered_data) jittered_data = provider.rotate_perturbation_point_cloud( jittered_data) jittered_data = provider.shift_point_cloud(jittered_data) feed_dict = { ops['pointclouds_pl']: jittered_data, ops['labels_pl']: current_label[start_idx:end_idx], ops['is_training_pl']: is_training, } # feed_dict的key一定是place_holder summary, step, _, loss_val, pred_val = sess.run( [ ops['merged'], ops['step'], ops['train_op'], ops['loss'], ops['pred'] ], feed_dict=feed_dict) print("--train file:{}, batch_idx:{},step:{}".format( str(fn), str(batch_idx), str(step))) train_writer.add_summary(summary, step) # 只有train才保存训练过程的曲线 pred_val = np.argmax(pred_val, 1) correct = np.sum(pred_val == current_label[start_idx:end_idx]) total_correct += correct total_seen += BATCH_SIZE loss_sum += loss_val log_string('mean loss: %f' % (loss_sum / float(num_batches))) log_string('accuracy: %f' % (total_correct / float(total_seen)))
def train_one_epoch(sess, ops, train_writer, dataset, verbose=True): """ Train model for one epoch """ global EPOCH_CNT is_training = True # Shuffle train samples train_idxs = np.arange(0, len(dataset)) np.random.shuffle(train_idxs) num_batches = len(dataset) / FLAGS['BATCH_SIZE'] # discards samples if dataset not divisible by batch size log_string('[' + str(datetime.now()) + ' | EPOCH ' + str(EPOCH_CNT) + '] Starting training.', printout=False) loss_sum, batch_print_steps = 0, 10 for batch_idx in range(num_batches): start_idx, end_idx = batch_idx * FLAGS['BATCH_SIZE'], (batch_idx + 1) * FLAGS['BATCH_SIZE'] batch_data, batch_label = get_batch(dataset, train_idxs, start_idx, end_idx) # Perturb point clouds: batch_data[:,:,:3] = provider.jitter_point_cloud(batch_data[:,:,:3]) batch_data[:,:,:3] = provider.rotate_perturbation_point_cloud(batch_data[:,:,:3]) batch_data[:,:,:3] = provider.shift_point_cloud(batch_data[:,:,:3]) batch_data[:,:,:3] = provider.random_point_dropout(batch_data[:,:,:3], max_dropout_ratio=FLAGS['MAX_POINT_DROPOUT_RATIO']) feed_dict = {ops['pointclouds_pl']: batch_data, ops['labels_pl']: batch_label, ops['is_training_pl']: is_training} summary, step, _, loss_val, pred_val = sess.run([ops['merged'], ops['step'], ops['train_op'], ops['loss'], ops['pred']], feed_dict=feed_dict) train_writer.add_summary(summary, step) loss_sum += loss_val if batch_idx % batch_print_steps == 0: log_string('[Batch %03d] Mean Loss: %f' % ((batch_idx + 1), (loss_sum / batch_print_steps)), printout=verbose) loss_sum = 0
def train_one_epoch(sess, ops, train_writer): """ ops: dict mapping from string to tf ops """ is_training = True # 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)): log_string('----' + str(fn) + '-----') current_data, current_label, normal_data = provider.loadDataFile_with_normal( TRAIN_FILES[train_file_idxs[fn]]) normal_data = normal_data[:, 0:NUM_POINT, :] current_data = current_data[:, 0:NUM_POINT, :] current_data, current_label, shuffle_idx = provider.shuffle_data( current_data, np.squeeze(current_label)) current_label = np.squeeze(current_label) normal_data = normal_data[shuffle_idx, ...] file_size = current_data.shape[0] num_batches = file_size // BATCH_SIZE total_correct = 0 total_seen = 0 loss_sum = 0 for batch_idx in range(num_batches): start_idx = batch_idx * BATCH_SIZE end_idx = (batch_idx + 1) * BATCH_SIZE # Augment batched point clouds by rotation and jittering rotated_data = provider.rotate_point_cloud( current_data[start_idx:end_idx, :, :]) jittered_data = provider.jitter_point_cloud(rotated_data) input_data = np.concatenate( (jittered_data, normal_data[start_idx:end_idx, :, :]), 2) #random point dropout input_data = provider.random_point_dropout(input_data) feed_dict = { ops['pointclouds_pl']: input_data, ops['labels_pl']: current_label[start_idx:end_idx], ops['is_training_pl']: is_training, } summary, step, _, loss_val, pred_val = sess.run( [ ops['merged'], ops['step'], ops['train_op'], ops['loss'], ops['pred'] ], feed_dict=feed_dict) train_writer.add_summary(summary, step) pred_val = np.argmax(pred_val, 1) correct = np.sum(pred_val == current_label[start_idx:end_idx]) total_correct += correct total_seen += BATCH_SIZE loss_sum += loss_val log_string('mean loss: %f' % (loss_sum / float(num_batches))) log_string('accuracy: %f' % (total_correct / float(total_seen)))
def train_one_epoch(sess, ops, train_writer): """ ops: dict mapping from string to tf ops """ is_training = True # 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)): log_string('----' + str(fn) + '-----') current_data, current_label = provider.loadDataFile( TRAIN_FILES[train_file_idxs[fn]]) current_data = current_data[:, 0:NUM_POINT, :] current_data, current_label, _ = provider.shuffle_data( current_data, np.squeeze(current_label)) current_label = np.squeeze(current_label) file_size = current_data.shape[0] num_batches = file_size // BATCH_SIZE total_correct = 0 total_seen = 0 loss_sum = 0 # 在一个epoch 中逐个mini-batch训练直至遍历完一遍训练集。计算总分类正确数total_correct和已遍历样本数 # total_senn,总损失loss_sum. for batch_idx in range(num_batches): start_idx = batch_idx * BATCH_SIZE end_idx = (batch_idx + 1) * BATCH_SIZE # Augment batched point clouds by rotation and jittering # 调用provider中rotate_point_cloud rotated_data = provider.rotate_point_cloud( current_data[start_idx:end_idx, :, :]) jittered_data = provider.jitter_point_cloud(rotated_data) feed_dict = { ops['pointclouds_pl']: jittered_data, ops['labels_pl']: current_label[start_idx:end_idx], ops['is_training_pl']: is_training, } summary, step, _, loss_val, pred_val = sess.run( [ ops['merged'], ops['step'], ops['train_op'], ops['loss'], ops['pred'] ], feed_dict=feed_dict) # 训练,使用 tf 的 session 运行设计的框架,ops['pred'] 为整个网络,feed_dict 为网络提供的数据 train_writer.add_summary(summary, step) pred_val = np.argmax(pred_val, 1) correct = np.sum(pred_val == current_label[start_idx:end_idx]) total_correct += correct total_seen += BATCH_SIZE loss_sum += loss_val # 记录平均loss,以及平均accuracy。 log_string('mean loss: %f' % (loss_sum / float(num_batches))) log_string('accuracy: %f' % (total_correct / float(total_seen)))
def augment_batch_data(batch_data): rotated_data = provider.rotate_point_cloud_with_normal(batch_data) jittered_data = provider.random_scale_point_cloud(rotated_data[:, :, 0:3]) jittered_data = provider.rotate_perturbation_point_cloud(jittered_data) jittered_data = provider.shift_point_cloud(jittered_data) jittered_data = provider.jitter_point_cloud(jittered_data) rotated_data[:, :, 0:3] = jittered_data return rotated_data
def _augment_batch_data(self, batch_data): rotated_data = provider.rotate_point_cloud(batch_data) rotated_data = provider.rotate_perturbation_point_cloud(rotated_data) jittered_data = provider.random_scale_point_cloud(rotated_data[:,:,0:3]) jittered_data = provider.shift_point_cloud(jittered_data) jittered_data = provider.jitter_point_cloud(jittered_data) rotated_data[:,:,0:3] = jittered_data return provider.shuffle_points(rotated_data)
def train_one_epoch(sess, ops, train_writer): """ ops: dict mapping from string to tf ops """ is_training = True # 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)): log_string('----' + str(fn) + '-----') current_data, current_label = provider.loadDataFile( TRAIN_FILES[train_file_idxs[fn]]) current_data = current_data[:, 0:NUM_POINT, :] current_data, current_label, _ = provider.shuffle_data( current_data, np.squeeze(current_label)) current_label = np.squeeze(current_label) file_size = current_data.shape[0] num_batches = file_size // BATCH_SIZE total_correct = 0 total_seen = 0 loss_sum = 0 for batch_idx in range(num_batches): start_idx = batch_idx * BATCH_SIZE end_idx = (batch_idx + 1) * BATCH_SIZE """Mixup""" print("Batch: %d", batch_idx) batch_data, batch_label_a, batch_label_b,lam = \ mixup_data(current_data[start_idx:end_idx, :, :], current_label[start_idx:end_idx], FLAGS.alpha) # Augment batched point clouds by rotation and jittering rotated_data = provider.rotate_point_cloud(batch_data) jittered_data = provider.jitter_point_cloud(rotated_data) feed_dict = { ops['pointclouds_pl']: jittered_data, ops['labels_a_pl']: batch_label_a, ops['labels_b_pl']: batch_label_b, ops['is_training_pl']: is_training, ops['lam_pl']: lam } summary, step, _, loss_val, pred_val = sess.run( [ ops['merged'], ops['step'], ops['train_op'], ops['loss'], ops['pred'] ], feed_dict=feed_dict) train_writer.add_summary(summary, step) pred_val = np.argmax(pred_val, 1) correct_a = np.sum(pred_val == batch_label_a) correct_b = np.sum(pred_val == batch_label_b) total_correct += (lam * correct_a + (1 - lam) * correct_b) total_seen += BATCH_SIZE loss_sum += loss_val log_string('mean loss: %f' % (loss_sum / float(num_batches))) log_string('accuracy: %f' % (total_correct / float(total_seen)))
def train_one_epoch(sess, ops, train_writer): """ ops: dict mapping from string to tf ops """ is_training = True # 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)): log_string('----' + str(fn) + '-----') current_data, current_label = provider.loadDataFile( TRAIN_FILES[train_file_idxs[fn]]) current_data = current_data[:, 0:NUM_POINT, :] current_data, current_label, _ = provider.shuffle_data( current_data, np.squeeze(current_label)) current_label = np.squeeze(current_label) file_size = current_data.shape[0] num_batches = file_size // BATCH_SIZE total_correct = 0 total_seen = 0 loss_sum = 0 for batch_idx in range(num_batches): start_idx = batch_idx * BATCH_SIZE end_idx = (batch_idx + 1) * BATCH_SIZE # Augment batched point clouds by rotation and jittering rotated_data = provider.rotate_point_cloud( current_data[start_idx:end_idx, :, :]) jittered_data = provider.jitter_point_cloud(rotated_data) feed_dict = { ops['pointclouds_pl']: jittered_data, ops['labels_pl']: current_label[start_idx:end_idx], ops['is_training_pl']: is_training, } summary, step, _, loss_val, pred_val, centroids = sess.run( [ ops['merged'], ops['step'], ops['train_op'], ops['loss'], ops['pred'], ops['centroids'] ], feed_dict=feed_dict) train_writer.add_summary(summary, step) pred_val = np.argmax(pred_val, 1) correct = np.sum(pred_val == current_label[start_idx:end_idx]) total_correct += correct total_seen += BATCH_SIZE loss_sum += loss_val if np.random.rand() <= 0.001: h5r = h5py.File( (LOG_DIR + '/demo/centroids' + str(step).zfill(8) + '.h5'), 'w') h5r.create_dataset('data', data=centroids) h5r.close() log_string('mean loss: %f' % (loss_sum / float(num_batches))) log_string('accuracy: %f' % (total_correct / float(total_seen)))
def train_one_epoch(sess, ops, train_writer): """ ops: dict mapping from string to tf ops """ start_time = time.time() is_training = True # 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)): log_string("----" + str(fn) + "-----") current_data, current_label = provider.loadDataFile( TRAIN_FILES[train_file_idxs[fn]] ) current_data = current_data[:, 0:NUM_POINT, :] current_data, current_label, _ = provider.shuffle_data( current_data, np.squeeze(current_label) ) current_label = np.squeeze(current_label) file_size = current_data.shape[0] num_batches = file_size // BATCH_SIZE total_correct = 0 total_seen = 0 loss_sum = 0 for batch_idx in range(num_batches): start_idx = batch_idx * BATCH_SIZE end_idx = (batch_idx + 1) * BATCH_SIZE # Augment batched point clouds by rotation and jittering rotated_data = provider.rotate_point_cloud( current_data[start_idx:end_idx, :, :] ) jittered_data = provider.jitter_point_cloud(rotated_data) feed_dict = { ops["pointclouds_pl"]: jittered_data, ops["labels_pl"]: current_label[start_idx:end_idx], ops["is_training_pl"]: is_training, } summary, step, _, loss_val, pred_val = sess.run( [ops["merged"], ops["step"], ops["train_op"], ops["loss"], ops["pred"]], feed_dict=feed_dict, ) train_writer.add_summary(summary, step) pred_val = np.argmax(pred_val, 1) correct = np.sum(pred_val == current_label[start_idx:end_idx]) total_correct += correct total_seen += BATCH_SIZE loss_sum += loss_val log_string("mean loss: %f" % (loss_sum / float(num_batches))) log_string("accuracy: %f" % (total_correct / float(total_seen))) duration = time.time() - start_time log_string("epoch duration (minutes): %.4f" % (duration / 60.0))
def train_one_epoch(sess, ops, train_writer): """ ops: dict mapping from string to tf ops """ is_training = True # 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)): log_string('----' + str(fn) + '-----') current_data, current_label = provider.loadDataFile( TRAIN_FILES[train_file_idxs[fn]]) current_data = current_data[:, 0:NUM_POINT, :] current_data, current_label, _ = provider.shuffle_data( current_data, np.squeeze(current_label)) current_label = np.squeeze(current_label) file_size = current_data.shape[0] num_batches = file_size // BATCH_SIZE total_correct = 0 total_seen = 0 loss_sum = 0 for batch_idx in range(num_batches): start_idx = batch_idx * BATCH_SIZE end_idx = (batch_idx + 1) * BATCH_SIZE # Augment batched point clouds by rotation and jittering rotated_data = provider.rotate_point_cloud( current_data[start_idx:end_idx, :, :]) jittered_data = provider.jitter_point_cloud(rotated_data) feed_dict = { ops['pointclouds_pl']: jittered_data, ops['labels_pl']: current_label[start_idx:end_idx], ops['is_training_pl']: is_training, } summary, step, _, loss_val, pred_val = sess.run( [ ops['merged'], ops['step'], ops['train_op'], ops['loss'], ops['pred'] ], feed_dict=feed_dict) train_writer.add_summary(summary, step) pred_val = np.argmax(pred_val, 1) correct = np.sum(pred_val == current_label[start_idx:end_idx]) total_correct += correct total_seen += BATCH_SIZE loss_sum += loss_val meanlosslogstr = str(loss_sum / float(num_batches)) accuracylogstr = str(total_correct / float(total_seen)) with open(os.path.join(LOG_DIR, 'trainlog.txt'), 'a') as myfile: myfile.write(meanlosslogstr + ',' + accuracylogstr + '\n') log_string('mean loss: %f' % (loss_sum / float(num_batches))) log_string('accuracy: %f' % (total_correct / float(total_seen)))
def augment(i, cur_data, cur_label, cur_meta, points, labels, meta): # rotated_data = provider.rotate_point_cloud(np.expand_dims(cur_data[i], axis=0)) jittered_data = provider.jitter_point_cloud( np.expand_dims(cur_data[i], axis=0)) translated_data = provider.translate_point_cloud(jittered_data) points.append(np.squeeze(translated_data)) labels.append(cur_label[i]) meta.append(cur_meta[i]) return points, labels, meta
def train_one_epoch(sess, ops, gmm, train_writer): """ ops: dict mapping from string to tf ops """ is_training = True # 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)): log_string('----' + str(fn) + '-----') current_data, current_label = provider.loadDataFile(TRAIN_FILES[train_file_idxs[fn]], compensate = False) # points_idx = range(0,NUM_POINT) points_idx = np.random.choice(range(0,2048),NUM_POINT) current_data = current_data[:, points_idx, :] current_data, current_label, _ = provider.shuffle_data(current_data, np.squeeze(current_label)) current_label = np.squeeze(current_label) file_size = current_data.shape[0] num_batches = file_size / BATCH_SIZE loss_sum = 0 for batch_idx in range(num_batches): start_idx = batch_idx * BATCH_SIZE end_idx = (batch_idx + 1) * BATCH_SIZE # Augment batched point clouds by rotation and jittering augmented_data = current_data[start_idx:end_idx, :, :] if augment_scale: augmented_data = provider.scale_point_cloud(augmented_data, smin=0.66, smax=1.5) if augment_rotation: augmented_data = provider.rotate_point_cloud(augmented_data) if augment_translation: augmented_data = provider.translate_point_cloud(augmented_data, tval = 0.2) if augment_jitter: augmented_data = provider.jitter_point_cloud(augmented_data, sigma=0.01, clip=0.05) # default sigma=0.01, clip=0.05 if augment_outlier: augmented_data = provider.insert_outliers_to_point_cloud(augmented_data, outlier_ratio=0.02) feed_dict = {ops['points_pl']: augmented_data, ops['labels_pl']: current_label[start_idx:end_idx], ops['w_pl']: gmm.weights_, ops['mu_pl']: gmm.means_, ops['sigma_pl']: np.sqrt(gmm.covariances_), ops['is_training_pl']: is_training, } summary, step, _, loss_val, reconstructed_points_val = sess.run([ops['merged'], ops['step'], ops['train_op'], ops['loss'], ops['reconstructed_points']], feed_dict=feed_dict) train_writer.add_summary(summary, step) loss_sum += loss_val log_string('mean loss: %f' % (loss_sum / float(num_batches)))
def train_one_epoch(sess, ops, train_writer): """ ops: dict mapping from string to tf ops """ is_training = True # 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)): log_string('----' + str(fn) + '-----') current_data, current_label = provider.loadDataFile(TRAIN_FILES[train_file_idxs[fn]]) current_data = current_data[:,0:NUM_POINT,:] current_data, current_label, _ = provider.shuffle_data(current_data, np.squeeze(current_label)) current_label = np.squeeze(current_label) file_size = current_data.shape[0] num_batches = file_size // BATCH_SIZE total_correct = 0 total_seen = 0 loss_sum = 0 for batch_idx in range(num_batches): start_idx = batch_idx * BATCH_SIZE end_idx = (batch_idx+1) * BATCH_SIZE # Augment batched point clouds by rotation and jittering rotated_data = provider.rotate_point_cloud(current_data[start_idx:end_idx, :, :]) jittered_data = provider.jitter_point_cloud(rotated_data) jittered_data_json = {'point_clouds': jittered_data.tolist()} # Etract features pointnet response_pointnet = requests.post(pointnet_url, json=jittered_data_json) pointnet_features = np.array(response_pointnet.json()['features']) # Etract features dgcnn response_dgcnn = requests.post(dgcnn_url, json=jittered_data_json) dgcnn_features = np.array(response_dgcnn.json()['features']) # Concatenate point_features = np.concatenate((pointnet_features, dgcnn_features), axis=-1) # Train feed_dict = {ops['features_pl']: point_features, ops['labels_pl']: current_label[start_idx:end_idx], ops['is_training_pl']: is_training,} summary, step, _, loss_val, pred_val = sess.run([ops['merged'], ops['step'], ops['train_op'], ops['loss'], ops['pred']], feed_dict=feed_dict) train_writer.add_summary(summary, step) pred_val = np.argmax(pred_val, 1) correct = np.sum(pred_val == current_label[start_idx:end_idx]) total_correct += correct total_seen += BATCH_SIZE loss_sum += loss_val log_string('mean loss: %f' % (loss_sum / float(num_batches))) log_string('accuracy: %f' % (total_correct / float(total_seen)))
def train_one_epoch(sess, ops, train_writer): """ ops: dict mapping from string to tf ops """ is_training = True # Shuffle train samples train_idxs = np.arange(0, len(TRAIN_DATASET)) np.random.shuffle(train_idxs) num_batches = int(len(TRAIN_DATASET) / BATCH_SIZE) log_string(str(datetime.now())) total_correct = 0 total_seen = 0 loss_sum = 0 pp_loss_sum = 0 for batch_idx in range(num_batches): start_idx = batch_idx * BATCH_SIZE end_idx = (batch_idx + 1) * BATCH_SIZE batch_data, batch_label, batch_cls_label, batch_pp_idx, batch_pp_label = get_batch( TRAIN_DATASET, train_idxs, start_idx, end_idx) # Augment batched point clouds by rotation and jittering #aug_data = batch_data #aug_data = provider.random_scale_point_cloud(batch_data) batch_data[:, :, 0:3] = provider.jitter_point_cloud(batch_data[:, :, 0:3]) feed_dict = { ops['pointclouds_pl']: batch_data, ops['labels_pl']: batch_label, ops['cls_labels_pl']: batch_cls_label, ops['pp_idx_pl']: batch_pp_idx, ops['pp_labels_pl']: batch_pp_label, ops['is_training_pl']: is_training, } summary, step, _, loss_val, pp_loss_val, pred_val, _ = sess.run( [ ops['merged'], ops['step'], ops['train_op'], ops['loss'], ops['pp_loss'], ops['pred'], ops['pp_pred'] ], feed_dict=feed_dict) train_writer.add_summary(summary, step) pred_val = np.argmax(pred_val, 2) correct = np.sum(pred_val == batch_label) total_correct += correct total_seen += (BATCH_SIZE * NUM_POINT) loss_sum += loss_val pp_loss_sum += pp_loss_val if (batch_idx + 1) % 10 == 0: log_string(' -- %03d / %03d --' % (batch_idx + 1, num_batches)) log_string('mean total_loss: %f' % (loss_sum / 10)) log_string('mean pp_loss: %f' % (pp_loss_sum / 10)) log_string('accuracy: %f' % (total_correct / float(total_seen))) total_correct = 0 total_seen = 0 loss_sum = 0 pp_loss_sum = 0
def train_one_epoch(sess, ops, train_writer): """ ops: dict mapping from string to tf ops """ is_training = True # Shuffle train files #train_file_idxs = np.arange(0, len(TRAIN_FILES)) #np.random.shuffle(train_file_idxs) current_data, current_label = provider.loadDataFile(TRAIN_FILES) print(current_data.shape, current_label.shape) #current_data = current_data[:,0:NUM_POINT,:] current_data, current_label, _ = provider.shuffle_data( current_data, np.squeeze(current_label)) #print('2') current_label = np.squeeze(current_label) #print('3') file_size = current_data.shape[0] num_batches = file_size // BATCH_SIZE total_correct = 0 total_seen = 0 loss_sum = 0 #import pdb; pdb.set_trace() for batch_idx in range(num_batches): start_idx = batch_idx * BATCH_SIZE end_idx = (batch_idx + 1) * BATCH_SIZE # Augment batched point clouds by rotation and jittering rotated_data = provider.rotate_point_cloud( current_data[start_idx:end_idx, :, :]) jittered_data = provider.jitter_point_cloud(rotated_data) jittered_data = provider.random_scale_point_cloud(jittered_data) jittered_data = provider.rotate_perturbation_point_cloud(jittered_data) jittered_data = provider.shift_point_cloud(jittered_data) #np.save('outfile.npy', jittered_data[0,...]) feed_dict = { ops['pointclouds_pl']: jittered_data, ops['labels_pl']: current_label[start_idx:end_idx], ops['is_training_pl']: is_training, } summary, step, _, loss_val, pred_val = sess.run([ ops['merged'], ops['step'], ops['train_op'], ops['loss'], ops['pred'] ], feed_dict=feed_dict) train_writer.add_summary(summary, step) pred_val = np.argmax(pred_val, 1) correct = np.sum(pred_val == current_label[start_idx:end_idx]) total_correct += correct total_seen += BATCH_SIZE loss_sum += loss_val print('-' * 10, 'train', '-' * 10) #import pdb; pdb.set_trace() log_string('mean loss: %f' % (loss_sum / float(num_batches))) log_string('accuracy: %f' % (total_correct / float(total_seen)))
def train_one_epoch(sess, ops, gmm, train_writer): """ ops: dict mapping from string to tf ops """ is_training = True if (".h5" in TRAIN_FILE): current_data, current_label = data_utils.get_current_data_h5(TRAIN_DATA, TRAIN_LABELS, NUM_POINT) else: current_data, current_label = data_utils.get_current_data(TRAIN_DATA, TRAIN_LABELS, NUM_POINT) current_label = np.squeeze(current_label) num_batches = current_data.shape[0]//BATCH_SIZE total_correct = 0 total_seen = 0 loss_sum = 0 for batch_idx in range(num_batches): start_idx = batch_idx * BATCH_SIZE end_idx = (batch_idx + 1) * BATCH_SIZE # Augment batched point clouds by rotation and jittering augmented_data = current_data[start_idx:end_idx, :, :] if augment_scale: augmented_data = provider.scale_point_cloud(augmented_data, smin=0.66, smax=1.5) if augment_rotation: augmented_data = provider.rotate_point_cloud(augmented_data) if augment_translation: augmented_data = provider.translate_point_cloud(augmented_data, tval = 0.2) if augment_jitter: augmented_data = provider.jitter_point_cloud(augmented_data, sigma=0.01, clip=0.05) # default sigma=0.01, clip=0.05 if augment_outlier: augmented_data = provider.insert_outliers_to_point_cloud(augmented_data, outlier_ratio=0.02) feed_dict = {ops['points_pl']: augmented_data, ops['labels_pl']: current_label[start_idx:end_idx], ops['w_pl']: gmm.weights_, ops['mu_pl']: gmm.means_, ops['sigma_pl']: np.sqrt(gmm.covariances_), ops['is_training_pl']: is_training, } summary, step, _, loss_val, pred_val = sess.run([ops['merged'], ops['step'], ops['train_op'], ops['loss'], ops['pred']], feed_dict=feed_dict) train_writer.add_summary(summary, step) pred_val = np.argmax(pred_val, 1) correct = np.sum(pred_val == current_label[start_idx:end_idx]) total_correct += correct total_seen += BATCH_SIZE loss_sum += loss_val log_string('mean loss: %f' % (loss_sum / float(num_batches))) log_string('accuracy: %f' % (total_correct / float(total_seen)))
def train_one_epoch(sess, ops, train_writer): """ ops: dict mapping from string to tf ops """ is_training = True # 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)): log_string('----' + str(fn) + '-----') # Load data and labels from the files. current_data, current_label = provider.loadDataFile(TRAIN_FILES[train_file_idxs[fn]]) current_data = current_data[:,0:NUM_POINT,:] # Shuffle the data in the training set. current_data, current_label, _ = provider.shuffle_data(current_data, np.squeeze(current_label)) current_label = np.squeeze(current_label) file_size = current_data.shape[0] num_batches = file_size // BATCH_SIZE total_correct = 0 total_seen = 0 loss_sum = 0 for batch_idx in range(num_batches): start_idx = batch_idx * BATCH_SIZE end_idx = (batch_idx+1) * BATCH_SIZE # Augment batched point clouds by rotating, jittering, shifting, # and scaling. rotated_data = provider.rotate_point_cloud(current_data[start_idx:end_idx, :, :]) jittered_data = provider.jitter_point_cloud(rotated_data) jittered_data = provider.random_scale_point_cloud(jittered_data) jittered_data = provider.rotate_perturbation_point_cloud(jittered_data) jittered_data = provider.shift_point_cloud(jittered_data) # Input the augmented point cloud and labels to the graph. feed_dict = {ops['pointclouds_pl']: jittered_data, ops['labels_pl']: current_label[start_idx:end_idx], ops['is_training_pl']: is_training,} # Calculate the loss and accuracy of the input batch data. summary, step, _, loss_val, pred_val = sess.run([ops['merged'], ops['step'], ops['train_op'], ops['loss'], ops['pred']], feed_dict=feed_dict) train_writer.add_summary(summary, step) pred_val = np.argmax(pred_val, 1) correct = np.sum(pred_val == current_label[start_idx:end_idx]) total_correct += correct total_seen += BATCH_SIZE loss_sum += loss_val log_string('mean loss: %f' % (loss_sum / float(num_batches))) log_string('accuracy: %f' % (total_correct / float(total_seen)))
def train_one_epoch(CURR_DATA, CURR_LABELS, sess, ops, train_writer): """ ops: dict mapping from string to tf ops """ is_training = True # Shuffle train files # train_file_idxs = np.arange(0, len(TRAIN_FILES)) # np.random.shuffle(train_file_idxs) train_files_idx = np.arange(0, CURR_DATA.shape[0]) np.random.shuffle(train_files_idx) CURR_DATA, CURR_LABELS = CURR_DATA[ train_files_idx, :, :], CURR_LABELS[train_files_idx] # for fn in range(len(TRAIN_FILES)): # log_string('----' + str(fn) + '-----') # current_data, current_label = provider.loadDataFile(TRAIN_FILES[train_file_idxs[fn]]) # current_data = current_data[:,0:NUM_POINT,:] # current_data, current_label, _ = provider.shuffle_data(current_data, np.squeeze(current_label)) # current_label = np.squeeze(current_label) file_size = CURR_DATA.shape[0] num_batches = file_size // BATCH_SIZE total_correct = 0 total_seen = 0 loss_sum = 0 for batch_idx in range(num_batches): start_idx = batch_idx * BATCH_SIZE end_idx = (batch_idx + 1) * BATCH_SIZE # Augment batched point clouds by rotation and jittering rotated_data = provider.rotate_point_cloud( CURR_DATA[start_idx:end_idx, :, :]) jittered_data = provider.jitter_point_cloud(rotated_data) feed_dict = { ops['pointclouds_pl']: jittered_data, ops['labels_pl']: CURR_LABELS[start_idx:end_idx], ops['is_training_pl']: is_training, } summary, step, _, loss_val, pred_val = sess.run([ ops['merged'], ops['step'], ops['train_op'], ops['loss'], ops['pred'] ], feed_dict=feed_dict) train_writer.add_summary(summary, step) pred_val = np.argmax(pred_val, 1) correct = np.sum(pred_val == CURR_LABELS[start_idx:end_idx]) total_correct += correct total_seen += BATCH_SIZE loss_sum += loss_val log_string('mean loss: %f' % (loss_sum / float(num_batches))) log_string('accuracy: %f' % (total_correct / float(total_seen)))
def train_one_epoch(config, sess, ops, epoch): is_training = True # 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)): current_data, current_label = provider.loadDataFile( TRAIN_FILES[train_file_idxs[fn]]) current_data = current_data[:, 0:config.num_points, :] current_data, current_label, _ = provider.shuffle_data( current_data, np.squeeze(current_label)) current_label = np.squeeze(current_label) file_size = current_data.shape[0] num_batches = file_size // config.batch_size total_correct = 0 total_seen = 0 losses = [] for batch_idx in range(num_batches): start_idx = batch_idx * config.batch_size end_idx = (batch_idx + 1) * config.batch_size # Augment batched point clouds by rotation and jittering rotated_data = provider.rotate_point_cloud( current_data[start_idx:end_idx, :, :]) jittered_data = provider.jitter_point_cloud(rotated_data) feed_dict = { ops['pointclouds_pl']: jittered_data, ops['labels_pl']: current_label[start_idx:end_idx], ops['is_training_pl']: is_training, } step, _, loss_val, pred_val = sess.run( [ops['step'], ops['train_op'], ops['loss'], ops['pred']], feed_dict=feed_dict) pred_val = np.argmax(pred_val, 1) correct = np.sum(pred_val == current_label[start_idx:end_idx]) total_correct += correct total_seen += config.batch_size losses.append(loss_val) if batch_idx % max(config.train_log_frq / config.batch_size, 1) == 0: acc = total_correct / float(total_seen) loss = np.mean(losses) losses = [] log( config.log_file, 'TRAINING EPOCH {} - accuracy: {} loss: {}'.format( epoch, acc, loss)) LOSS_LOGGER.log(loss, epoch, "train_loss") ACC_LOGGER.log(acc, epoch, "train_accuracy")
def get_example(self, i): if self.augment: rotated_data = provider.rotate_point_cloud(self.data[i:i + 1, :, :]) jittered_data = provider.jitter_point_cloud(rotated_data) point_data = jittered_data[0] else: point_data = self.data[i] point_data = np.transpose(point_data.astype(np.float32), (1, 0))[:, :, None] return point_data, self.label[i]
def _augment_batch_data(self, batch_data): if self.normal_channel: rotated_data = provider.rotate_point_cloud_with_normal(batch_data) rotated_data = provider.rotate_perturbation_point_cloud_with_normal(rotated_data) else: rotated_data = provider.rotate_point_cloud(batch_data) rotated_data = provider.rotate_perturbation_point_cloud(rotated_data) jittered_data = provider.random_scale_point_cloud(rotated_data[:,:,0:3]) jittered_data = provider.shift_point_cloud(jittered_data) jittered_data = provider.jitter_point_cloud(jittered_data) rotated_data[:,:,0:3] = jittered_data return provider.shuffle_points(rotated_data)
def train_one_epoch(sess, ops, train_writer): """ ops: dict mapping from string to tf ops """ is_training = True # 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)): log_string('----' + str(fn) + '-----') current_data, current_label = provider.loadDataFile(TRAIN_FILES[train_file_idxs[fn]]) current_data = current_data[:,0:NUM_POINT,:] current_data, current_label, _ = provider.shuffle_data(current_data, np.squeeze(current_label)) current_label = np.squeeze(current_label) file_size = current_data.shape[0] num_batches = file_size // BATCH_SIZE total_correct = 0 total_seen = 0 loss_sum = 0 for batch_idx in range(num_batches): start_idx = batch_idx * BATCH_SIZE end_idx = (batch_idx+1) * BATCH_SIZE # Augment batched point clouds by rotation and jittering rotated_data = provider.rotate_point_cloud(current_data[start_idx:end_idx, :, :]) jittered_data = provider.jitter_point_cloud(rotated_data) feed_dict = {ops['pointclouds_pl']: jittered_data, ops['labels_pl']: current_label[start_idx:end_idx], ops['is_training_pl']: is_training,} summary, step, _, loss_val, pred_val = sess.run([ops['merged'], ops['step'], ops['train_op'], ops['loss'], ops['pred']], feed_dict=feed_dict) train_writer.add_summary(summary, step) pred_val = np.argmax(pred_val, 1) correct = np.sum(pred_val == current_label[start_idx:end_idx]) total_correct += correct total_seen += BATCH_SIZE loss_sum += loss_val log_string('mean loss: %f' % (loss_sum / float(num_batches))) log_string('accuracy: %f' % (total_correct / float(total_seen)))
def train_one_epoch(sess, ops, train_writer): """ ops: dict mapping from string to tf ops """ is_training = True # Shuffle train samples train_idxs = np.arange(0, len(TRAIN_DATASET)) np.random.shuffle(train_idxs) num_batches = len(TRAIN_DATASET)/BATCH_SIZE log_string(str(datetime.now())) total_correct = 0 total_seen = 0 loss_sum = 0 for batch_idx in range(num_batches): start_idx = batch_idx * BATCH_SIZE end_idx = (batch_idx+1) * BATCH_SIZE batch_data, batch_label, batch_cls_label = get_batch(TRAIN_DATASET, train_idxs, start_idx, end_idx) # Augment batched point clouds by rotation and jittering #aug_data = batch_data #aug_data = provider.random_scale_point_cloud(batch_data) batch_data[:,:,0:3] = provider.jitter_point_cloud(batch_data[:,:,0:3]) feed_dict = {ops['pointclouds_pl']: batch_data, ops['labels_pl']: batch_label, ops['cls_labels_pl']: batch_cls_label, ops['is_training_pl']: is_training,} summary, step, _, loss_val, pred_val = sess.run([ops['merged'], ops['step'], ops['train_op'], ops['loss'], ops['pred']], feed_dict=feed_dict) train_writer.add_summary(summary, step) pred_val = np.argmax(pred_val, 2) correct = np.sum(pred_val == batch_label) total_correct += correct total_seen += (BATCH_SIZE*NUM_POINT) loss_sum += loss_val if (batch_idx+1)%10 == 0: log_string(' -- %03d / %03d --' % (batch_idx+1, num_batches)) log_string('mean loss: %f' % (loss_sum / 10)) log_string('accuracy: %f' % (total_correct / float(total_seen))) total_correct = 0 total_seen = 0 loss_sum = 0