def analyze_all(self): """ :return: """ path_dir = self.pred_dir # 1. path check if os.path.exists(path_dir): print('path ok') else: print('Path Not find:', path_dir) sys.exit() pred_list = os.listdir(path_dir) fileNumber = len(pred_list) print('The number of images are: ', fileNumber) rate = 1 pickNumber = int(fileNumber * rate) sample = random.sample(pred_list, pickNumber) f1_score_list = [] pred_name_list = [] loss_list = [] src_name_list = [] gt_name_list = [] band_gt_name_list = [] precision_score_list = [] acc_list = [] recall_list = [] combineArray = np.zeros((320, 4 * 320, 3)) for index, name in enumerate(sample): print(index, '/', len(sample)) src_path, gt_path = Analyze.__find_src_and_gt(self, name) pred_img = os.path.join(path_dir, name) pred_img = Image.open(pred_img) src_img = Image.open(src_path) gt_img = Image.open(gt_path) # check channel required 1 dim if len(pred_img.split()) == 3: pred_img = pred_img.split()[0] else: pass if len(gt_img.split()) == 3: gt_img = gt_img.split()[0] else: pass # convert to ndarray and normalize,then to tensor pred_ndarray = np.array(pred_img) pred_ndarray3D = np.expand_dims(pred_ndarray, axis=2) pred_ndarray = pred_ndarray / 255 pred_ndarray4D = pred_ndarray[np.newaxis, np.newaxis, :, :] # convert numpy to tensor pred_img_tensor = torch.from_numpy(pred_ndarray4D) # compute loss gt_ndarray = np.array(gt_img) gt = gt_ndarray.copy() gt = np.where((gt == 100) | (gt == 255), 1, 0) gt_ndarray3D = np.expand_dims(gt_ndarray, axis=2) gt_ndarray4D = gt_ndarray[np.newaxis, np.newaxis, :, :] band_gt_np = Analyze.__gen_band_gt(self, gt_ndarray4D) band_gt_np3D = band_gt_np.squeeze(0) band_gt_np2D = band_gt_np3D.squeeze(0) band_gt_np3DLast1 = np.expand_dims(band_gt_np2D, axis=2) band_gt_np3DLast1 = band_gt_np3DLast1 * 255 band_gt_img = Image.fromarray(band_gt_np2D) band_gt_prefix = 'band5_' gt_name = gt_path.split('/')[-1] band_gt_name = band_gt_prefix + gt_name band_gt_img.save(os.path.join(self.save_band_dir, band_gt_name)) band_gt_tensor = torch.from_numpy(band_gt_np) # compute loss,f1,acc,precision,recall gt = torch.from_numpy(gt) gt = gt.unsqueeze(0) gt = gt.unsqueeze(0) loss_tonsor = wce_dice_huber_loss(pred_img_tensor.float(), gt.float()) # loss_tonsor = wce_dice_huber_loss(pred_img_tensor.float(), band_gt_tensor.float()) loss = loss_tonsor.item() f1_score = my_f1_score(pred_img_tensor, band_gt_tensor) acc_score = my_acc_score(pred_img_tensor, band_gt_tensor) recall = my_recall_score(pred_img_tensor, band_gt_tensor) precision = my_precision_score(pred_img_tensor, band_gt_tensor) # output to csv f1_score_list.append(f1_score) pred_name_list.append(name) loss_list.append(loss) acc_list.append(acc_score) recall_list.append(recall) precision_score_list.append(precision) src_name = src_path.split('/')[-1] src_name_list.append(src_name) gt_name_list.append(gt_name) band_gt_name_list.append(band_gt_name) # combine_plot src_ndarray = np.array(src_img) combineArray[:, :320, :] = src_ndarray combineArray[:, 320:640, :] = gt_ndarray3D combineArray[:, 640:960, :] = band_gt_np3DLast1 combineArray[:, 960:, :] = pred_ndarray3D combineImg = Image.fromarray(combineArray.astype(np.uint8)) combineImg_prefix = 'comb_' combineImg_name = combineImg_prefix + src_name combineImg.save( os.path.join(self.save_combine_dir, combineImg_name)) # difficult top-k data = { 'srcName': src_name_list, 'gtName': gt_name_list, 'bandGtName': band_gt_name_list, 'predName': pred_name_list, 'loss': loss_list, 'precision': precision_score_list, 'recall': recall_list, 'f1': f1_score_list, 'acc': acc_list } test = pd.DataFrame(data) test.to_excel(self.save_excel_dir)
def train(model1, model2, optimizer1, optimizer2, dataParser, epoch, save_dir): # 读取数据的迭代器 train_epoch = int(dataParser.steps_per_epoch) # 变量保存 batch_time = Averagvalue() data_time = Averagvalue() losses = Averagvalue() fuse_loss = Averagvalue f1_value_stage1 = Averagvalue() acc_value_stage1 = Averagvalue() recall_value_stage1 = Averagvalue() precision_value_stage1 = Averagvalue() map8_loss_value_stage1 = Averagvalue() f1_value_stage2 = Averagvalue() acc_value_stage2 = Averagvalue() recall_value_stage2 = Averagvalue() precision_value_stage2 = Averagvalue() map8_loss_value_stage2 = Averagvalue() loss_8 = Averagvalue() stage1_loss = Averagvalue() stage1_pred_loss = Averagvalue() stage2_loss = Averagvalue() stage2_pred_loss = Averagvalue() ############################### mid_freq = 100 # switch to train mode model1.train() model2.train() end = time.time() epoch_loss = [] for batch_index, (images, labels_numpy) in enumerate( generate_minibatches(dataParser, True)): # 读取数据的时间 data_time.update(time.time() - end) # 对读取的numpy类型数据进行调整 labels = [] if torch.cuda.is_available(): images = torch.from_numpy(images).cuda() for item in labels_numpy: labels.append(torch.from_numpy(item).cuda()) else: images = torch.from_numpy(images) for item in labels_numpy: labels.append(torch.from_numpy(item)) if torch.cuda.is_available(): loss = torch.zeros(1).cuda() loss_stage_2 = torch.zeros(1).cuda() loss_8t = torch.zeros(()).cuda() else: loss = torch.zeros(1) loss_stage_2 = torch.zeros(1).cuda() loss_8t = torch.zeros(()) with torch.set_grad_enabled(True): images.requires_grad = True optimizer1.zero_grad() optimizer2.zero_grad() one_stage_outputs = model1(images) zero = torch.zeros_like(one_stage_outputs[0]) one = torch.ones_like(one_stage_outputs[0]) rgb_pred = images * torch.where(one_stage_outputs[0] > 0.1, one, zero) _rgb_pred = rgb_pred.cpu() _rgb_pred = _rgb_pred.detach().numpy() if abs(batch_index - dataParser.steps_per_epoch) % mid_freq == 0: for i in range(args.batch_size): t = _rgb_pred[i, :, :, :] t = t * 255 t = np.array(t, dtype='uint8') t = t.transpose(1, 2, 0) t = Image.fromarray(t) t.save( 'mid_result/two_stage_input/two_stage_the_midinput_%d_%d.png' % (epoch, batch_index)) _rgb = images.cpu() _rgb = _rgb.detach().numpy() if abs(batch_index - dataParser.steps_per_epoch) % mid_freq == 0: for i in range(args.batch_size): t = _rgb[i, :, :, :] t = t * 255 t = np.array(t, dtype='uint8') t = t.transpose(1, 2, 0) t = Image.fromarray(t) t.save( 'mid_result/one_stage_input/two_stage_the_midinput_%d_%d.png' % (epoch, batch_index)) two_stage_outputs = model2(rgb_pred, one_stage_outputs[9], one_stage_outputs[10], one_stage_outputs[11]) ########################################## # deal with one stage issue # 建立loss _loss_stage_1 = wce_huber_loss(one_stage_outputs[0], labels[1]) if False: loss_stage_1 *= 12 for c_index, c in enumerate(one_stage_outputs[1:9]): one_loss_t = wce_huber_loss((c, labels[c_index + 2])) loss_8t += one_loss_t writer.add_scalar('stage1_%d_map_loss' % (c_index), one_loss_t.item(), global_step=epoch * train_epoch + batch_index) loss_stage_1 += loss_8t loss_8t = torch.zeros(()) loss_stage_1 = loss_stage_1 / 20 else: loss_stage_1 = _loss_stage_1 ############################################## # deal with two stage issues _loss_stage_2 = wce_huber_loss(two_stage_outputs[0], labels[0]) * 12 for c_index, c in enumerate(two_stage_outputs[1:9]): one_loss_t = wce_huber_loss(c, labels[c_index + 2]) loss_8t += one_loss_t writer.add_scalar('stage2_%d_map_loss' % (c_index), one_loss_t.item(), global_step=epoch * train_epoch + batch_index) loss_stage_2 += loss_8t loss_stage_2 = _loss_stage_2 / 20 ####################################### # 总的LOSS writer.add_scalar('stage_one_loss', loss_stage_1.item(), global_step=epoch * train_epoch + batch_index) writer.add_scalar('stage_two_pred_loss', _loss_stage_2.item(), global_step=epoch * train_epoch + batch_index) writer.add_scalar('stage_two_fuse_loss', loss_stage_2.item(), global_step=epoch * train_epoch + batch_index) loss = (loss_stage_1 + loss_stage_2) / 2 writer.add_scalar('fuse_loss_per_epoch', loss.item(), global_step=epoch * train_epoch + batch_index) ########################################## _output = two_stage_outputs[0].cpu() _output = _output.detach().numpy() if abs(batch_index - dataParser.steps_per_epoch) % mid_freq == 0: for i in range(args.batch_size): t = _output[i, :, :] t = np.squeeze(t, 0) t = t * 255 t = np.array(t, dtype='uint8') t = Image.fromarray(t) t.save( 'mid_result/two_stage_output/two_stage_the_midoutput_%d_%d.png' % (epoch, batch_index)) _output = one_stage_outputs[0].cpu() _output = _output.detach().numpy() if abs(batch_index - dataParser.steps_per_epoch) % mid_freq == 0: for i in range(args.batch_size): t = _output[i, :, :] t = np.squeeze(t, 0) t = t * 255 t = np.array(t, dtype='uint8') t = Image.fromarray(t) t.save( 'mid_result/one_stage_output/one_stage_the_midoutput_%d_%d.png' % (epoch, batch_index)) # 这里放保存中间结1果的代码 # if batch_index in args.mid_result_index: # save_mid_result(outputs, labels, epoch, batch_index, args.mid_result_root,save_8map=True,train_phase=True) loss.backward() optimizer1.step() optimizer2.step() # measure the accuracy and record loss losses.update(loss.item()) map8_loss_value_stage1.update(loss_8t.item()) # epoch_loss.append(loss.item()) batch_time.update(time.time() - end) end = time.time() stage1_loss.update(loss_stage_1.item()) stage2_loss.update(loss_stage_2.item()) stage1_pred_loss.update(_loss_stage_1.item()) stage2_pred_loss.update(_loss_stage_2.item()) ############################################## # 评价指标 # stage 1 f1score_stage1 = my_f1_score(one_stage_outputs[0], labels[1]) precisionscore_stage1 = my_precision_score(one_stage_outputs[0], labels[1]) accscore_stage1 = my_acc_score(one_stage_outputs[0], labels[1]) recallscore_stage1 = my_recall_score(one_stage_outputs[0], labels[1]) # stage 2 f1score_stage2 = my_f1_score(two_stage_outputs[0], labels[0]) precisionscore_stage2 = my_precision_score(two_stage_outputs[0], labels[0]) accscore_stage2 = my_acc_score(two_stage_outputs[0], labels[0]) recallscore_stage2 = my_recall_score(two_stage_outputs[0], labels[0]) ################################################# writer.add_scalar('f1_score_stage1', f1score_stage1, global_step=epoch * train_epoch + batch_index) writer.add_scalar('precision_score_stage1', f1score_stage1, global_step=epoch * train_epoch + batch_index) writer.add_scalar('acc_score_stage1', f1score_stage1, global_step=epoch * train_epoch + batch_index) writer.add_scalar('recall_score_stage1', f1score_stage1, global_step=epoch * train_epoch + batch_index) writer.add_scalar('f1_score_stage2', f1score_stage2, global_step=epoch * train_epoch + batch_index) writer.add_scalar('precision_score_stage2', f1score_stage2, global_step=epoch * train_epoch + batch_index) writer.add_scalar('acc_score_stage2', f1score_stage2, global_step=epoch * train_epoch + batch_index) writer.add_scalar('recall_score_stage2', f1score_stage2, global_step=epoch * train_epoch + batch_index) ################################ f1_value_stage1.update(f1score_stage1) precision_value_stage1.update(precisionscore_stage1) acc_value_stage1.update(accscore_stage1) recall_value_stage1.update(recallscore_stage1) f1_value_stage2.update(f1score_stage2) precision_value_stage2.update(precisionscore_stage2) acc_value_stage2.update(accscore_stage2) recall_value_stage2.update(recallscore_stage2) if batch_index % args.print_freq == 0: info = 'Epoch: [{0}/{1}][{2}/{3}] '.format(epoch, args.maxepoch, batch_index, dataParser.steps_per_epoch) + \ 'Time {batch_time.val:.3f} (avg:{batch_time.avg:.3f}) '.format(batch_time=batch_time) + \ '两阶段总Loss {loss.val:f} (avg:{loss.avg:f}) '.format(loss=losses) + \ '第一阶段:f1_score {f1.val:f} (avg:{f1.avg:f}) '.format(f1=f1_value_stage1) + \ '第一阶段:precision_score: {precision.val:f} (avg:{precision.avg:f}) '.format(precision=precision_value_stage1) + \ '第一阶段:acc_score {acc.val:f} (avg:{acc.avg:f})'.format(acc=acc_value_stage1) +\ '第一阶段:recall_score {recall.val:f} (avg:{recall.avg:f})'.format(recall=recall_value_stage1) + \ '第二阶段:f1_score {f1.val:f} (avg:{f1.avg:f}) '.format(f1=f1_value_stage2) + \ '第二阶段:precision_score: {precision.val:f} (avg:{precision.avg:f}) '.format(precision=precision_value_stage2) + \ '第二阶段:acc_score {acc.val:f} (avg:{acc.avg:f})'.format(acc=acc_value_stage2) +\ '第二阶段:recall_score {recall.val:f} (avg:{recall.avg:f})'.format(recall=recall_value_stage2) print(info) # 对于每一个epoch内按照一定的频率保存评价指标,以观察震荡情况 # if batch_index % args.per_epoch_freq == 0: # writer.add_scalar('tr_loss_per_epoch', losses.val, global_step=epoch * train_epoch + batch_index) # writer.add_scalar('f1_score_per_epoch', f1score, global_step=epoch * train_epoch + batch_index) # writer.add_scalar('precision_score_per_epoch', precisionscore, # global_step=epoch * train_epoch + batch_index) # writer.add_scalar('acc_score_per_epoch', accscore, global_step=epoch * train_epoch + batch_index) # writer.add_scalar('recall_score_per_epoch',recallscore,global_step=epoch * train_epoch + batch_index) # if batch_index >= train_epoch: break # 保存模型 if epoch % 1 == 0: save_file = os.path.join( args.model_save_dir, '1104_stage1_checkpoint_epoch{}.pth'.format(epoch)) save_checkpoint( { 'epoch': epoch, 'state_dict': model1.state_dict(), 'optimizer': optimizer1.state_dict() }, filename=save_file) save_file = os.path.join( args.model_save_dir, '1104_stage2_checkpoint_epoch{}.pth'.format(epoch)) save_checkpoint( { 'epoch': epoch, 'state_dict': model2.state_dict(), 'optimizer': optimizer2.state_dict() }, filename=save_file) # save_checkpoint({ # 'epoch': epoch, # 'state_dict': model1.state_dict(), # 'optimizer': optimizer1.state_dict() # }, filename=join(save_dir, "epoch-%d-checkpoint.pth" % epoch)) return losses.avg, stage1_loss.avg, stage2_loss.avg, f1_value_stage1.avg, f1_value_stage2.avg
def val(model, epoch): torch.cuda.empty_cache() # 读取数据的迭代器 dataParser = DataParser(args.batch_size) # batch_time = Averagvalue() data_time = Averagvalue() losses = Averagvalue() # switch to train mode model.eval() end = time.time() epoch_loss = [] counter = 0 for batch_index, (images, labels_numpy) in enumerate( generate_minibatches(dataParser, False)): # 读取数据的时间 data_time.update(time.time() - end) # 对读取的numpy类型数据进行调整 labels = [] if torch.cuda.is_available(): images = torch.from_numpy(images).cuda() for item in labels_numpy: labels.append(torch.from_numpy(item).cuda()) else: images = torch.from_numpy(images) for item in labels_numpy: labels.append(torch.from_numpy(item)) # 输出结果[img,8张图] outputs = model(images) # 这里放保存中间结果的代码 if batch_index in args.mid_result_index: save_mid_result(outputs, labels, epoch, batch_index, args.mid_result_root, save_8map=True, train_phase=False) # 建立loss loss = wce_huber_loss(outputs[0], labels[0]) * 12 for c_index, c in enumerate(outputs[1:]): loss = loss + wce_huber_loss_8(c, labels[c_index + 1]) loss = loss / 20 # measure the accuracy and record loss losses.update(loss.item(), images.size(0)) epoch_loss.append(loss.item()) batch_time.update(time.time() - end) end = time.time() # 评价指标 f1score = my_f1_score(outputs[0], labels[0]) precisionscore = my_precision_score(outputs[0], labels[0]) accscore = my_acc_score(outputs[0], labels[0]) writer.add_scalar('val_f1score', f1score, global_step=epoch * dataParser.val_steps + batch_index) writer.add_scalar('val_precisionscore', precisionscore, global_step=epoch * dataParser.val_steps + batch_index) writer.add_scalar('val_acc_score', accscore, global_step=epoch * dataParser.val_steps + batch_index) if batch_index % args.print_freq == 0: info = 'Epoch: [{0}/{1}][{2}/{3}] '.format(epoch, args.maxepoch, batch_index, dataParser.val_steps) + \ 'Time {batch_time.val:.3f} (avg:{batch_time.avg:.3f}) '.format(batch_time=batch_time) + \ 'Loss {loss.val:f} (avg:{loss.avg:f}) '.format(loss=losses) + \ 'f1_score : %.4f ' % f1score + \ 'precision_score: %.4f ' % precisionscore + \ 'acc_score %.4f ' % accscore print('val: ', info) writer.add_scalar('val_avg_loss2', losses.val, global_step=epoch * (dataParser.val_steps // 100) + batch_index) if batch_index > dataParser.val_steps // 1: break return losses.avg, epoch_loss
def val(model, dataParser, epoch): # 读取数据的迭代器 val_epoch = len(dataParser) # 变量保存 batch_time = Averagvalue() data_time = Averagvalue() losses = Averagvalue() f1_value = Averagvalue() acc_value = Averagvalue() recall_value = Averagvalue() precision_value = Averagvalue() map8_loss_value = Averagvalue() # switch to test mode model.eval() end = time.time() for batch_index, input_data in enumerate(dataParser): # 读取数据的时间 data_time.update(time.time() - end) images = input_data['tamper_image'] labels = input_data['gt_band'] if torch.cuda.is_available(): images = images.cuda() labels = labels.cuda() # 对读取的numpy类型数据进行调整 if torch.cuda.is_available(): loss = torch.zeros(1).cuda() loss_8t = torch.zeros(()).cuda() else: loss = torch.zeros(1) loss_8t = torch.zeros(()) # 网络输出 outputs = model(images)[0] # 这里放保存中间结果的代码 if args.save_mid_result: if batch_index in args.mid_result_index: save_mid_result(outputs, labels, epoch, batch_index, args.mid_result_root, save_8map=True, train_phase=True) else: pass else: pass """""" """""" """""" """""" """""" " Loss 函数 " """""" """""" """""" """""" """""" loss = wce_dice_huber_loss(outputs, labels) writer.add_scalar('val_fuse_loss_per_epoch', loss.item(), global_step=epoch * val_epoch + batch_index) # 将各种数据记录到专门的对象中 losses.update(loss.item()) map8_loss_value.update(loss_8t.item()) batch_time.update(time.time() - end) end = time.time() # 评价指标 f1score = my_f1_score(outputs, labels) precisionscore = my_precision_score(outputs, labels) accscore = my_acc_score(outputs, labels) recallscore = my_recall_score(outputs, labels) writer.add_scalar('val_f1_score', f1score, global_step=epoch * val_epoch + batch_index) writer.add_scalar('val_precision_score', precisionscore, global_step=epoch * val_epoch + batch_index) writer.add_scalar('val_acc_score', accscore, global_step=epoch * val_epoch + batch_index) writer.add_scalar('val_recall_score', recallscore, global_step=epoch * val_epoch + batch_index) ################################ f1_value.update(f1score) precision_value.update(precisionscore) acc_value.update(accscore) recall_value.update(recallscore) if batch_index % args.print_freq == 0: info = 'Epoch: [{0}/{1}][{2}/{3}] '.format(epoch, args.maxepoch, batch_index, val_epoch) + \ 'Time {batch_time.val:.3f} (avg:{batch_time.avg:.3f}) '.format(batch_time=batch_time) + \ 'vla_Loss {loss.val:f} (avg:{loss.avg:f}) '.format(loss=losses) + \ 'val_f1_score {f1.val:f} (avg:{f1.avg:f}) '.format(f1=f1_value) + \ 'val_precision_score: {precision.val:f} (avg:{precision.avg:f}) '.format(precision=precision_value) + \ 'val_acc_score {acc.val:f} (avg:{acc.avg:f})'.format(acc=acc_value) + \ 'val_recall_score {recall.val:f} (avg:{recall.avg:f})'.format(recall=recall_value) print(info) if batch_index >= val_epoch: break return { 'loss_avg': losses.avg, 'f1_avg': f1_value.avg, 'precision_avg': precision_value.avg, 'accuracy_avg': acc_value.avg, 'recall_avg': recall_value.avg }
def val(model1, model2, dataParser, epoch): # 读取数据的迭代器 val_epoch = len(dataParser) # 变量保存 batch_time = Averagvalue() data_time = Averagvalue() losses = Averagvalue() loss_stage1 = Averagvalue() loss_stage2 = Averagvalue() f1_value_stage1 = Averagvalue() acc_value_stage1 = Averagvalue() recall_value_stage1 = Averagvalue() precision_value_stage1 = Averagvalue() f1_value_stage2 = Averagvalue() acc_value_stage2 = Averagvalue() recall_value_stage2 = Averagvalue() precision_value_stage2 = Averagvalue() map8_loss_value = [ Averagvalue(), Averagvalue(), Averagvalue(), Averagvalue(), Averagvalue(), Averagvalue(), Averagvalue(), Averagvalue(), Averagvalue(), Averagvalue() ] # switch to train mode model1.eval() model2.eval() end = time.time() for batch_index, input_data in enumerate(dataParser): # 读取数据的时间 data_time.update(time.time() - end) # check_4dim_img_pair(input_data['tamper_image'],input_data['gt_band']) # 准备输入数据 images = input_data['tamper_image'].cuda() labels_band = input_data['gt_band'].cuda() labels_dou_edge = input_data['gt_dou_edge'].cuda() relation_map = input_data['relation_map'] if torch.cuda.is_available(): loss_8t = torch.zeros(()).cuda() else: loss_8t = torch.zeros(()) with torch.set_grad_enabled(False): images.requires_grad = False # 网络输出 one_stage_outputs = model1(images) rgb_pred = images * one_stage_outputs[0] rgb_pred_rgb = torch.cat((rgb_pred, images), 1) two_stage_outputs = model2(rgb_pred_rgb, one_stage_outputs[1], one_stage_outputs[2], one_stage_outputs[3]) """""" """""" """""" """""" """""" " Loss 函数 " """""" """""" """""" """""" """""" ########################################## # deal with one stage issue # 建立loss loss_stage_1 = wce_dice_huber_loss(one_stage_outputs[0], labels_band) ############################################## # deal with two stage issues _loss_stage_2 = wce_dice_huber_loss(two_stage_outputs[0], labels_dou_edge) * 12 for c_index, c in enumerate(two_stage_outputs[1:9]): one_loss_t = map8_loss_ce(c, relation_map[c_index].cuda()) loss_8t += one_loss_t map8_loss_value[c_index].update(one_loss_t.item()) _loss_stage_2 += loss_8t loss_stage_2 = _loss_stage_2 / 20 loss = (loss_stage_1 + loss_stage_2) / 2 ####################################### # 总的LOSS writer.add_scalar('val_stage_one_loss', loss_stage_1.item(), global_step=epoch * val_epoch + batch_index) writer.add_scalar('val_stage_two_fuse_loss', loss_stage_2.item(), global_step=epoch * val_epoch + batch_index) writer.add_scalar('val_fuse_loss_per_epoch', loss.item(), global_step=epoch * val_epoch + batch_index) ########################################## # 将各种数据记录到专门的对象中 losses.update(loss.item()) loss_stage1.update(loss_stage_1.item()) loss_stage2.update(loss_stage_2.item()) batch_time.update(time.time() - end) end = time.time() # 评价指标 f1score_stage2 = my_f1_score(two_stage_outputs[0], labels_dou_edge) precisionscore_stage2 = my_precision_score(two_stage_outputs[0], labels_dou_edge) accscore_stage2 = my_acc_score(two_stage_outputs[0], labels_dou_edge) recallscore_stage2 = my_recall_score(two_stage_outputs[0], labels_dou_edge) f1score_stage1 = my_f1_score(one_stage_outputs[0], labels_band) precisionscore_stage1 = my_precision_score(one_stage_outputs[0], labels_band) accscore_stage1 = my_acc_score(one_stage_outputs[0], labels_band) recallscore_stage1 = my_recall_score(one_stage_outputs[0], labels_band) writer.add_scalar('val_f1_score_stage1', f1score_stage1, global_step=epoch * val_epoch + batch_index) writer.add_scalar('val_precision_score_stage1', precisionscore_stage1, global_step=epoch * val_epoch + batch_index) writer.add_scalar('val_acc_score_stage1', accscore_stage1, global_step=epoch * val_epoch + batch_index) writer.add_scalar('val_recall_score_stage1', recallscore_stage1, global_step=epoch * val_epoch + batch_index) writer.add_scalar('val_f1_score_stage2', f1score_stage2, global_step=epoch * val_epoch + batch_index) writer.add_scalar('val_precision_score_stage2', precisionscore_stage2, global_step=epoch * val_epoch + batch_index) writer.add_scalar('val_acc_score_stage2', accscore_stage2, global_step=epoch * val_epoch + batch_index) writer.add_scalar('val_recall_score_stage2', recallscore_stage2, global_step=epoch * val_epoch + batch_index) ################################ f1_value_stage1.update(f1score_stage1) precision_value_stage1.update(precisionscore_stage1) acc_value_stage1.update(accscore_stage1) recall_value_stage1.update(recallscore_stage1) f1_value_stage2.update(f1score_stage2) precision_value_stage2.update(precisionscore_stage2) acc_value_stage2.update(accscore_stage2) recall_value_stage2.update(recallscore_stage2) if batch_index % args.print_freq == 0: info = 'Epoch: [{0}/{1}][{2}/{3}] '.format(epoch, args.maxepoch, batch_index, val_epoch) + \ 'Time {batch_time.val:.3f} (avg:{batch_time.avg:.3f}) '.format(batch_time=batch_time) + \ '两阶段总Loss {loss.val:f} (avg:{loss.avg:f}) '.format(loss=losses) + \ '第一阶段Loss {loss.val:f} (avg:{loss.avg:f}) '.format(loss=loss_stage1) + \ '第二阶段Loss {loss.val:f} (avg:{loss.avg:f}) '.format(loss=loss_stage2) + \ '第一阶段:f1_score {f1.val:f} (avg:{f1.avg:f}) '.format(f1=f1_value_stage1) + \ '第一阶段:precision_score: {precision.val:f} (avg:{precision.avg:f}) '.format( precision=precision_value_stage1) + \ '第一阶段:acc_score {acc.val:f} (avg:{acc.avg:f})'.format(acc=acc_value_stage1) + \ '第一阶段:recall_score {recall.val:f} (avg:{recall.avg:f})'.format(recall=recall_value_stage1) + \ '第二阶段:f1_score {f1.val:f} (avg:{f1.avg:f}) '.format(f1=f1_value_stage2) + \ '第二阶段:precision_score: {precision.val:f} (avg:{precision.avg:f}) '.format( precision=precision_value_stage2) + \ '第二阶段:acc_score {acc.val:f} (avg:{acc.avg:f})'.format(acc=acc_value_stage2) + \ '第二阶段:recall_score {recall.val:f} (avg:{recall.avg:f})'.format(recall=recall_value_stage2) print(info) if batch_index >= val_epoch: break return { 'loss_avg': losses.avg, 'f1_avg_stage1': f1_value_stage1.avg, 'precision_avg_stage1': precision_value_stage1.avg, 'accuracy_avg_stage1': acc_value_stage1.avg, 'recall_avg_stage1': recall_value_stage1.avg, 'f1_avg_stage2': f1_value_stage2.avg, 'precision_avg_stage2': precision_value_stage2.avg, 'accuracy_avg_stage2': acc_value_stage2.avg, 'recall_avg_stage2': recall_value_stage2.avg, 'map8_loss': [map8_loss.avg for map8_loss in map8_loss_value], }
def train(model, optimizer, dataParser, epoch): # 读取数据的迭代器 train_epoch = len(dataParser) # 变量保存 batch_time = Averagvalue() data_time = Averagvalue() losses = Averagvalue() f1_value = Averagvalue() acc_value = Averagvalue() recall_value = Averagvalue() precision_value = Averagvalue() map8_loss_value = Averagvalue() # switch to train mode model.train() end = time.time() for batch_index, input_data in enumerate(dataParser): # 读取数据的时间 data_time.update(time.time() - end) # check_4dim_img_pair(input_data['tamper_image'],input_data['gt_band']) # 准备输入数据 images = input_data['tamper_image'].cuda() labels = input_data['gt_band'].cuda() if torch.cuda.is_available(): loss = torch.zeros(1).cuda() loss_8t = torch.zeros(()).cuda() else: loss = torch.zeros(1) loss_8t = torch.zeros(()) with torch.set_grad_enabled(True): images.requires_grad = True optimizer.zero_grad() # 网络输出 outputs = model(images)[0] # 这里放保存中间结果的代码 """""" """""" """""" """""" """""" " Loss 函数 " """""" """""" """""" """""" """""" loss = wce_dice_huber_loss(outputs, labels) writer.add_scalar('loss_per_batch', loss.item(), global_step=epoch * train_epoch + batch_index) loss.backward() optimizer.step() # 将各种数据记录到专门的对象中 losses.update(loss.item()) map8_loss_value.update(loss_8t.item()) batch_time.update(time.time() - end) end = time.time() # 评价指标 f1score = my_f1_score(outputs, labels) precisionscore = my_precision_score(outputs, labels) accscore = my_acc_score(outputs, labels) recallscore = my_recall_score(outputs, labels) writer.add_scalar('f1_score', f1score, global_step=epoch * train_epoch + batch_index) writer.add_scalar('precision_score', precisionscore, global_step=epoch * train_epoch + batch_index) writer.add_scalar('acc_score', accscore, global_step=epoch * train_epoch + batch_index) writer.add_scalar('recall_score', recallscore, global_step=epoch * train_epoch + batch_index) ################################ f1_value.update(f1score) precision_value.update(precisionscore) acc_value.update(accscore) recall_value.update(recallscore) if batch_index % args.print_freq == 0: info = 'Epoch: [{0}/{1}][{2}/{3}] '.format(epoch, args.maxepoch, batch_index, train_epoch) + \ 'Time {batch_time.val:.3f} (avg:{batch_time.avg:.3f}) '.format(batch_time=batch_time) + \ 'Loss {loss.val:f} (avg:{loss.avg:f}) '.format(loss=losses) + \ 'f1_score {f1.val:f} (avg:{f1.avg:f}) '.format(f1=f1_value) + \ 'precision_score: {precision.val:f} (avg:{precision.avg:f}) '.format(precision=precision_value) + \ 'acc_score {acc.val:f} (avg:{acc.avg:f})'.format(acc=acc_value) + \ 'recall_score {recall.val:f} (avg:{recall.avg:f})'.format(recall=recall_value) print(info) if batch_index >= train_epoch: break return { 'loss_avg': losses.avg, 'f1_avg': f1_value.avg, 'precision_avg': precision_value.avg, 'accuracy_avg': acc_value.avg, 'recall_avg': recall_value.avg }
def train(model1, model2, optimizer1, optimizer2, dataParser, epoch): # 读取数据的迭代器 train_epoch = len(dataParser) # 变量保存 batch_time = Averagvalue() data_time = Averagvalue() losses = Averagvalue() loss_stage1 = Averagvalue() loss_stage2 = Averagvalue() f1_value_stage1 = Averagvalue() acc_value_stage1 = Averagvalue() recall_value_stage1 = Averagvalue() precision_value_stage1 = Averagvalue() f1_value_stage2 = Averagvalue() acc_value_stage2 = Averagvalue() recall_value_stage2 = Averagvalue() precision_value_stage2 = Averagvalue() map8_loss_value = Averagvalue() # switch to train mode model1.train() model2.train() end = time.time() for batch_index, input_data in enumerate(dataParser): # 读取数据的时间 data_time.update(time.time() - end) # check_4dim_img_pair(input_data['tamper_image'],input_data['gt_band']) # 准备输入数据 images = input_data['tamper_image'].cuda() labels_band = input_data['gt_band'].cuda() labels_dou_edge = input_data['gt_dou_edge'].cuda() relation_map = input_data['relation_map'] image_path = input_data['path'] if torch.cuda.is_available(): loss = torch.zeros(1).cuda() loss_8t = torch.zeros(()).cuda() else: loss = torch.zeros(1) loss_8t = torch.zeros(()) with torch.set_grad_enabled(True): images.requires_grad = True optimizer1.zero_grad() optimizer2.zero_grad() if images.shape[1] != 3 or images.shape[2] != 320: continue # 网络输出 try: one_stage_outputs = model1(images) except: print(images) continue zero = torch.zeros_like(one_stage_outputs[0]) one = torch.ones_like(one_stage_outputs[0]) rgb_pred = images * torch.where(one_stage_outputs[0] > 0.1, one, zero) rgb_pred_rgb = torch.cat((rgb_pred, images), 1) two_stage_outputs = model2(rgb_pred_rgb, one_stage_outputs[9], one_stage_outputs[10], one_stage_outputs[11]) """""" """""" """""" """""" """""" " Loss 函数 " """""" """""" """""" """""" """""" ########################################## # deal with one stage issue # 建立loss _loss_stage_1 = wce_dice_huber_loss(one_stage_outputs[0], labels_band) loss_stage_1 = _loss_stage_1 ############################################## # deal with two stage issues _loss_stage_2 = wce_dice_huber_loss(two_stage_outputs[0], labels_dou_edge) * 12 for c_index, c in enumerate(two_stage_outputs[1:9]): one_loss_t = cross_entropy_loss(c, relation_map[c_index].cuda()) loss_8t += one_loss_t writer.add_scalar('stage2_%d_map_loss' % (c_index), one_loss_t.item(), global_step=epoch * train_epoch + batch_index) _loss_stage_2 += loss_8t loss_stage_2 = _loss_stage_2 / 20 loss = loss_stage_2 ####################################### # 总的LOSS # print(type(loss_stage_2.item())) writer.add_scalars('loss_gather', { 'stage_one_loss': loss_stage_1.item(), 'stage_two_pred_loss': _loss_stage_2.item(), 'stage_two_fuse_loss': loss_stage_2.item(), 'fuse_loss_per_epoch': loss.item() }, global_step=epoch * train_epoch + batch_index) ########################################## loss.backward() optimizer1.step() optimizer2.step() # 将各种数据记录到专门的对象中 losses.update(loss.item()) loss_stage1.update(loss_stage_1.item()) loss_stage2.update(loss_stage_2.item()) map8_loss_value.update(loss_8t.item()) batch_time.update(time.time() - end) end = time.time() # 评价指标 f1score_stage2 = my_f1_score(two_stage_outputs[0], labels_dou_edge) precisionscore_stage2 = my_precision_score(two_stage_outputs[0], labels_dou_edge) accscore_stage2 = my_acc_score(two_stage_outputs[0], labels_dou_edge) recallscore_stage2 = my_recall_score(two_stage_outputs[0], labels_dou_edge) f1score_stage1 = my_f1_score(one_stage_outputs[0], labels_band) precisionscore_stage1 = my_precision_score(one_stage_outputs[0], labels_band) accscore_stage1 = my_acc_score(one_stage_outputs[0], labels_band) recallscore_stage1 = my_recall_score(one_stage_outputs[0], labels_band) writer.add_scalars('f1_score_stage', { 'stage1': f1score_stage1, 'stage2': f1score_stage2 }, global_step=epoch * train_epoch + batch_index) writer.add_scalars('precision_score_stage', { 'stage1': precisionscore_stage1, 'stage2': precisionscore_stage2 }, global_step=epoch * train_epoch + batch_index) writer.add_scalars('acc_score_stage', { 'stage1': accscore_stage1, 'stage2': accscore_stage2 }, global_step=epoch * train_epoch + batch_index) writer.add_scalars('recall_score_stage', { 'stage1': recallscore_stage1, 'stage2': recallscore_stage2 }, global_step=epoch * train_epoch + batch_index) ################################ f1_value_stage1.update(f1score_stage1) precision_value_stage1.update(precisionscore_stage1) acc_value_stage1.update(accscore_stage1) recall_value_stage1.update(recallscore_stage1) f1_value_stage2.update(f1score_stage2) precision_value_stage2.update(precisionscore_stage2) acc_value_stage2.update(accscore_stage2) recall_value_stage2.update(recallscore_stage2) if batch_index % args.print_freq == 0: info = 'Epoch: [{0}/{1}][{2}/{3}] '.format(epoch, args.maxepoch, batch_index, train_epoch) + \ 'Time {batch_time.val:.3f} (avg:{batch_time.avg:.3f}) '.format(batch_time=batch_time) + \ '两阶段总Loss {loss.val:f} (avg:{loss.avg:f}) '.format(loss=losses) + \ '第一阶段Loss {loss.val:f} (avg:{loss.avg:f}) '.format(loss=loss_stage1) + \ '第二阶段Loss {loss.val:f} (avg:{loss.avg:f}) '.format(loss=loss_stage2) + \ '第一阶段:f1_score {f1.val:f} (avg:{f1.avg:f}) '.format(f1=f1_value_stage1) + \ '第一阶段:precision_score: {precision.val:f} (avg:{precision.avg:f}) '.format( precision=precision_value_stage1) + \ '第一阶段:acc_score {acc.val:f} (avg:{acc.avg:f})'.format(acc=acc_value_stage1) + \ '第一阶段:recall_score {recall.val:f} (avg:{recall.avg:f})'.format(recall=recall_value_stage1) + \ '第二阶段:f1_score {f1.val:f} (avg:{f1.avg:f}) '.format(f1=f1_value_stage2) + \ '第二阶段:precision_score: {precision.val:f} (avg:{precision.avg:f}) '.format( precision=precision_value_stage2) + \ '第二阶段:acc_score {acc.val:f} (avg:{acc.avg:f})'.format(acc=acc_value_stage2) + \ '第二阶段:recall_score {recall.val:f} (avg:{recall.avg:f})'.format(recall=recall_value_stage2) print(info) if batch_index >= train_epoch: break return { 'loss_avg': losses.avg, 'f1_avg_stage1': f1_value_stage1.avg, 'precision_avg_stage1': precision_value_stage1.avg, 'accuracy_avg_stage1': acc_value_stage1.avg, 'recall_avg_stage1': recall_value_stage1.avg, 'f1_avg_stage2': f1_value_stage2.avg, 'precision_avg_stage2': precision_value_stage2.avg, 'accuracy_avg_stage2': acc_value_stage2.avg, 'recall_avg_stage2': recall_value_stage2.avg }
def val(model, dataParser, epoch): # 读取数据的迭代器 train_epoch = int(dataParser.val_steps) # 变量保存 batch_time = Averagvalue() data_time = Averagvalue() losses = Averagvalue() f1_value = Averagvalue() acc_value = Averagvalue() recall_value = Averagvalue() precision_value = Averagvalue() map8_loss_value = Averagvalue() # switch to test mode model.eval() end = time.time() for batch_index, (images, labels_numpy) in enumerate( generate_minibatches(dataParser, False)): # 读取数据的时间 data_time.update(time.time() - end) # 对读取的numpy类型数据进行调整 labels = [] if torch.cuda.is_available(): images = torch.from_numpy(images).cuda() for item in labels_numpy: labels.append(torch.from_numpy(item).cuda()) else: images = torch.from_numpy(images) for item in labels_numpy: labels.append(torch.from_numpy(item)) if torch.cuda.is_available(): loss = torch.zeros(1).cuda() loss_8t = torch.zeros(()).cuda() else: loss = torch.zeros(1) loss_8t = torch.zeros(()) # 网络输出 outputs = model(images) # 这里放保存中间结果的代码 if args.save_mid_result: if batch_index in args.mid_result_index: save_mid_result(outputs, labels, epoch, batch_index, args.mid_result_root, save_8map=True, train_phase=True) else: pass else: pass """""" """""" """""" """""" """""" " Loss 函数 " """""" """""" """""" """""" """""" if not args.band_mode: # 如果不是使用band_mode 则需要计算8张图的loss loss = wce_dice_huber_loss(outputs[0], labels[0]) * args.fuse_loss_weight writer.add_scalar('val_fuse_loss_per_epoch', loss.item() / args.fuse_loss_weight, global_step=epoch * train_epoch + batch_index) for c_index, c in enumerate(outputs[1:]): one_loss_t = wce_dice_huber_loss(c, labels[c_index + 1]) loss_8t += one_loss_t writer.add_scalar('val_%d_map_loss' % (c_index), one_loss_t.item(), global_step=train_epoch) loss += loss_8t loss = loss / 20 else: loss = wce_dice_huber_loss(outputs[0], labels[0]) writer.add_scalar('val_fuse_loss_per_epoch', loss.item(), global_step=epoch * train_epoch + batch_index) # 将各种数据记录到专门的对象中 losses.update(loss.item()) map8_loss_value.update(loss_8t.item()) batch_time.update(time.time() - end) end = time.time() # 评价指标 f1score = my_f1_score(outputs[0], labels[0]) precisionscore = my_precision_score(outputs[0], labels[0]) accscore = my_acc_score(outputs[0], labels[0]) recallscore = my_recall_score(outputs[0], labels[0]) writer.add_scalar('val_f1_score', f1score, global_step=epoch * train_epoch + batch_index) writer.add_scalar('val_precision_score', precisionscore, global_step=epoch * train_epoch + batch_index) writer.add_scalar('val_acc_score', accscore, global_step=epoch * train_epoch + batch_index) writer.add_scalar('val_recall_score', recallscore, global_step=epoch * train_epoch + batch_index) ################################ f1_value.update(f1score) precision_value.update(precisionscore) acc_value.update(accscore) recall_value.update(recallscore) if batch_index % args.print_freq == 0: info = 'Epoch: [{0}/{1}][{2}/{3}] '.format(epoch, args.maxepoch, batch_index, dataParser.val_steps) + \ 'Time {batch_time.val:.3f} (avg:{batch_time.avg:.3f}) '.format(batch_time=batch_time) + \ 'vla_Loss {loss.val:f} (avg:{loss.avg:f}) '.format(loss=losses) + \ 'val_f1_score {f1.val:f} (avg:{f1.avg:f}) '.format(f1=f1_value) + \ 'val_precision_score: {precision.val:f} (avg:{precision.avg:f}) '.format(precision=precision_value) + \ 'val_acc_score {acc.val:f} (avg:{acc.avg:f})'.format(acc=acc_value) + \ 'val_recall_score {recall.val:f} (avg:{recall.avg:f})'.format(recall=recall_value) print(info) if batch_index >= train_epoch: break return { 'loss_avg': losses.avg, 'f1_avg': f1_value.avg, 'precision_avg': precision_value.avg, 'accuracy_avg': acc_value.avg, 'recall_avg': recall_value.avg }
def train(model, optimizer, dataParser, epoch): # 读取数据的迭代器 train_epoch = len(dataParser) # 变量保存 batch_time = Averagvalue() data_time = Averagvalue() losses = Averagvalue() f1_value = Averagvalue() acc_value = Averagvalue() recall_value = Averagvalue() precision_value = Averagvalue() map8_loss_value = Averagvalue() # switch to train mode model.train() end = time.time() for batch_index, input_data in enumerate(dataParser): # 读取数据的时间 data_time.update(time.time() - end) # check_4dim_img_pair(input_data['tamper_image'],input_data['gt_band']) # 准备输入数据 images = input_data['tamper_image'].cuda() labels = input_data['gt_band'].cuda() # 对读取的numpy类型数据进行调整 # labels = [] # if torch.cuda.is_available(): # images = torch.from_numpy(images).cuda() # for item in labels_numpy: # labels.append(torch.from_numpy(item).cuda()) # else: # images = torch.from_numpy(images) # for item in labels_numpy: # labels.append(torch.from_numpy(item)) if torch.cuda.is_available(): loss = torch.zeros(1).cuda() loss_8t = torch.zeros(()).cuda() else: loss = torch.zeros(1) loss_8t = torch.zeros(()) with torch.set_grad_enabled(True): images.requires_grad = True optimizer.zero_grad() # 网络输出 outputs = model(images) # 这里放保存中间结果的代码 if args.save_mid_result: if batch_index in args.mid_result_index: save_mid_result(outputs, labels, epoch, batch_index, args.mid_result_root, save_8map=True, train_phase=True) else: pass else: pass """""" """""" """""" """""" """""" " Loss 函数 " """""" """""" """""" """""" """""" # if not args.band_mode: # # 如果不是使用band_mode 则需要计算8张图的loss # loss = wce_dice_huber_loss(outputs[0], labels[0]) * args.fuse_loss_weight # # writer.add_scalar('fuse_loss_per_epoch', loss.item() / args.fuse_loss_weight, # global_step=epoch * train_epoch + batch_index) # # for c_index, c in enumerate(outputs[1:]): # one_loss_t = wce_dice_huber_loss(c, labels[c_index + 1]) # loss_8t += one_loss_t # writer.add_scalar('%d_map_loss' % (c_index), one_loss_t.item(), global_step=train_epoch) # loss += loss_8t # loss = loss / 20 loss = wce_dice_huber_loss(outputs[0], labels) writer.add_scalar('fuse_loss_per_epoch', loss.item(), global_step=epoch * train_epoch + batch_index) loss.backward() optimizer.step() # 将各种数据记录到专门的对象中 losses.update(loss.item()) map8_loss_value.update(loss_8t.item()) batch_time.update(time.time() - end) end = time.time() # 评价指标 f1score = my_f1_score(outputs[0], labels) precisionscore = my_precision_score(outputs[0], labels) accscore = my_acc_score(outputs[0], labels) recallscore = my_recall_score(outputs[0], labels) writer.add_scalar('f1_score', f1score, global_step=epoch * train_epoch + batch_index) writer.add_scalar('precision_score', precisionscore, global_step=epoch * train_epoch + batch_index) writer.add_scalar('acc_score', accscore, global_step=epoch * train_epoch + batch_index) writer.add_scalar('recall_score', recallscore, global_step=epoch * train_epoch + batch_index) ################################ f1_value.update(f1score) precision_value.update(precisionscore) acc_value.update(accscore) recall_value.update(recallscore) if batch_index % args.print_freq == 0: info = 'Epoch: [{0}/{1}][{2}/{3}] '.format(epoch, args.maxepoch, batch_index, train_epoch) + \ 'Time {batch_time.val:.3f} (avg:{batch_time.avg:.3f}) '.format(batch_time=batch_time) + \ 'Loss {loss.val:f} (avg:{loss.avg:f}) '.format(loss=losses) + \ 'f1_score {f1.val:f} (avg:{f1.avg:f}) '.format(f1=f1_value) + \ 'precision_score: {precision.val:f} (avg:{precision.avg:f}) '.format(precision=precision_value) + \ 'acc_score {acc.val:f} (avg:{acc.avg:f})'.format(acc=acc_value) + \ 'recall_score {recall.val:f} (avg:{recall.avg:f})'.format(recall=recall_value) print(info) if batch_index >= train_epoch: break return { 'loss_avg': losses.avg, 'f1_avg': f1_value.avg, 'precision_avg': precision_value.avg, 'accuracy_avg': acc_value.avg, 'recall_avg': recall_value.avg }
def test(model, dataParser, epoch): # 读取数据的迭代器 test_epoch = len(dataParser) # 变量保存 batch_time = Averagvalue() data_time = Averagvalue() losses = Averagvalue() f1_value = Averagvalue() acc_value = Averagvalue() recall_value = Averagvalue() precision_value = Averagvalue() map8_loss_value = Averagvalue() # switch to test mode model.eval() end = time.time() for batch_index, input_data in enumerate(dataParser): # 读取数据的时间 data_time.update(time.time() - end) images = input_data['tamper_image'] labels = input_data['gt_band'] if torch.cuda.is_available(): images = images.cuda() labels = labels.cuda() if torch.cuda.is_available(): loss = torch.zeros(1).cuda() loss_8t = torch.zeros(()).cuda() else: loss = torch.zeros(1) loss_8t = torch.zeros(()) # 网络输出 try: outputs = model(images)[0] """""" """""" """""" """""" """""" " Loss 函数 " """""" """""" """""" """""" """""" loss = wce_dice_huber_loss(outputs, labels) except Exception as e: continue writer.add_scalar('val_fuse_loss_per_epoch', loss.item(), global_step=epoch * test_epoch + batch_index) # 将各种数据记录到专门的对象中 losses.update(loss.item()) map8_loss_value.update(loss_8t.item()) batch_time.update(time.time() - end) end = time.time() # 评价指标 f1score = my_f1_score(outputs, labels) precisionscore = my_precision_score(outputs, labels) accscore = my_acc_score(outputs, labels) recallscore = my_recall_score(outputs, labels) writer.add_scalar('test_f1_score', f1score, global_step=epoch * test_epoch + batch_index) writer.add_scalar('test_precision_score', precisionscore, global_step=epoch * test_epoch + batch_index) writer.add_scalar('test_acc_score', accscore, global_step=epoch * test_epoch + batch_index) writer.add_scalar('test_recall_score', recallscore, global_step=epoch * test_epoch + batch_index) writer.add_images('test_image_batch:%d' % (batch_index), outputs, global_step=epoch) ################################ f1_value.update(f1score) precision_value.update(precisionscore) acc_value.update(accscore) recall_value.update(recallscore) if batch_index % args.print_freq == 0: info = 'TEST_Epoch: [{0}/{1}][{2}/{3}] '.format(epoch, args.maxepoch, batch_index, test_epoch) + \ 'Time {batch_time.val:.3f} (avg:{batch_time.avg:.3f}) '.format(batch_time=batch_time) + \ 'test_Loss {loss.val:f} (avg:{loss.avg:f}) '.format(loss=losses) + \ 'test_f1_score {f1.val:f} (avg:{f1.avg:f}) '.format(f1=f1_value) + \ 'test_precision_score: {precision.val:f} (avg:{precision.avg:f}) '.format( precision=precision_value) + \ 'test_acc_score {acc.val:f} (avg:{acc.avg:f})'.format(acc=acc_value) + \ 'test_recall_score {recall.val:f} (avg:{recall.avg:f})'.format(recall=recall_value) print(info) if batch_index >= test_epoch: break return { 'loss_avg': losses.avg, 'f1_avg': f1_value.avg, 'precision_avg': precision_value.avg, 'accuracy_avg': acc_value.avg, 'recall_avg': recall_value.avg }