def main(_): hooks = [ tf.train.LoggingTensorHook(['train_accuracy', 'train_loss'], every_n_iter=10) ] NUM_GPUS = 3 strategy = tf.contrib.distribute.MirroredStrategy(num_gpus=NUM_GPUS) config = tf.estimator.RunConfig(train_distribute=strategy) #estimator = tf.keras.estimator.model_to_estimator(model, config=config) mnist_classifier = tf.estimator.Estimator(model_fn=model_function, model_dir=FLAGS.model_dir, config=config) timer('TRAIN_AND_EVALUATE') for _ in range(FLAGS.num_epochs): mnist_classifier.train( input_fn=train_data, hooks=hooks, ) mnist_classifier.evaluate(input_fn=eval_data) timer()
def calibrate(): data = parse_data() end = timer() homographies = compute_homography(data) end("Homography Estimation") print "homographies" print homographies end = timer() intrinsics = get_camera_intrinsics(homographies) end("Intrinsics") print "intrinsics" print intrinsics end = timer() extrinsics = get_camera_extrinsics(intrinsics, homographies) end("Extrinsics") print "extrinsics" print extrinsics end = timer() distortion = estimate_lens_distortion(intrinsics, extrinsics, data["real"], data["sensed"]) end("Distortion") return
def calibrate(): data = prepare_data() #print(data) end = timer() homographies = compute_homography(data) end("Homography Estimation") print("homographies") print(homographies) end = timer() intrinsics = get_camera_intrinsics(homographies) end("Intrinsics") print("intrinsics") print(intrinsics) end = timer() extrinsics = get_camera_extrinsics(intrinsics, homographies) end("Extrinsics") print("extrinsics") print(extrinsics) return
def compute_homography(data): end = timer() real = data['real'] es = [] for i in range(0, len(data['sensed'])): sensed = data['sensed'][i] estimated = estimate_homography(real, sensed) es.append(estimated) end = timer() end("compute_homography") return np.array(es)
def rSort(self): for i in range(1000, 101000 + 1, 10000): # Radix sort current_file_path = self.current_file_path(i) init_array = self.get_correct_array(current_file_path) start_time = timer() number_of_operations = radixsort.radix_sort(init_array) end_time = timer() algorithm_time = get_difference(start_time, end_time) number_of_elements = i self.save_to_file("radixsort", number_of_elements, number_of_operations, algorithm_time)
def compute_homography(data): end = timer() real = data['real'] refined_homographies = [] for i in range(0, len(data['sensed'])): sensed = data['sensed'][i] estimated = estimate_homography(real, sensed) end = timer() refined = refine_homography(estimated, sensed, real) refined = refined / refined[-1] end("refine_homography") refined_homographies.append(estimated) end("compute_homography") return np.array(refined_homographies)
def get_normalisation_matrix(flattened_corners): end = timer() avg_x = flattened_corners[:, 0].mean() avg_y = flattened_corners[:, 1].mean() s_x = np.sqrt(2 / flattened_corners[0].std()) s_y = np.sqrt(2 / flattened_corners[1].std()) end("get_normalization_matrix") return np.matrix([[s_x, 0, -s_x * avg_x], [0, s_y, -s_y * avg_y], [0, 0, 1]])
def make_bottleneck_data(src_dir, shape, ratio): filenames_data = make_filenames_list_from_subdir(src_dir=src_dir, shape=shape, ratio=ratio) dataset = make_tf_dataset(filenames_data) timer('make_bottleneck') bottleneck_data = make_bottleneck_with_tf(dataset, shape=SHAPE) bottleneck_data['id_label'] = filenames_data['id_label'] bottleneck_data['label_id'] = filenames_data['label_id'] bottleneck_data['num_classes'] = filenames_data['num_classes'] print('Train size:', len(bottleneck_data['train']['images'])) print('Valid size:', len(bottleneck_data['valid']['images'])) print('Test size:', len(bottleneck_data['test']['images'])) return bottleneck_data
def estimate_homography(first, second): end = timer() first_normalisation_matrix = get_normalisation_matrix(first) second_normalisation_matrix = get_normalisation_matrix(second) M = [] for j in range(0, int(first.size / 2)): homogeneous_first = np.array([ first[j][0], first[j][1], 1 ]) homogeneous_second = np.array([ second[j][0], second[j][1], 1 ]) pr_1 = np.dot(first_normalisation_matrix, homogeneous_first) pr_2 = np.dot(second_normalisation_matrix, homogeneous_second) M.append(np.array([ pr_1.item(0), pr_1.item(1), 1, 0, 0, 0, -pr_1.item(0)*pr_2.item(0), -pr_1.item(1)*pr_2.item(0), -pr_2.item(0) ])) M.append(np.array([ 0, 0, 0, pr_1.item(0), pr_1.item(1), 1, -pr_1.item(0)*pr_2.item(1), -pr_1.item(1)*pr_2.item(1), -pr_2.item(1) ])) U, S, Vh = np.linalg.svd(np.array(M).reshape((512, 9))) L = Vh[-1] H = L.reshape(3, 3) denormalised = np.dot( np.dot( np.linalg.inv(first_normalisation_matrix), H ), second_normalisation_matrix ) end("estimate_homography") return denormalised / denormalised[-1, -1]
def __call__(self, max_iter=1000, train_set=None, validation_set=None): sess = self.sess net = self.net with sess.as_default(): #for init model batch_size = 1 if cfg.TRAINING_TIMER: time_it = timer() # start training here ######################################################################################### self.log_msg.write( 'iter | top_cls_loss reg_loss | fuse_cls_loss reg_loss total | \n' ) self.log_msg.write( '-------------------------------------------------------------------------------------\n' ) fit_iteration = self.fit_iteration_gen(max_iter) for iter in range(max_iter): self.n_iter = iter next(fit_iteration) if (iter + 1) % self.ckpt_save_step == 0 or self.fast_test_mode: self.save_weights(self.train_target) self.save_progress() if (iter + 1) % 200 == 0: if cfg.TRAINING_TIMER: self.log_msg.write('It takes %0.2f secs to train %d iterations. \n' % \ (time_it.time_diff_per_n_loops(), 200)) self.n_global_step += 1 if cfg.TRAINING_TIMER: self.log_msg.write('It takes %0.2f secs to train the dataset. \n' % \ (time_it.total_time())) self.save_weights(self.train_target) self.save_progress()
def __call__(self, max_iter=1000, train_set =None, validation_set =None): sess = self.sess net = self.net with sess.as_default(): #for init model batch_size=1 if cfg.TRAINING_TIMER: time_it = timer() # start training here ######################################################################################### self.log_msg.write('iter | top_cls_loss reg_loss | fuse_cls_loss reg_loss total | \n') self.log_msg.write('-------------------------------------------------------------------------------------\n') fit_iteration =self.fit_iteration_gen(max_iter) for iter in range(max_iter): self.n_iter=iter next(fit_iteration) if (iter+1)%self.ckpt_save_step==0 or self.fast_test_mode: self.save_weights(self.train_target) self.save_progress() if (iter+1)%200==0: if cfg.TRAINING_TIMER: self.log_msg.write('It takes %0.2f secs to train %d iterations. \n' % \ (time_it.time_diff_per_n_loops(), 200)) self.n_global_step += 1 if cfg.TRAINING_TIMER: self.log_msg.write('It takes %0.2f secs to train the dataset. \n' % \ (time_it.total_time())) self.save_weights(self.train_target) self.save_progress()
def compare_questions(df_ques, dfcore, min_number_results=5, tests=None): """ Parameters ---------- df : DataFrame, where column is question ids, and rows is result ids: 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 ... 2038 1537 50 50 50 50 50 50 50 50 50 50 ... 50 1538 1 50 0 1 50 0 1 50 0 0 ... 1 min_number_results : int, minimal number of common result for two questions, when we calculate correlation. If num results < this value, then we claim, that there is no correlation. Returns ------- corr: from 0 to 1: = 1 -- positive corr. = 0 -- negativ corr. = 0.5 - no corr. phi: from -1 to 1. """ logging.info('compare questions') #df = df_ques # for short ids = set(df_ques.columns) ids_from_tests = get_questions_of_tests(dfcore, tests) ids = ids & ids_from_tests #! select only those questions that are in given tests num = len(ids) #corr = np.zeros(shape=(num, num), dtype=float) # correlation based on similar answer #phi = np.zeros(shape=(num, num), dtype=float) # phi-value #ratio = np.zeros(shape=(num, num), dtype=float) #num_common_results = np.zeros(shape=(num, num), dtype=int) # the number of common results for two question question_answers_dict = get_question_answers_dict(dfcore) print(question_answers_dict) ques_labels, ques_labels_dict = database_connect.load_question_labels( tests=tests) # to get test_id for a question test_id_by_ques_id = { ques_id: ques_labels_dict[ques_id]['test'] for ques_id in ids } #coeff_dict = dict() #abs_coeff_dict = dict() abs_test_coeff_dict = dict() num_pair_dict = dict() total_count_answer_pair = 0 # count number of all pair of answers #total_answers_test_number = 0 #df_matrix_corr = pd.DataFrame() # calculate the number of rows in new table num_rows = 0 for index1, id1 in enumerate(ids): #print('{0}/{1}, id={2}'.format(1+index1, len(ids), id1)) for index2, id2 in enumerate(ids): if id1 == id2: continue # cause the correlation is always = 1 num_ans1 = len(question_answers_dict[id1]) # we get it from dfcore num_ans2 = len(question_answers_dict[id2]) num_rows += num_ans1 * num_ans2 print('num_rows =', num_rows) #sys.exit(0) #matrix_corr = np.array(shape=) # prepare an empty dataframe for data store #df_matrix_corr = pd.DataFrame(0, index=np.arange(num_rows),\ #columns=['test_id_1', 'test_id_2', 'question_id_1', 'question_id_2',\ # columns=['question_id_1', 'question_id_2',\ # 'answer_id_1', 'answer_id_2']) matrix_corr1 = np.zeros(shape=(num_rows, 6), dtype=np.int32) matrix_corr2 = np.empty(shape=(num_rows, 3), dtype=np.float32) matrix_corr2.fill(np.nan) #df_matrix_corr['coeff'] = np.nan #df_matrix_corr['abs_coeff'] = np.nan #df_matrix_corr['abs_test_coeff'] = np.nan #columns_dict = { key:i for i, key in enumerate(df_matrix_corr.columns)} #print(columns_dict) #print('df_matrix_corr:') #print(df_matrix_corr.info()) #columns_dict = {'test_id_1':0, 'test_id_2':1, 'question_id_1':2, 'question_id_2':3,\ # 'answer_id_1':4, 'answer_id_2':5} index = 0 timer('start') USE_PD = False for index1, id1 in enumerate(ids): #print('{0}/{1}, id={2}'.format(1+index1, len(ids), id1)) timer('{0}/{1}, id={2}'.format(1 + index1, len(ids), id1)) for index2, id2 in enumerate(ids): if id1 == id2: continue # cause the correlation is always = 1 #print(' id2={0}'.format(id2)) if USE_PD: df = df_ques[[id1, id2]] # select data only for given two questions df = df[(df[id1] != NAN) & (df[id2] != NAN)] # and find intersection of results num = len(df) # общее кол-вот пар ответов a-b else: values = df_ques[[id1, id2]].values arr = values[(values[:, 0] != NAN) & (values[:, 1] != NAN)] num = arr.shape[0] total_count_answer_pair += num #if num < min_number_results: # logging.debug('num = {0} < min_number_results. continue'.format(num)) # continue answers1 = question_answers_dict[id1] # we get it from dfcore answers2 = question_answers_dict[id2] #answers1 = set(df[id1]) # we get it from df #answers2 = set(df[id2]) #coeff_ans_dict = dict() #abs_coeff_ans_dict = dict() #abs_test_coeff_ans_dict = dict() for ans1 in answers1: if USE_PD: num_ans1 = len( df[df[id1] == ans1]) # N(A1) = P(A1) * num --- count of answer1 else: # N(A1) = P(A1) * num --- count of answer1 num_ans1 = np.count_nonzero(arr[:, 0] == ans1) for ans2 in answers2: if USE_PD: num_ans1_ans2 = len( df[(df[id1] == ans1) & (df[id2] == ans2)] ) # N(A1,A2) count of ans1 and ans2 num_ans2 = len( df[df[id1] == ans1] ) # N(A2) = P(A2) * num --- count of answer2 else: num_ans1_ans2 = np.count_nonzero((arr[:, 0] == ans1) & (arr[:, 1] == ans2)) num_ans2 = np.count_nonzero(arr[:, 1] == ans2) if num_ans1_ans2 > num_ans1: print('num_ans1_ans2=', num_ans1_ans2) print('num_ans1=', num_ans1) assert num_ans1_ans2 <= num assert num_ans1_ans2 <= num_ans1 assert num > 0 P_A1_A2 = num_ans1_ans2 / num # = P(A1,A2) P_A1_A2 = round(min(P_A1_A2, 1.0), 3) if DEBUG: print('id1, id2 = ', (id1, id2)) print('ans1, ans2 = ', (ans1, ans2)) print('num = ', num) print('num_ans1_ans2 =', num_ans1_ans2) print('P_A1_A2 =', P_A1_A2) if num_ans1 > 0: P_A2_cond_A1 = num_ans1_ans2 / num_ans1 # = P(A2|A1) = P(A1,A2) / P(A1) P_A2_cond_A1 = round(min(P_A2_cond_A1, 1.0), 3) else: P_A2_cond_A1 = np.nan #coeff_ans_dict[(ans1,ans2)] = P_A2_cond_A1 #abs_coeff_ans_dict[(ans1,ans2)] = P_A1_A2 if (ans1, ans2) in num_pair_dict: num_pair_dict[(ans1, ans2)] += num_ans1_ans2 #print('add ', num_ans1_ans2, ' for ', (ans1,ans2)) else: num_pair_dict[(ans1, ans2)] = num_ans1_ans2 if DEBUG: print('{0}-{1} ({2},{3}): {4:.4f} | {5:.4f} | {6}'.\ format(id1, id2, ans1, ans2, P_A2_cond_A1, P_A1_A2, num_pair_dict[(ans1,ans2)])) #num_ans2 = len(df[df[id2]==ans2]) # count of answer2 #print('index =', index) assert index < num_rows matrix_corr1[index, 0] = test_id_by_ques_id[id1] matrix_corr1[index, 1] = test_id_by_ques_id[id2] matrix_corr1[index, 2] = id1 matrix_corr1[index, 3] = id2 matrix_corr1[index, 4] = ans1 matrix_corr1[index, 5] = ans2 matrix_corr2[index, 0] = P_A2_cond_A1 # coeff matrix_corr2[index, 1] = P_A1_A2 # abs_coeff #matrix_corr2[index, 2] = num_ans2 # abs_test_coeff - MY matrix_corr2[index, 2] = P_A1_A2 # abs_test_coeff - how in #df_matrix_corr.iloc[index, columns_dict['coeff']] = P_A2_cond_A1 #df_matrix_corr.iloc[index, columns_dict['abs_coeff']] = P_A1_A2 index += 1 if DEBUG and id1 == 1 and id2 == 2 and ans1 == 1 and ans2 == 8: print(matrix_corr1[index, :]) print(matrix_corr2[index, :]) sys.exit() #coeff_dict[(id1,id2)] = coeff_ans_dict #abs_coeff_dict[(id1,id2)] = abs_coeff_ans_dict """ all_answers = set(dfcore['answer_id']) for index1, ans1 in enumerate(all_answers): print('{0}/{1}, id={2}'.format(1+index1, len(ids), id1)) for index2, ans2 in enumerate(all_answers): for pair in num_pair_dict: abs_test_coeff_dict[pair] = num_pair_dict[pair] / count_pair """ sum_num_pair_dict = sum(num_pair_dict.values()) assert total_count_answer_pair == sum_num_pair_dict print('total_count_answer_pair =', total_count_answer_pair) print('sum_num_pair_dict =', sum_num_pair_dict) #for i in range(num_rows): # for pair in num_pair_dict: # if (matrix_corr1[i,4] == pair[0]) and (matrix_corr1[i,5] == pair[1]): # matrix_corr2[i,2] = num_pair_dict[pair] """ # 1-st way: for pair in num_pair_dict: matrix_corr2[((matrix_corr1[:,4] == pair[0]) & (matrix_corr1[:,5] == pair[1])), 2] = num_pair_dict[pair] matrix_corr2[:,2] = matrix_corr2[:,2] / sum_num_pair_dict """ matrix_corr2[:, 2] = matrix_corr2[:, 2] * MULT_abs_test_coeff / total_count_answer_pair matrix_corr2[:, 2] = np.where(matrix_corr2[:, 2] <= 1.0, matrix_corr2[:, 2], 1.0) matrix_corr2[:, 2] = np.round(matrix_corr2[:, 2], 7) #matrix_corr2[:,0] = np.where(matrix_corr2[:,0] <= 1.0, matrix_corr2[:,0], 1.0) #matrix_corr2[:,1] = np.where(matrix_corr2[:,1] <= 1.0, matrix_corr2[:,1], 1.0) # fill tests id. result = (matrix_corr1, matrix_corr2) df_matrix_corr = pd.DataFrame(matrix_corr1,\ columns=['test_id_1', 'test_id_2', 'question_id_1', 'question_id_2','answer_id_1', 'answer_id_2']) #df_matrix_corr = pd.DataFrame(0, index=np.arange(num_rows),\ #columns=['test_id_1', 'test_id_2', 'question_id_1', 'question_id_2',\ # columns=['question_id_1', 'question_id_2',\ # 'answer_id_1', 'answer_id_2']) df_matrix_corr['coeff'] = matrix_corr2[:, 0] df_matrix_corr['abs_coeff'] = matrix_corr2[:, 1] df_matrix_corr['abs_test_coeff'] = matrix_corr2[:, 2] result = { 'df_matrix_corr': df_matrix_corr, 'matrix_corr1': matrix_corr1, 'matrix_corr2': matrix_corr2, 'num_pair_dict': num_pair_dict } return result
def pred_and_save(tracklet_pred_dir, dataset,frame_offset=0, log_tag=None, weights_tag=None): top_shape, front_shape, rgb_shape = dataset.get_shape() predict = mv3d.Predictor(top_shape, front_shape, rgb_shape, log_tag=log_tag, weights_tag=weights_tag) queue = deque(maxlen=1) # timer timer_step = 100 if cfg.TRACKING_TIMER: time_it = timer() # dataset.size - 1 for in dataset.get_shape(), a frame is used. So it'll omit first frame for prediction, # fix this if has more time for i in range(dataset.size-1 if fast_test == False else frame_offset + 1): rgb, top, front, _, _, frame_id = dataset.load() # handling multiple bags. current_bag = frame_id.split('/')[1] current_frame_num = int(frame_id.split('/')[2]) if i == 0: prev_tag_bag = None else: prev_tag_bag = queue[0] if current_bag != prev_tag_bag: # print('current bag name: ', current_bag, '. previous bag name ', prev_tag_bag) if i != 0: tracklet.write_tracklet() tracklet = Tracklet_saver(tracklet_pred_dir, current_bag,exist_ok=True) # print('frame counter reset to 0. ') queue.append(current_bag) # frame_num = i - frame_offset # if frame_num < 0: # continue # detection boxes3d, probs = predict(top, front, rgb) # predict.dump_log(log_subdir=os.path.join('tracking',log_tag), n_frame=i, frame_tag=frame_id) # time timer_step iterations. Turn it on/off in config.py if cfg.TRACKING_TIMER and i % timer_step == 0 and i != 0: predict.track_log.write('It takes %0.2f secs for inferring %d frames. \n' % \ (time_it.time_diff_per_n_loops(), timer_step)) if len(boxes3d) != 0: translation, size, rotation = boxes3d_decompose(boxes3d[:, :, :]) # print(translation) # print(len(translation)) # add to tracklets for j in range(len(translation)): # if 0 < translation[j, 1] < 8: # print('pose wrote. ' tracklet.add_tracklet(current_frame_num, size[j], translation[j], rotation[j], probs[j],boxes3d[j]) # print('frame_counter is here: ', current_frame_num, ' and i is here: ', i, 'frame id is here: ', frame_id) tracklet.write_tracklet() predict.save_weights(dir=os.path.join(log_dir, 'pretrained_model')) if cfg.TRACKING_TIMER: predict.log_msg.write('It takes %0.2f secs for inferring the whole test dataset. \n' % \ (time_it.total_time())) print("tracklet file named tracklet_labels.xml is written successfully.") return tracklet.path
def pred_and_save(tracklet_pred_dir, dataset, generate_video=False, frame_offset=16, log_tag=None, weights_tag=None): # Tracklet_saver will check whether the file already exists. tracklet = Tracklet_saver(tracklet_pred_dir, 'pred') os.makedirs(os.path.join(log_dir, 'image'), exist_ok=True) gt_tracklet = Tracklet_saver(tracklet_pred_dir, 'gt') top_shape, front_shape, rgb_shape = dataset.get_shape() predict = mv3d.Predictor(top_shape, front_shape, rgb_shape, log_tag=log_tag, weights_tag=weights_tag) if generate_video: vid_in = skvideo.io.FFmpegWriter(os.path.join(log_dir, 'output.mp4')) # timer timer_step = 100 if cfg.TRACKING_TIMER: time_it = timer() print('dataset.size') print(dataset.size) lenght = [] gt_lenght = [] frame_num = 0 for i in range(dataset.size if fast_test == False else frame_offset + 1): rgb, top, front, _, _, _ = dataset.load(size=1) frame_num = i - frame_offset print('frame_num') print(frame_num) if frame_num < 0: continue gt_boxes3d_tmp = np.load( '/home/mohsen/Desktop/MV3D/data/preprocessed/kitti/gt_boxes3d/object3d/test/%05d.npy' % i) #remove gt boxes with hiegh less than 40 gt_boxes3d_list = [] for gt_box3d_tmp in gt_boxes3d_tmp: # if gt_box3d_tmp[0,0]>0: gt_box3d_tmp_list = [] gt_box3d_tmp_list.append(gt_box3d_tmp) gt_project = box3d.box3d_to_rgb_box(gt_box3d_tmp_list) if abs(gt_project[0][0, 1] - gt_project[0][4, 1]) >= 40: gt_box3d = gt_box3d_tmp gt_boxes3d_list.append(gt_box3d) gt_boxes3d = np.array(gt_boxes3d_list) # gt_boxes3d = gt_boxes3d_tmp ##################################### boxes3d_tmp, probs = predict(top, front, rgb) predict.dump_log(log_subdir=log_subdir, n_frame=i) # time timer_step iterations. Turn it on/off in config.py if cfg.TRACKING_TIMER and i % timer_step == 0 and i != 0: predict.track_log.write('It takes %0.2f secs for inferring %d frames. \n' % \ (time_it.time_diff_per_n_loops(), timer_step)) # for debugging: save image and show image. top_image = draw_top_image(top[0]) rgb_image = rgb[0] if len(gt_boxes3d) != 0: gt_lenght.append(len(gt_boxes3d)) gt_translation, gt_size, gt_rotation = boxes3d_decompose( gt_boxes3d[:, :, :]) # todo: remove it after gtbox is ok gt_size[:, 1:3] = gt_size[:, 1:3] / cfg.TRACKLET_GTBOX_LENGTH_SCALE for j in range(len(gt_translation)): gt_tracklet.add_tracklet(frame_num, gt_size[j], gt_translation[j], gt_rotation[j]) #remove predicted boxes with hiegh less than 40 boxes3d_list = [] for box3d_tmp in boxes3d_tmp: # if box3d_tmp[0, 0] > 0: box3d_tmp_list = [] box3d_tmp_list.append(box3d_tmp) project = box3d.box3d_to_rgb_box(box3d_tmp_list) if abs(project[0][0, 1] - project[0][4, 1]) >= 40: print(project[0][0, 1] - project[0][4, 1]) pred_box3d = box3d_tmp boxes3d_list.append(pred_box3d) boxes3d = np.array(boxes3d_list) # boxes3d = boxes3d_tmp ##################################### print('sizes') print(np.size(boxes3d)) print(gt_boxes3d) print(np.size(gt_boxes3d)) if len(boxes3d) != 0: lenght.append(len(boxes3d)) top_image = draw_box3d_on_top(top_image, boxes3d[:, :, :], color=(80, 80, 0), thickness=3) rgb_image = draw_box3d_on_camera(rgb_image, boxes3d[:, :, :], color=(0, 0, 80), thickness=3) if len(gt_boxes3d) != 0: rgb_image = draw_box3d_on_camera(rgb_image, gt_boxes3d[:, :, :], color=(0, 80, 0), thickness=3) translation, size, rotation = boxes3d_decompose(boxes3d[:, :, :]) # todo: remove it after gtbox is ok size[:, 1:3] = size[:, 1:3] / cfg.TRACKLET_GTBOX_LENGTH_SCALE for j in range(len(translation)): tracklet.add_tracklet(frame_num, size[j], translation[j], rotation[j]) resize_scale = top_image.shape[0] / rgb_image.shape[0] rgb_image = cv2.resize( rgb_image, (int(rgb_image.shape[1] * resize_scale), top_image.shape[0])) rgb_image = cv2.cvtColor(rgb_image, cv2.COLOR_BGR2RGB) new_image = np.concatenate((top_image, rgb_image), axis=1) cv2.imwrite(os.path.join(log_dir, 'image', '%5d_image.jpg' % i), new_image) if generate_video: vid_in.writeFrame(new_image) vid_in.close() print(lenght) print(sum(lenght)) tracklet.write_tracklet() predict.dump_weigths(os.path.join(log_dir, 'pretrained_model')) print(gt_lenght) print(sum(gt_lenght)) gt_tracklet.write_tracklet() if cfg.TRACKING_TIMER: predict.log_msg.write('It takes %0.2f secs for inferring the whole test dataset. \n' % \ (time_it.total_time())) print("tracklet file named tracklet_labels.xml is written successfully.") return tracklet.path, gt_tracklet.path
def __call__(self, max_iter=1000, train_set=None, validation_set=None): sess = self.sess net = self.net with sess.as_default(): #for init model batch_size = 1 validation_step = 40 ckpt_save_step = 200 if cfg.TRAINING_TIMER: time_it = timer() # start training here ######################################################################################### self.log_msg.write( 'iter | top_cls_loss reg_loss | fuse_cls_loss reg_loss total | \n' ) self.log_msg.write( '-------------------------------------------------------------------------------------\n' ) for iter in range(max_iter): is_validation = False summary_it = False summary_runmeta = False print_loss = False log_this_iter = False # set fit flag if iter % validation_step == 0: summary_it, is_validation, print_loss = True, True, True # summary validation loss if (iter + 1) % validation_step == 0: summary_it, print_loss = True, True # summary train loss if iter % 20 == 0: print_loss = True #print train loss if 1 and iter % 300 == 0: summary_it, summary_runmeta = True, True if iter % self.iter_debug == 0 or (iter + 1) % self.iter_debug == 0: log_this_iter = True print('Summary log image') if iter % self.iter_debug == 0: is_validation = False else: is_validation = True data_set = self.validation_set if is_validation else self.train_set self.default_summary_writer = self.val_summary_writer if is_validation else self.train_summary_writer step_name = 'validation' if is_validation else 'training' # load dataset self.batch_rgb_images, self.batch_top_view, self.batch_front_view, \ self.batch_gt_labels, self.batch_gt_boxes3d, self.frame_id = \ data_set.load() # fit_iterate log init if log_this_iter: self.time_str = strftime("%Y_%m_%d_%H_%M", localtime()) self.frame_info = data_set.get_frame_info() self.log_subdir = step_name + '/' + self.time_str top_image = data.draw_top_image(self.batch_top_view[0]) self.top_image = self.top_image_padding(top_image) # fit t_cls_loss, t_reg_loss, f_cls_loss, f_reg_loss= \ self.fit_iteration(self.batch_rgb_images, self.batch_top_view, self.batch_front_view, self.batch_gt_labels, self.batch_gt_boxes3d, self.frame_id, is_validation =is_validation, summary_it=summary_it, summary_runmeta=summary_runmeta, log=log_this_iter) if print_loss: self.log_msg.write('%10s: | %5d %0.5f %0.5f | %0.5f %0.5f \n' % \ (step_name, self.n_global_step, t_cls_loss, t_reg_loss, f_cls_loss, f_reg_loss)) if iter % ckpt_save_step == 0: self.save_weights(self.train_target) if cfg.TRAINING_TIMER: self.log_msg.write('It takes %0.2f secs to train %d iterations. \n' % \ (time_it.time_diff_per_n_loops(), ckpt_save_step)) self.gc() self.n_global_step += 1 if cfg.TRAINING_TIMER: self.log_msg.write('It takes %0.2f secs to train the dataset. \n' % \ (time_it.total_time())) self.save_progress()
def __call__(self, max_iter=1000, train_set =None, validation_set =None): sess = self.sess net = self.net with sess.as_default(): #for init model batch_size=1 validation_step=40 ckpt_save_step=200 if cfg.TRAINING_TIMER: time_it = timer() # start training here ######################################################################################### self.log_msg.write('iter | top_cls_loss reg_loss | fuse_cls_loss reg_loss total | \n') self.log_msg.write('-------------------------------------------------------------------------------------\n') for iter in range(max_iter): is_validation = False summary_it = False summary_runmeta = False print_loss = False log_this_iter = False # set fit flag if iter % validation_step == 0: summary_it,is_validation,print_loss = True,True,True # summary validation loss if (iter+1) % validation_step == 0: summary_it,print_loss = True,True # summary train loss if iter % 20 == 0: print_loss = True #print train loss if 1 and iter%300 == 0: summary_it,summary_runmeta = True,True if iter % self.iter_debug == 0 or (iter + 1) % self.iter_debug == 0: log_this_iter = True print('Summary log image') if iter % self.iter_debug == 0: is_validation =False else: is_validation =True data_set = self.validation_set if is_validation else self.train_set self.default_summary_writer = self.val_summary_writer if is_validation else self.train_summary_writer step_name = 'validation' if is_validation else 'training' # load dataset if config.cfg.USE_RNN: self.batch_rgb_images, self.batch_top_view, self.batch_front_view, \ self.batch_gt_labels, self.batch_gt_boxes3d, self.frame_id = \ data_set.load(batch_size, shuffled=False) else: self.batch_rgb_images, self.batch_top_view, self.batch_front_view, \ self.batch_gt_labels, self.batch_gt_boxes3d, self.frame_id = \ data_set.load(batch_size, shuffled=True) # fit_iterate log init if log_this_iter: self.time_str = strftime("%Y_%m_%d_%H_%M", localtime()) self.frame_info = data_set.get_frame_info(self.frame_id)[0] self.log_subdir = step_name + '/' + self.time_str top_image = data.draw_top_image(self.batch_top_view[0]) self.top_image = self.top_image_padding(top_image) # fit t_cls_loss, t_reg_loss, f_cls_loss, f_reg_loss= \ self.fit_iteration(self.batch_rgb_images, self.batch_top_view, self.batch_front_view, self.batch_gt_labels, self.batch_gt_boxes3d, self.frame_id, is_validation =is_validation, summary_it=summary_it, summary_runmeta=summary_runmeta, log=log_this_iter) if print_loss: self.log_msg.write('%10s: | %5d %0.5f %0.5f | %0.5f %0.5f \n' % \ (step_name, self.n_global_step, t_cls_loss, t_reg_loss, f_cls_loss, f_reg_loss)) if iter%ckpt_save_step==0: self.save_weights(self.train_target) if cfg.TRAINING_TIMER: self.log_msg.write('It takes %0.2f secs to train %d iterations. \n' % \ (time_it.time_diff_per_n_loops(), ckpt_save_step)) self.gc() self.n_global_step += 1 if cfg.TRAINING_TIMER: self.log_msg.write('It takes %0.2f secs to train the dataset. \n' % \ (time_it.total_time())) self.save_progress()
help='The directory where the model will be stored.') self.add_argument( '--train_epochs', type=int, default=40, help='Number of epochs to train.') self.add_argument( '--data_format', type=str, default=None, choices=['channels_first', 'channels_last'], help='A flag to override the data format used in the model. ' 'channels_first provides a performance boost on GPU but is not always ' 'compatible with CPU. If left unspecified, the data format will be ' 'chosen automatically based on whether TensorFlow was built for CPU or ' 'GPU.') self.add_argument( '--export_dir', type=str, help='The directory where the exported SavedModel will be stored.') if __name__ == '__main__': parser = MNISTArgParser() tf.logging.set_verbosity(tf.logging.INFO) FLAGS, unparsed = parser.parse_known_args() timer('TRAIN') tf.app.run(main=main, argv=[sys.argv[0]] + unparsed) timer()
acc = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) # top-1 - mean value acc_top6 = tf.nn.in_top_k(logits, tf.argmax(y, 1), 6) # list values for batch. with tf.Session() as sess: sess.run(tf.global_variables_initializer()) if arguments.restore_checkpoint is not None: tf.train.Saver().restore(sess, './{}/{}'.\ format(dir_for_checkpoints, arguments.restore_checkpoint)) for epoch in range(num_epochs): print('\nEPOCH {}/{}'.format(epoch, num_epochs)) timer('train, epoch {0}'.format(epoch)) train_loss_list, train_acc_list, train_top6_list = [], [], [] train_top6_list2 = [] for i in range(train_steps_per_epoch): try: features, labels = sess.run(next_element_train) #print(i, labels[0]) sess.run(train_op, feed_dict={x: features, y: labels}) #train_acc, train_acc_top6 = sess.run([acc, acc_top6], feed_dict={x: features, y: labels}) train_outputs, train_loss, train_acc, train_top6 \ = sess.run([output, loss, acc, acc_top6], feed_dict={x: features, y: labels}) acc1 = accuracy_top1(train_outputs, labels)
def pred_and_save(tracklet_pred_dir, dataset, frame_offset=0, log_tag=None, weights_tag=None): top_shape, front_shape, rgb_shape = dataset.get_shape() predict = mv3d.Predictor(top_shape, front_shape, rgb_shape, log_tag=log_tag, weights_tag=weights_tag) queue = deque(maxlen=1) # timer timer_step = 100 if cfg.TRACKING_TIMER: time_it = timer() # dataset.size - 1 for in dataset.get_shape(), a frame is used. So it'll omit first frame for prediction, # fix this if has more time for i in range(dataset.size - 1 if fast_test == False else frame_offset + 1): rgb, top, front, _, _, frame_id = dataset.load() # handling multiple bags. current_bag = frame_id.split('/')[1] current_frame_num = int(frame_id.split('/')[2]) if i == 0: prev_tag_bag = None else: prev_tag_bag = queue[0] if current_bag != prev_tag_bag: # print('current bag name: ', current_bag, '. previous bag name ', prev_tag_bag) if i != 0: tracklet.write_tracklet() tracklet = Tracklet_saver(tracklet_pred_dir, current_bag, exist_ok=True) # print('frame counter reset to 0. ') queue.append(current_bag) # frame_num = i - frame_offset # if frame_num < 0: # continue # detection boxes3d, probs = predict(top, front, rgb) # predict.dump_log(log_subdir=os.path.join('tracking',log_tag), n_frame=i, frame_tag=frame_id) # time timer_step iterations. Turn it on/off in config.py if cfg.TRACKING_TIMER and i % timer_step == 0 and i != 0: predict.track_log.write('It takes %0.2f secs for inferring %d frames. \n' % \ (time_it.time_diff_per_n_loops(), timer_step)) if len(boxes3d) != 0: translation, size, rotation = boxes3d_decompose(boxes3d[:, :, :]) # print(translation) # print(len(translation)) # add to tracklets for j in range(len(translation)): # if 0 < translation[j, 1] < 8: # print('pose wrote. ' tracklet.add_tracklet(current_frame_num, size[j], translation[j], rotation[j], probs[j], boxes3d[j]) # print('frame_counter is here: ', current_frame_num, ' and i is here: ', i, 'frame id is here: ', frame_id) tracklet.write_tracklet() predict.save_weights(dir=os.path.join(log_dir, 'pretrained_model')) if cfg.TRACKING_TIMER: predict.log_msg.write('It takes %0.2f secs for inferring the whole test dataset. \n' % \ (time_it.total_time())) print("tracklet file named tracklet_labels.xml is written successfully.") return tracklet.path
acc_top6 = tf.nn.in_top_k(logits, tf.argmax(y, 1), 6) # list values for batch. with tf.Session() as sess: sess.run(tf.global_variables_initializer()) if arguments.restore_checkpoint is not None: tf.train.Saver(variables_to_restore).restore(sess, './{}/{}'.\ format(dir_for_checkpoints, arguments.restore_checkpoint)) for epoch in range(num_epochs): print('\nEPOCH {}/{} ({})'.format(epoch, num_epochs, net_model_name)) timer('train, epoch {0}'.format(epoch)) train_loss_list, train_acc_list, train_top6_list = [], [], [] for i in range(train_steps_per_epoch): try: features, labels = sess.run(next_element_train) #print(i, labels[0]) sess.run(train_op, feed_dict={x: features, y: labels}) #train_acc, train_acc_top6 = sess.run([acc, acc_top6], feed_dict={x: features, y: labels}) train_loss, train_acc, train_top6 = sess.run( [loss, acc, acc_top6], feed_dict={ x: features,
def __call__(self, max_iter=1000, train_set =None, validation_set =None): sess = self.sess net = self.net with sess.as_default(): #for init model batch_size=1 validation_step=40 ckpt_save_step=200 if cfg.TRAINING_TIMER: time_it = timer() # start training here ######################################################################################### self.log_msg.write('iter | top_cls_loss reg_loss | fuse_cls_loss reg_loss total | \n') self.log_msg.write('-------------------------------------------------------------------------------------\n') for iter in range(max_iter): is_validation = False summary_it = False summary_runmeta = False print_loss = False log_this_iter = False # set fit flag if iter % validation_step == 0: summary_it,is_validation,print_loss = True,True,True # summary validation loss if (iter+1) % validation_step == 0: summary_it,print_loss = True,True # summary train loss if iter % 5 == 0: print_loss = True #print train loss if 1 and iter%300 == 3: summary_it,summary_runmeta = True,True if iter % self.iter_debug == 0 or (iter + 1) % self.iter_debug == 0: log_this_iter = True print('summary log image') if iter % self.iter_debug == 0: is_validation =False else: is_validation =True data_set = self.validation_set if is_validation else self.train_set self.default_summary_writer = self.val_summary_writer if is_validation else self.train_summary_writer step_name = 'validation' if is_validation else 'training' # load dataset self.batch_rgb_images, self.batch_top_view, self.batch_front_view, \ self.batch_gt_labels, self.batch_gt_boxes3d, self.frame_id = \ data_set.load(batch_size, shuffled=True) # # if self.batch_data_is_invalid(self.batch_gt_boxes3d[0]): # continue # for keeping all gt labels and gt boxes inside range, and discard gt out of selected range. is_gt_inside_range, batch_gt_labels_in_range, batch_gt_boxes3d_in_range = \ self.keep_gt_inside_range(self.batch_gt_labels[0], self.batch_gt_boxes3d[0]) if not is_gt_inside_range: continue # todo current support only batch_size == 1 self.batch_gt_labels = np.zeros((1, batch_gt_labels_in_range.shape[0]), dtype=np.int32) self.batch_gt_boxes3d = np.zeros((1, batch_gt_labels_in_range.shape[0], 8, 3), dtype=np.float32) self.batch_gt_labels[0] = batch_gt_labels_in_range self.batch_gt_boxes3d[0] = batch_gt_boxes3d_in_range # fit_iterate log init if log_this_iter: self.time_str = strftime("%Y_%m_%d_%H_%M", localtime()) self.frame_info = data_set.get_frame_info(self.frame_id)[0] self.log_subdir = step_name + '/' + self.time_str top_image = data.draw_top_image(self.batch_top_view[0]) self.top_image = self.top_image_padding(top_image) # fit t_cls_loss, t_reg_loss, f_cls_loss, f_reg_loss= \ self.fit_iteration(self.batch_rgb_images, self.batch_top_view, self.batch_front_view, self.batch_gt_labels, self.batch_gt_boxes3d, self.frame_id, is_validation =is_validation, summary_it=summary_it, summary_runmeta=summary_runmeta, log=log_this_iter) if print_loss: self.log_msg.write('%10s: | %5d %0.5f %0.5f | %0.5f %0.5f \n' % \ (step_name, self.n_global_step, t_cls_loss, t_reg_loss, f_cls_loss, f_reg_loss)) if iter%ckpt_save_step==0: # saver.save(sess, pretrained_model_path) print('save_weights') self.save_weights(self.train_target) if cfg.TRAINING_TIMER: self.log_msg.write('It takes %0.2f secs to train %d iterations. \n' % \ (time_it.time_diff_per_n_loops(), ckpt_save_step)) self.gc() self.n_global_step += 1 if cfg.TRAINING_TIMER: self.log_msg.write('It takes %0.2f secs to train the dataset. \n' % \ (time_it.total_time())) self.save_progress()
def __call__(self, max_iter=1000, train_set=None, validation_set=None): sess = self.sess net = self.net with sess.as_default(): #for init model batch_size = 1 validation_step = 40 ckpt_save_step = 200 if cfg.TRAINING_TIMER: time_it = timer() # start training here ######################################################################################### self.log_msg.write( 'iter | top_cls_loss reg_loss | fuse_cls_loss reg_loss total | \n' ) self.log_msg.write( '-------------------------------------------------------------------------------------\n' ) for iter in range(max_iter): is_validation = False summary_it = False summary_runmeta = False print_loss = False log_this_iter = False # set fit flag if iter % validation_step == 0: summary_it, is_validation, print_loss = True, True, True # summary validation loss if (iter + 1) % validation_step == 0: summary_it, print_loss = True, True # summary train loss if iter % 5 == 0: print_loss = True #print train loss if 1 and iter % 300 == 3: summary_it, summary_runmeta = True, True if iter % self.iter_debug == 0 or (iter + 1) % self.iter_debug == 0: log_this_iter = True print('summary log image') if iter % self.iter_debug == 0: is_validation = False else: is_validation = True data_set = self.validation_set if is_validation else self.train_set self.default_summary_writer = self.val_summary_writer if is_validation else self.train_summary_writer step_name = 'validation' if is_validation else 'training' # load dataset self.batch_rgb_images, self.batch_top_view, self.batch_front_view, \ self.batch_gt_labels, self.batch_gt_boxes3d, self.frame_id = \ data_set.load(batch_size, shuffled=True) # # if self.batch_data_is_invalid(self.batch_gt_boxes3d[0]): # continue # for keeping all gt labels and gt boxes inside range, and discard gt out of selected range. is_gt_inside_range, batch_gt_labels_in_range, batch_gt_boxes3d_in_range = \ self.keep_gt_inside_range(self.batch_gt_labels[0], self.batch_gt_boxes3d[0]) if not is_gt_inside_range: continue # todo current support only batch_size == 1 self.batch_gt_labels = np.zeros( (1, batch_gt_labels_in_range.shape[0]), dtype=np.int32) self.batch_gt_boxes3d = np.zeros( (1, batch_gt_labels_in_range.shape[0], 8, 3), dtype=np.float32) self.batch_gt_labels[0] = batch_gt_labels_in_range self.batch_gt_boxes3d[0] = batch_gt_boxes3d_in_range # fit_iterate log init if log_this_iter: self.time_str = strftime("%Y_%m_%d_%H_%M", localtime()) self.frame_info = data_set.get_frame_info(self.frame_id)[0] self.log_subdir = step_name + '/' + self.time_str top_image = data.draw_top_image(self.batch_top_view[0]) self.top_image = self.top_image_padding(top_image) # fit t_cls_loss, t_reg_loss, f_cls_loss, f_reg_loss= \ self.fit_iteration(self.batch_rgb_images, self.batch_top_view, self.batch_front_view, self.batch_gt_labels, self.batch_gt_boxes3d, self.frame_id, is_validation =is_validation, summary_it=summary_it, summary_runmeta=summary_runmeta, log=log_this_iter) if print_loss: self.log_msg.write('%10s: | %5d %0.5f %0.5f | %0.5f %0.5f \n' % \ (step_name, self.n_global_step, t_cls_loss, t_reg_loss, f_cls_loss, f_reg_loss)) if iter % ckpt_save_step == 0: # saver.save(sess, pretrained_model_path) print('save_weights') self.save_weights(self.train_target) if cfg.TRAINING_TIMER: self.log_msg.write('It takes %0.2f secs to train %d iterations. \n' % \ (time_it.time_diff_per_n_loops(), ckpt_save_step)) self.gc() self.n_global_step += 1 if cfg.TRAINING_TIMER: self.log_msg.write('It takes %0.2f secs to train the dataset. \n' % \ (time_it.total_time())) self.save_progress()
def pred_and_save(tracklet_pred_dir, dataset, generate_video=False, frame_offset=16, log_tag=None, weights_tag=None): # Tracklet_saver will check whether the file already exists. tracklet = Tracklet_saver(tracklet_pred_dir) os.makedirs(os.path.join(log_dir, 'image'), exist_ok=True) top_shape, front_shape, rgb_shape = dataset.get_shape() predict = mv3d.Predictor(top_shape, front_shape, rgb_shape, log_tag=log_tag, weights_tag=weights_tag) if generate_video: vid_in = skvideo.io.FFmpegWriter(os.path.join(log_dir, 'output.mp4')) # timer timer_step = 100 if cfg.TRACKING_TIMER: time_it = timer() frame_num = 0 for i in range(dataset.size if fast_test == False else frame_offset + 1): rgb, top, front, _, _, _ = dataset.load() frame_num = i - frame_offset if frame_num < 0: continue boxes3d, probs = predict(top, front, rgb) predict.dump_log(log_subdir=log_subdir, n_frame=i) # time timer_step iterations. Turn it on/off in config.py if cfg.TRACKING_TIMER and i % timer_step == 0 and i != 0: predict.track_log.write('It takes %0.2f secs for inferring %d frames. \n' % \ (time_it.time_diff_per_n_loops(), timer_step)) # for debugging: save image and show image. top_image = draw_top_image(top[0]) rgb_image = rgb[0] if len(boxes3d) != 0: top_image = draw_box3d_on_top(top_image, boxes3d[:, :, :], color=(80, 80, 0), thickness=3) rgb_image = draw_box3d_on_camera(rgb_image, boxes3d[:, :, :], color=(0, 0, 80), thickness=3) translation, size, rotation = boxes3d_decompose(boxes3d[:, :, :]) # todo: remove it after gtbox is ok size[:, 1:3] = size[:, 1:3] / cfg.TRACKLET_GTBOX_LENGTH_SCALE for j in range(len(translation)): if 0 < translation[j, 1] < 8: tracklet.add_tracklet(frame_num, size[j], translation[j], rotation[j]) resize_scale = top_image.shape[0] / rgb_image.shape[0] rgb_image = cv2.resize( rgb_image, (int(rgb_image.shape[1] * resize_scale), top_image.shape[0])) rgb_image = cv2.cvtColor(rgb_image, cv2.COLOR_BGR2RGB) new_image = np.concatenate((top_image, rgb_image), axis=1) cv2.imwrite(os.path.join(log_dir, 'image', '%5d_image.jpg' % i), new_image) if generate_video: vid_in.writeFrame(new_image) vid_in.close() tracklet.write_tracklet() predict.dump_weigths(os.path.join(log_dir, 'pretrained_model')) if cfg.TRACKING_TIMER: predict.log_msg.write('It takes %0.2f secs for inferring the whole test dataset. \n' % \ (time_it.total_time())) print("tracklet file named tracklet_labels.xml is written successfully.") return tracklet.path
def correlation_calculation(tests=None, min_number_results=5, one=False): timer('load_data') np.set_printoptions(precision=2) pd.options.display.float_format = '{:,.2f}'.format if tests == None: # if list of tests is not specific tests = database_connect.load_test_list() att_dict = database_connect.load_attributes(tests=tests) print('num scales:', len(att_dict)) timer('get_question_values') df, df_ques = get_question_values(tests) #return df, df_ques # !!! HERE WE SECOND TIME CALL get_dataframes TO GET dfcore _, dfcore = database_connect.get_dataframes(tests=tests) if one: table_name = 'test_qa_correlation' else: table_name = 'matrix_corr_qa' # Clean table if not NO_WRITING_DB: database_connect.clean_table(table_name, truncate=True) logging.info('Table {0} was cleaned.'.format(table_name)) timer('compare_questions') if one: for test in tests: result = compare_questions(df_ques, dfcore, min_number_results, tests=[test]) df = result['df_matrix_corr'] df['test_id'] = df['test_id_1'] df.drop(['test_id_1'], axis=1, inplace=True) df.drop(['test_id_2'], axis=1, inplace=True) df.drop(['coeff'], axis=1, inplace=True) save_dataframe_to_db(df, table_name) else: if len(tests) == 1: result = compare_questions(df_ques, dfcore, min_number_results, tests=tests) df = result['df_matrix_corr'] #return df save_dataframe_to_db(df, table_name) else: for test1 in tests: for test2 in tests: if test1 > test2: continue result = compare_questions(df_ques, dfcore, min_number_results, tests=[test1, test2]) df = result['df_matrix_corr'] save_dataframe_to_db(df, table_name)
def pred_and_save(tracklet_pred_dir, dataset, generate_video=False, frame_offset=16, log_tag=None, weights_tag=None): # Tracklet_saver will check whether the file already exists. tracklet = Tracklet_saver(tracklet_pred_dir) os.makedirs (os.path.join(log_dir,'image'),exist_ok=True) top_shape, front_shape, rgb_shape=dataset.get_shape() predict=mv3d.Predictor(top_shape, front_shape, rgb_shape, log_tag=log_tag, weights_tag=weights_tag) if generate_video: vid_in = skvideo.io.FFmpegWriter(os.path.join(log_dir,'output.mp4')) # timer timer_step = 100 if cfg.TRACKING_TIMER: time_it = timer() frame_num = 0 for i in range(dataset.size): rgb, top, front, _, _,_= dataset.load(1) frame_num = i - frame_offset if frame_num < 0: continue boxes3d,probs=predict(top, front, rgb) predict.dump_log(log_subdir=log_subdir,n_frame=i) # time timer_step iterations. Turn it on/off in config.py if cfg.TRACKING_TIMER and i%timer_step ==0 and i!=0: predict.track_log.write('It takes %0.2f secs for inferring %d frames. \n' % \ (time_it.time_diff_per_n_loops(), timer_step)) # for debugging: save image and show image. top_image = draw_top_image(top[0]) rgb_image = rgb[0] if len(boxes3d)!=0: top_image = draw_box3d_on_top(top_image, boxes3d[:,:,:], color=(80, 80, 0), thickness=3) rgb_image = draw_box3d_on_camera(rgb_image, boxes3d[:, :, :], color=(0, 0, 80), thickness=3) translation, size, rotation = boxes3d_decompose(boxes3d[:, :, :]) #todo: remove it after gtbox is ok size[:,1:3] = size[:,1:3]/cfg.TRACKLET_GTBOX_LENGTH_SCALE for j in range(len(translation)): if 0<translation[j,1]<8: tracklet.add_tracklet(frame_num, size[j], translation[j], rotation[j]) resize_scale=top_image.shape[0]/rgb_image.shape[0] rgb_image = cv2.resize(rgb_image,(int(rgb_image.shape[1]*resize_scale), top_image.shape[0])) rgb_image = cv2.cvtColor(rgb_image, cv2.COLOR_BGR2RGB) new_image = np.concatenate((top_image, rgb_image), axis = 1) cv2.imwrite(os.path.join(log_dir,'image','%5d_image.jpg'%i), new_image) if generate_video: vid_in.writeFrame(new_image) vid_in.close() tracklet.write_tracklet() predict.dump_weigths(os.path.join(log_dir, 'pretrained_model')) if cfg.TRACKING_TIMER: predict.log_msg.write('It takes %0.2f secs for inferring the whole test dataset. \n' % \ (time_it.total_time())) print("tracklet file named tracklet_labels.xml is written successfully.") return tracklet.path