def main(): args = get_args() if args.opts: cfg.merge_from_list(args.opts) cfg.freeze() # create model print("=> creating model '{}'".format(cfg.MODEL.ARCH)) model = get_model(model_name=cfg.MODEL.ARCH, pretrained=None) device = "cuda" if torch.cuda.is_available() else "cpu" model = model.to(device) # load checkpoint resume_path = args.resume if Path(resume_path).is_file(): print("=> loading checkpoint '{}'".format(resume_path)) checkpoint = torch.load(resume_path, map_location="cpu") model.load_state_dict(checkpoint['state_dict']) print("=> loaded checkpoint '{}'".format(resume_path)) else: raise ValueError("=> no checkpoint found at '{}'".format(resume_path)) if device == "cuda": cudnn.benchmark = True test_dataset = FaceDataset(args.data_dir, "test", img_size=cfg.MODEL.IMG_SIZE, augment=False) test_loader = DataLoader(test_dataset, batch_size=cfg.TEST.BATCH_SIZE, shuffle=False, num_workers=cfg.TRAIN.WORKERS, drop_last=False) print("=> start testing") _, _, test_mae = validate(test_loader, model, None, 0, device) print(f"test mae: {test_mae:.3f}")
def main_cs(mydict): # py脚本额外参数 args = get_args() # main函数传入参数 my_data_dir = mydict["data_dir"] my_ifSE = mydict["ifSE"] my_l1loss = mydict["l1loss"] my_resume = mydict["resume"] if my_l1loss: l1loss = 0.1 else: l1loss = 0.0 if args.opts: cfg.merge_from_list(args.opts) cfg.freeze() # create model_dir print("=> creating model_dir '{}'".format(cfg.MODEL.ARCH)) # model = get_model(model_name=cfg.MODEL.ARCH, pretrained=None) model = my_model(my_ifSE) device = "cuda" if torch.cuda.is_available() else "cpu" model = model.to(device) # load checkpoint resume_path = my_resume if Path(resume_path).is_file(): print("=> loading checkpoint '{}'".format(resume_path)) checkpoint = torch.load(resume_path, map_location="cpu") model.load_state_dict(checkpoint['state_dict']) print("=>ckpt loaded checkpoint '{}'".format(resume_path)) else: raise ValueError( "=> no checkpoTrueint found at '{}'".format(resume_path)) if device == "cuda": cudnn.benchmark = True test_dataset = FaceDataset_morph2(my_data_dir, "test", img_size=cfg.MODEL.IMG_SIZE, augment=False) test_loader = DataLoader(test_dataset, batch_size=cfg.BATCH_SIZE, shuffle=False, num_workers=cfg.TRAIN.WORKERS, drop_last=False) print("=> start testing") _, _, test_cs = validate_cs(test_loader, model, None, 0, device, l1loss) print(f"test cs list: {test_cs}") return test_cs
def main(): args = get_args() if args.opts: cfg.merge_from_list(args.opts) cfg.freeze() # create model print("=> creating model '{}'".format(cfg.MODEL.ARCH)) model = get_model(model_name=cfg.MODEL.ARCH, pretrained=None) device = "cuda" if torch.cuda.is_available() else "cpu" model = model.to(device) # TODO: delete if torch.cuda.device_count() > 1: print("Let's use [1,2,4,5] GPUs!") # dim = 0 [30, xxx] -> [10, ...], [10, ...], [10, ...] on 3 GPUs model = nn.DataParallel(model, device_ids=[1, 2, 4, 5]) model.to(device) # load checkpoint resume_path = args.resume if Path(resume_path).is_file(): print("=> loading checkpoint '{}'".format(resume_path)) checkpoint = torch.load(resume_path, map_location="cpu") model.load_state_dict(checkpoint['state_dict']) print("=> loaded checkpoint '{}'".format(resume_path)) else: raise ValueError("=> no checkpoint found at '{}'".format(resume_path)) if device == "cuda": cudnn.benchmark = True test_dataset = FaceDataset(args.data_dir, "test", img_size=cfg.MODEL.IMG_SIZE, augment=False) test_loader = DataLoader(test_dataset, batch_size=cfg.TEST.BATCH_SIZE, shuffle=False, num_workers=cfg.TRAIN.WORKERS, drop_last=False) criterion = nn.CrossEntropyLoss().to(device) print("=> start testing") _, _, test_mae, gen_acc = validate(test_loader, model, criterion, 0, device) print(f"Test age mae: {test_mae:.3f}") print(f"Test gender accuracy: {gen_acc:.2f}")
def main(): args = get_args() if args.opts: cfg.merge_from_list(args.opts) cfg.freeze() start_epoch = 0 checkpoint_dir = Path(args.checkpoint) checkpoint_dir.mkdir(parents=True, exist_ok=True) # create model print("=> creating model '{}'".format(cfg.MODEL.ARCH)) model = get_model(model_name=cfg.MODEL.ARCH, homosedastic = cfg.MODEL.HOMOSCEDASTIC) if cfg.TRAIN.OPT == "sgd": optimizer = torch.optim.SGD(model.parameters(), lr=cfg.TRAIN.LR, momentum=cfg.TRAIN.MOMENTUM, weight_decay=cfg.TRAIN.WEIGHT_DECAY)
def main(): start_time = smtp.print_time("开始测试!!!") # py脚本额外参数 args = get_args() # main函数传入参数 img_path = args.img_path my_resume = args.my_resume if args.opts: cfg.merge_from_list(args.opts) cfg.freeze() # create model_dir print("=> creating model_dir '{}'".format(cfg.MODEL.ARCH)) model = my_model() device = "cuda" if torch.cuda.is_available() else "cpu" model = model.to(device) # load checkpoint resume_path = my_resume if Path(resume_path).is_file(): print("=> loading checkpoint '{}'".format(resume_path)) checkpoint = torch.load(resume_path, map_location="cpu") model.load_state_dict(checkpoint['state_dict']) print("=>ckpt loaded checkpoint '{}'".format(resume_path)) else: raise ValueError( "=> no checkpoTrueint found at '{}'".format(resume_path)) if device == "cuda": cudnn.benchmark = True print("=> start testing") # img_path, img_size, model, device predict_age = validate_age_estimation(img_path, cfg.MODEL.IMG_SIZE, model, device) print(f"predict_age: {predict_age:.2f}") end_time = smtp.print_time("测试结束!!!") print(smtp.date_gap_abs(start_time, end_time)) return int(round(predict_age))
def main(): parser = argparse.ArgumentParser(description="YAML parser") parser.add_argument( "--config-file", default="./setting.yaml", metavar="FILE", help="path to config file", ) # this makes sure you can use commond like # python main.py --config-file setting.yaml MODEL.ARCH PSP parser.add_argument( "opts", help="Modify config options using the command-line", default=None, nargs=argparse.REMAINDER, ) args = parser.parse_args() cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.freeze() print(cfg.MODEL.ARCH)
def main(): args = get_args() if args.opts: cfg.merge_from_list(args.opts) cfg.freeze() start_epoch = 0 checkpoint_dir = Path(args.checkpoint) checkpoint_dir.mkdir(parents=True, exist_ok=True) group = { 0: " 0-5", 1: " 6-10", 2: "11-20", 3: "21-30", 4: "31-40", 5: "41-60", 6: " 61-" } group_count = torch.zeros(7) get_ca = True # create model print("=> creating model '{}'".format(cfg.MODEL.ARCH)) model = get_model(model_name=cfg.MODEL.ARCH) if cfg.TRAIN.OPT == "sgd": optimizer = torch.optim.SGD(model.parameters(), lr=cfg.TRAIN.LR, momentum=cfg.TRAIN.MOMENTUM, weight_decay=cfg.TRAIN.WEIGHT_DECAY) else: optimizer = torch.optim.Adam(model.parameters(), lr=cfg.TRAIN.LR) device = "cuda" if torch.cuda.is_available() else "cpu" model = model.to(device) # optionally resume from a checkpoint resume_path = args.resume if resume_path: if Path(resume_path).is_file(): print("=> loading checkpoint '{}'".format(resume_path)) checkpoint = torch.load(resume_path, map_location="cpu") start_epoch = checkpoint['epoch'] - 1 model.load_state_dict(checkpoint['state_dict']) print("=> loaded checkpoint '{}' (epoch {})".format( resume_path, checkpoint['epoch'])) optimizer.load_state_dict(checkpoint['optimizer_state_dict']) else: print("=> no checkpoint found at '{}'".format(resume_path)) if args.multi_gpu: model = nn.DataParallel(model) if device == "cuda": cudnn.benchmark = True criterion = nn.CrossEntropyLoss().to(device) gender = False gender_count = "False" if args.dataset == "Morph" or args.dataset == "imdb_wiki": gender = True gender_count = torch.zeros(2) val_dataset = FaceVal(args.data_dir, "valid", args.dataset, img_size=cfg.MODEL.IMG_SIZE, augment=False, label=True, gender=gender, expand=args.expand) val_loader = DataLoader(val_dataset, batch_size=cfg.TEST.BATCH_SIZE, shuffle=False, num_workers=cfg.TRAIN.WORKERS, drop_last=False) print(len(val_dataset)) # validate if args.ldl: val_loss, val_acc, val_mae, maes, df = validate_ldl( val_loader, model, criterion, start_epoch, device, group_count, gender_count, get_ca) else: val_loss, val_acc, val_mae, maes, df = validate( val_loader, model, criterion, start_epoch, device, group_count, gender_count, get_ca) print("=> Validation finished") print(f"additional opts: {args.opts}") print(f"Val MAE: {val_mae:.4f}") group_mae = maes[0] print("Group MAE:") for ind, interval in enumerate(group.values()): print(interval + ":", (group_mae[ind] / group_count[ind]).item(), "/", group_count[ind].item()) ca = maes[1] if gender: gender_mae = maes[1] ca = maes[2] for ind, gen in enumerate([" Male", "Female"]): print(gen + ":", (gender_mae[ind] / gender_count[ind]).item(), "/", gender_count[ind].item()) if get_ca: print("CA3: {:.2f} CA5: {:.2f} CA7: {:.2f}".format( ca[3] * 100, ca[5] * 100, ca[7] * 100)) csv_path = resume_path.split("/")[-1] csv_path = csv_path[:-4] df.to_csv("csv/" + csv_path + ".csv", index=False)
def main(): args = get_args() if args.opts: cfg.merge_from_list(args.opts) cfg.freeze() if args.output_dir is not None: if args.img_dir is None: raise ValueError( "=> --img_dir argument is required if --output_dir is used") output_dir = Path(args.output_dir) output_dir.mkdir(parents=True, exist_ok=True) # create model print("=> creating model '{}'".format(cfg.MODEL.ARCH)) model = get_model(model_name=cfg.MODEL.ARCH, pretrained=None) device = "cuda" if torch.cuda.is_available() else "cpu" model = model.to(device) # load checkpoint resume_path = args.resume if resume_path is None: resume_path = Path(__file__).resolve().parent.joinpath( "misc", "megaage_fusion.pth") if not resume_path.is_file(): print( f"=> model path is not set; start downloading trained model to {resume_path}" ) url = "https://github.com/yjl450/age-estimation-ldl-pytorch/releases/download/v1.0/megaage_fusion.pth" urllib.request.urlretrieve(url, str(resume_path)) print("=> download finished") if Path(resume_path).is_file(): print("=> loading checkpoint '{}'".format(resume_path)) checkpoint = torch.load(resume_path, map_location="cpu") model.load_state_dict(checkpoint['state_dict']) print("=> loaded checkpoint '{}'".format(resume_path)) else: raise ValueError("=> no checkpoint found at '{}'".format(resume_path)) if device == "cuda": cudnn.benchmark = True model.eval() img_dir = args.img_dir # detector = dlib.get_frontal_face_detector() mtcnn = MTCNN(device=device, post_process=False, keep_all=False) img_size = cfg.MODEL.IMG_SIZE image_generator = yield_images_from_dir( img_dir) if img_dir else yield_images() rank = torch.Tensor([i for i in range(101)]).to(device) with torch.no_grad(): for img, name in image_generator: # start processing image start = perf_counter() input_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) image = Image.fromarray(input_img) # image.show() detected, _, landmarks = mtcnn.detect(image, landmarks=True) if img_dir and landmarks is not None: deg = angel(landmarks[0][0], landmarks[0][1]) image = image.rotate(deg, resample=Image.BICUBIC, expand=True) aligned, _ = mtcnn.detect(image, landmarks=False) else: aligned = detected if aligned is not None and len(detected) > 0: detected = detected.astype(int) if args.expand > 0: box = expand_bbox(image.size, detected[0], ratio=args.expand) else: box = detected[0] cv2.rectangle(img, (detected[0][0], detected[0][1]), (detected[0][2], detected[0][3]), (255, 255, 255), 2) cv2.rectangle(img, (box[0], box[1]), (box[2], box[3]), (255, 0, 0), 2) if img_dir: aligned = aligned.astype(int) if args.expand > 0: box = expand_bbox(image.size, aligned[0], ratio=args.expand) else: box = aligned[0] image = image.crop(box) # image.show() image.resize((img_size, img_size)) image = torchvision.transforms.ToTensor()(image) image = image.unsqueeze(0).to(device) # predict ages outputs = model(image) outputs = F.softmax(outputs, dim=1) if args.ldl: predicted_ages = torch.sum(outputs * rank, dim=1) else: _, predicted_ages = outputs.max(1) # draw results # for i, d in enumerate(detected): label = "{}".format(int(predicted_ages[0])) draw_label(img, (detected[0][0], detected[0][1]), label) # faces = np.array(faces.permute(1, 2, 0)).astype(np.uint8) # faces = cv2.cvtColor(faces, cv2.COLOR_RGB2BGR) if args.output_dir is not None: output_path = output_dir.joinpath(name) cv2.imwrite(str(output_path), img) else: elapsed = perf_counter() - start cv2.putText( img, "FPS: " + "{:.1f} Press ESC to exit".format(60 / elapsed), (10, 20), cv2.FONT_HERSHEY_DUPLEX, 0.5, (255, 255, 255), 1) cv2.imshow("result", img) key = cv2.waitKey(-1) if img_dir else cv2.waitKey(30) if key == 27: # ESC break
def main(): args = get_args() prototxtPath = os.path.sep.join(["face_detector", "deploy.prototxt"]) weightsPath = os.path.sep.join( ["face_detector", "res10_300x300_ssd_iter_140000.caffemodel"]) faceNet = cv2.dnn.readNet(prototxtPath, weightsPath) if args.opts: cfg.merge_from_list(args.opts) cfg.freeze() if args.output_dir is not None: if args.img_dir is None: raise ValueError( "=> --img_dir argument is required if --output_dir is used") output_dir = Path(args.output_dir) output_dir.mkdir(parents=True, exist_ok=True) # create model print("=> creating model '{}'".format(cfg.MODEL.ARCH)) model = get_model(model_name=cfg.MODEL.ARCH, pretrained=cfg.MODEL.PRETRAINED) device = args.device model = model.to(device) # load checkpoint resume_path = args.resume if resume_path is None: resume_path = Path(__file__).resolve().parent.joinpath("misc", MODEL) if not resume_path.is_file(): print( f"=> model path is not set; start downloading trained model to {resume_path}" ) url = f"https://github.com/anhlnt/age-estimation-pytorch/releases/download/v{VER}/{MODEL}" urllib.request.urlretrieve(url, str(resume_path)) print("=> download finished") if Path(resume_path).is_file(): print("=> loading checkpoint '{}'".format(resume_path)) checkpoint = torch.load(resume_path, map_location="cpu") model.load_state_dict(checkpoint['state_dict']) print("=> loaded checkpoint '{}'".format(resume_path)) else: raise ValueError("=> no checkpoint found at '{}'".format(resume_path)) if device == "cuda": cudnn.benchmark = True model.eval() margin = args.margin img_dir = args.img_dir img_size = cfg.MODEL.IMG_SIZE image_generator = yield_images_from_dir( img_dir) if img_dir else yield_images() start = time.time() with torch.no_grad(): for img, name in image_generator: input_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) img_h, img_w, _ = np.shape(input_img) # detect faces using ssd detected = detect_mask(img, faceNet) faces = np.empty((len(detected), img_size, img_size, 3)) if len(detected) > 0: for i, d in enumerate(detected): x1, y1, x2, y2, w, h = d.left(), d.top( ), d.right() + 1, d.bottom() + 1, d.width(), d.height() xw1 = max(int(x1 - margin * w), 0) yw1 = max(int(y1 - margin * h), 0) xw2 = min(int(x2 + margin * w), img_w - 1) yw2 = min(int(y2 + margin * h), img_h - 1) cv2.rectangle(img, (x1, y1), (x2, y2), (0, 0, 255), 2) cv2.imwrite("test/test.jpg", img) print("name: ", name) print("face: ", img[yw1:yw2 + 1, xw1:xw2 + 1]) print("x1, y1, x2, y2: ", x1, y1, x2, y2) print("xw1, yw1, xw2, yw2; ", xw1, yw1, xw2, yw2) print("img_w, img_h: ", img_w, img_h) print("len(detected): ", len(detected)) face = img[yw1:yw2 + 1, xw1:xw2 + 1] if len(face): faces[i] = cv2.resize(face, (img_size, img_size)) # predict ages inputs = torch.from_numpy( np.transpose(faces.astype(np.float32), (0, 3, 1, 2))).to(device) outputs = F.softmax(model(inputs), dim=-1).cpu().numpy() # print("outputs: ", outputs) ages = np.arange(0, 101) predicted_ages = (outputs * ages).sum(axis=-1) # draw results for i, d in enumerate(detected): try: label = "{}".format(int(predicted_ages[i])) except BaseException: label = "-" draw_label(img, (d.left(), d.top()), label) draw_label(img, (50, 50), "{:.2f}fps".format(1.0 / (time.time() - start))) if args.output_dir is not None: output_path = output_dir.joinpath(name) cv2.imwrite(str(output_path), img) else: cv2.imshow("result", img) key = cv2.waitKey(-1) if img_dir else cv2.waitKey(30) if key == 27: # ESC break start = time.time()
def main(): args = get_args() if args.opts: cfg.merge_from_list(args.opts) cfg.freeze() start_epoch = 0 checkpoint_dir = Path(args.checkpoint) checkpoint_dir.mkdir(parents=True, exist_ok=True) # display nb of workers print(f"number of train workers {cfg.TRAIN.WORKERS}") # fetch features with open('train_features.pkl', 'rb') as f: train_features = pickle.load(f) with open('train_labels.pkl', 'rb') as f: train_labels = pickle.load(f) with open('valid_features.pkl', 'rb') as f: valid_features = pickle.load(f) with open('valid_labels.pkl', 'rb') as f: valid_labels = pickle.load(f) n_features = train_features.shape[1] * train_features.shape[ 2] * train_features.shape[3] n_classes = 101 # create model if cfg.MODEL.ARCH_STYLE == 'classifier': print("=> creating classifier") model = get_classifier(n_features=n_features, n_classes=n_classes) else: print("=> creating regressor") model = get_regressor(n_features=n_features, n_classes=n_classes) # Create optimizer if cfg.TRAIN.OPT == "sgd": optimizer = torch.optim.SGD(model.parameters(), lr=cfg.TRAIN.LR, momentum=cfg.TRAIN.MOMENTUM, weight_decay=cfg.TRAIN.WEIGHT_DECAY) else: optimizer = torch.optim.Adam(model.parameters(), lr=cfg.TRAIN.LR) device = "cuda" if torch.cuda.is_available() else "cpu" model = model.to(device) # GPU config if args.multi_gpu: model = nn.DataParallel(model) if device == "cuda": cudnn.benchmark = True # criterion if cfg.MODEL.ARCH_STYLE == 'classifier': if cfg.MODEL.SMOOTHING == True: print("=> using label smoothing") criterion = LabelSmoothingLoss( std_smoothing=cfg.MODEL.STD_SMOOTHING, n_classes=n_classes).to(device) else: criterion = nn.CrossEntropyLoss().to(device) else: if cfg.MODEL.ALEATORIC: criterion = HeteroscedasticGaussianLoss().to(device) else: criterion = nn.L1Loss(reduction="sum").to(device) # loaders train_loader = get_feature_loader(train_features, train_labels, batch_size=cfg.TEST.BATCH_SIZE, shuffle=True, num_workers=cfg.TRAIN.WORKERS, drop_last=True) val_loader = get_feature_loader(valid_features, valid_labels, batch_size=cfg.TEST.BATCH_SIZE, shuffle=False, num_workers=cfg.TRAIN.WORKERS, drop_last=False) scheduler = StepLR(optimizer, step_size=cfg.TRAIN.LR_DECAY_STEP, gamma=cfg.TRAIN.LR_DECAY_RATE, last_epoch=start_epoch - 1) best_val_mae = 10000.0 train_writer = None if args.tensorboard is not None: opts_prefix = "_".join(args.opts) train_writer = SummaryWriter(log_dir=args.tensorboard + "/" + opts_prefix + "_train") val_writer = SummaryWriter(log_dir=args.tensorboard + "/" + opts_prefix + "_val") print('=> Start training') for epoch in range(start_epoch, cfg.TRAIN.EPOCHS): # train train_loss, train_acc = train(train_loader, model, criterion, optimizer, epoch, device) # validate val_loss, val_acc, val_mae = validate(val_loader, model, criterion, epoch, device) if args.tensorboard is not None: train_writer.add_scalar("loss", train_loss, epoch) train_writer.add_scalar("acc", train_acc, epoch) val_writer.add_scalar("loss", val_loss, epoch) val_writer.add_scalar("acc", val_acc, epoch) val_writer.add_scalar("mae", val_mae, epoch) # checkpoint if val_mae < best_val_mae: print( f"=> [epoch {epoch:03d}] best val mae was improved from {best_val_mae:.3f} to {val_mae:.3f}" ) model_state_dict = model.module.state_dict( ) if args.multi_gpu else model.state_dict() torch.save( { 'epoch': epoch + 1, 'arch': cfg.MODEL.ARCH, 'state_dict': model_state_dict, 'optimizer_state_dict': optimizer.state_dict() }, str( checkpoint_dir.joinpath( "epoch{:03d}_{:.5f}_{:.4f}.pth".format( epoch, val_loss, val_mae)))) best_val_mae = val_mae else: print( f"=> [epoch {epoch:03d}] best val mae was not improved from {best_val_mae:.3f} ({val_mae:.3f})" ) # adjust learning rate scheduler.step() print("=> training finished") print(f"additional opts: {args.opts}") print(f"best val mae: {best_val_mae:.3f}")
rand_movie = random.sample(range(movie_len), cfg.DEMO.PRODUCED_MOVIES) for i in rand_movie: # for i in range(0, movie_len): ML_dict = {col: MLs.iloc[i][col] for col in MLs.columns} d = {'age': f'{age}', 'gender': gender_out} d.update(ML_dict) data.append(d) data_df = pd.DataFrame(data) return data_df #################### GLOBAL #################### args = get_args() if args.opts: cfg.merge_from_list(args.opts) cfg.freeze() if args.output_dir is not None: if args.img_dir is None: raise ValueError( "=> --img_dir argument is required if --output_dir is used") output_dir = Path(args.output_dir) output_dir.mkdir(parents=True, exist_ok=True) # create model print("=> creating model '{}'".format(cfg.MODEL.ARCH)) model = get_model(model_name=cfg.MODEL.ARCH, pretrained=None) device = "cuda" if torch.cuda.is_available() else "cpu"
def main(): args = get_args() if args.opts: cfg.merge_from_list(args.opts) cfg.freeze() if args.output_dir is not None: if args.img_dir is None: raise ValueError( "=> --img_dir argument is required if --output_dir is used") output_dir = Path(args.output_dir) output_dir.mkdir(parents=True, exist_ok=True) # create model print("=> creating model '{}'".format(cfg.MODEL.ARCH)) model = get_model(model_name=cfg.MODEL.ARCH, pretrained=None) device = "cuda" if torch.cuda.is_available() else "cpu" model = model.to(device) # load checkpoint resume_path = args.resume if resume_path is None: resume_path = Path(__file__).resolve().parent.joinpath( "misc", "epoch044_0.02343_3.9984.pth") if not resume_path.is_file(): print( f"=> model path is not set; start downloading trained model to {resume_path}" ) url = "https://github.com/yu4u/age-estimation-pytorch/releases/download/v1.0/epoch044_0.02343_3.9984.pth" urllib.request.urlretrieve(url, str(resume_path)) print("=> download finished") if Path(resume_path).is_file(): print("=> loading checkpoint '{}'".format(resume_path)) checkpoint = torch.load(resume_path, map_location="cpu") model.load_state_dict(checkpoint['state_dict']) print("=> loaded checkpoint '{}'".format(resume_path)) else: raise ValueError("=> no checkpoint found at '{}'".format(resume_path)) if device == "cuda": cudnn.benchmark = True model.eval() margin = args.margin img_dir = args.img_dir cnn_face_detection_model = face_recognition_models.cnn_face_detector_model_location( ) detector = dlib.cnn_face_detection_model_v1(cnn_face_detection_model) img_size = cfg.MODEL.IMG_SIZE image_generator = yield_images_from_dir( img_dir) if img_dir else yield_images() with torch.no_grad(): for img, name in image_generator: input_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) img_h, img_w, _ = np.shape(input_img) # detect faces using dlib detector detected = [r.rect for r in detector(input_img, 1)] faces = np.empty((len(detected), img_size, img_size, 3)) if len(detected) > 0: for i, d in enumerate(detected): x1, y1, x2, y2, w, h = d.left(), d.top( ), d.right() + 1, d.bottom() + 1, d.width(), d.height() xw1 = max(int(x1 - margin * w), 0) yw1 = max(int(y1 - margin * h), 0) xw2 = min(int(x2 + margin * w), img_w - 1) yw2 = min(int(y2 + margin * h), img_h - 1) cv2.rectangle(img, (x1, y1), (x2, y2), (255, 255, 255), 2) cv2.rectangle(img, (xw1, yw1), (xw2, yw2), (255, 0, 0), 2) faces[i] = cv2.resize(img[yw1:yw2 + 1, xw1:xw2 + 1], (img_size, img_size)) # predict ages inputs = torch.from_numpy( np.transpose(faces.astype(np.float32), (0, 3, 1, 2))).to(device) outputs = F.softmax(model(inputs), dim=-1).cpu().numpy() ages = np.arange(0, 101) predicted_ages = (outputs * ages).sum(axis=-1) # draw results for i, d in enumerate(detected): label = "{}".format(int(predicted_ages[i])) draw_label(img, (d.left(), d.top()), label) if args.output_dir is not None: output_path = output_dir.joinpath(name) cv2.imwrite(str(output_path), img) else: cv2.imshow("result", img) key = cv2.waitKey(-1) if img_dir else cv2.waitKey(30) if key == 27: # ESC break
def main(mydict): print("开始训练时间:") start_time = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())) print(start_time) # py脚本额外参数 args = get_args() # main函数传入参数 my_data_dir = mydict["data_dir"] my_tensorboard = mydict["tensorboard"] my_checkpoint = mydict["checkpoint"] my_ifSE = mydict["ifSE"] my_l1loss = mydict["l1loss"] if my_l1loss: l1loss = 0.1 # 0.1 # l1loss = my_l1value else: l1loss = 0.0 if args.opts: cfg.merge_from_list(args.opts) cfg.freeze() start_epoch = 0 # checkpoint_dir = Path(args.checkpoint) checkpoint_dir = Path(my_checkpoint) checkpoint_dir.mkdir(parents=True, exist_ok=True) # create model_dir print("=> creating model_dir '{}'".format("se_resnext50_32x4d")) # model = get_model(model_name="se_resnext50_32x4d") model = my_model(my_ifSE) if cfg.TRAIN.OPT == "sgd": optimizer = torch.optim.SGD(model.parameters(), lr=cfg.TRAIN.LR, momentum=cfg.TRAIN.MOMENTUM, weight_decay=cfg.TRAIN.WEIGHT_DECAY) else: optimizer = torch.optim.Adam(model.parameters(), lr=cfg.TRAIN.LR) device = "cuda" if torch.cuda.is_available() else "cpu" model = model.to(device) # optionally resume from a checkpoint resume_path = args.resume if resume_path: print(Path(resume_path).is_file()) if Path(resume_path).is_file(): print("=> loading checkpoint '{}'".format(resume_path)) checkpoint = torch.load(resume_path, map_location="cpu") start_epoch = checkpoint['epoch'] model.load_state_dict(checkpoint['state_dict']) print("=> loaded checkpoint '{}' (epoch {})".format( resume_path, checkpoint['epoch'])) optimizer.load_state_dict(checkpoint['optimizer_state_dict']) else: print("=> no checkpoint found at '{}'".format(resume_path)) if args.multi_gpu: model = nn.DataParallel(model) if device == "cuda": cudnn.benchmark = True # 损失计算准则 criterion = nn.CrossEntropyLoss().to(device) train_dataset = FaceDataset_ceface(my_data_dir, "train", img_size=cfg.MODEL.IMG_SIZE, augment=True, age_stddev=cfg.TRAIN.AGE_STDDEV) train_loader = DataLoader(train_dataset, batch_size=cfg.BATCH_SIZE, shuffle=True, num_workers=cfg.TRAIN.WORKERS, drop_last=True) val_dataset = FaceDataset_ceface(my_data_dir, "valid", img_size=cfg.MODEL.IMG_SIZE, augment=False) val_loader = DataLoader(val_dataset, batch_size=cfg.BATCH_SIZE, shuffle=False, num_workers=cfg.TRAIN.WORKERS, drop_last=False) scheduler = StepLR(optimizer, step_size=cfg.TRAIN.LR_DECAY_STEP, gamma=cfg.TRAIN.LR_DECAY_RATE, last_epoch=start_epoch - 1) best_val_mae = 10000.0 train_writer = None val_mae_list = [] train_loss_list = [] val_loss_list = [] if my_tensorboard is not None: opts_prefix = "_".join(args.opts) train_writer = SummaryWriter(log_dir=my_tensorboard + "/" + opts_prefix + "_train") val_writer = SummaryWriter(log_dir=my_tensorboard + "/" + opts_prefix + "_val") for epoch in range(start_epoch, 80): # cfg.TRAIN.EPOCHS): # train train_loss, train_acc = train(train_loader, model, criterion, optimizer, epoch, device, l1loss) train_loss_list.append(train_loss) # validate val_loss, val_acc, val_mae = validate(val_loader, model, criterion, epoch, device, l1loss) val_mae_list.append(val_mae) val_loss_list.append(val_loss) if my_tensorboard is not None: train_writer.add_scalar("loss", train_loss, epoch) train_writer.add_scalar("acc", train_acc, epoch) val_writer.add_scalar("loss", val_loss, epoch) val_writer.add_scalar("acc", val_acc, epoch) val_writer.add_scalar("mae", val_mae, epoch) if val_mae < best_val_mae or val_mae > 0: print( f"=> [epoch {epoch:03d}] best val mae was improved from {best_val_mae:.3f} to {val_mae:.3f}" ) best_val_mae = val_mae # checkpoint if val_mae < 4.0: model_state_dict = model.module.state_dict( ) if args.multi_gpu else model.state_dict() torch.save( { 'epoch': epoch + 1, 'arch': cfg.MODEL.ARCH, 'state_dict': model_state_dict, 'optimizer_state_dict': optimizer.state_dict() }, str( checkpoint_dir.joinpath( "epoch{:03d}_{:.5f}_{:.4f}.pth".format( epoch, val_loss, val_mae)))) else: print( f"=> [epoch {epoch:03d}] best val mae was not improved from {best_val_mae:.3f} ({val_mae:.3f})" ) # adjust learning rate scheduler.step() print("=> training finished") print(f"additional opts: {args.opts}") print(f"best val mae: {best_val_mae:.3f}") print("结束训练时间:") end_time = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time())) print(end_time) print("训练耗时: " + smtp.date_gap(start_time, end_time)) # 发邮件 smtp.main( dict_={ "共训练epochs: ": cfg.TRAIN.EPOCHS, "训练耗时: ": smtp.date_gap(start_time, end_time), "最低val_mae: ": best_val_mae, "平均val_mae: ": np.array(val_mae_list).mean(), "vale_mae_list: ": val_mae_list, "train_loss_list: ": train_loss_list, "val_loss_list: ": val_loss_list, "MODEL.IMG_SIZE: ": cfg.MODEL.IMG_SIZE, "BATCH_SIZE: ": cfg.BATCH_SIZE, "LOSS.l1: ": l1loss, "TRAIN.LR: ": cfg.TRAIN.LR, "TRAIN.LR_DECAY_STEP: ": cfg.TRAIN.LR_DECAY_STEP, "TRAIN.LR_DECAY_RATE:": cfg.TRAIN.LR_DECAY_RATE, "TRAIN.OPT: ": cfg.TRAIN.OPT, "MODEL.ARCH:": cfg.MODEL.ARCH }) return best_val_mae
def main(): args = get_args() if args.opts: cfg.merge_from_list(args.opts) cfg.freeze() if args.output_dir is not None: if args.img_dir is None: raise ValueError( "=> --img_dir argument is required if --output_dir is used") output_dir = Path(args.output_dir) output_dir.mkdir(parents=True, exist_ok=True) # create model print("=> creating model '{}'".format(cfg.MODEL.ARCH)) model = get_model(model_name=cfg.MODEL.ARCH, pretrained=None) device = "cuda" if torch.cuda.is_available() else "cpu" model = model.to(device) # load checkpoint resume_path = args.resume # Load 作者model if resume_path is None: resume_path = Path(__file__).resolve().parent.joinpath( "misc", "epoch044_0.02343_3.9984.pth") if Path(resume_path).is_file(): print("=> loading checkpoint '{}'".format(resume_path)) checkpoint = torch.load(resume_path, map_location="cpu") model.load_state_dict(checkpoint['state_dict']) print("=> loaded checkpoint '{}'".format(resume_path)) else: raise ValueError("=> no checkpoint found at '{}'".format(resume_path)) if device == "cuda": cudnn.benchmark = True model.eval() margin = args.margin img_dir = args.img_dir detector = dlib.get_frontal_face_detector() img_size = cfg.MODEL.IMG_SIZE image_generator = yield_images_from_dir( img_dir) if img_dir else yield_images() starttime_without = time.time() ### delete with torch.no_grad(): for img, name in image_generator: input_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) img_h, img_w, _ = np.shape(input_img) # detect faces using dlib detector detected = detector(input_img, 1) faces = np.empty((len(detected), img_size, img_size, 3)) if len(detected) > 0: for i, d in enumerate(detected): x1, y1, x2, y2, w, h = d.left(), d.top( ), d.right() + 1, d.bottom() + 1, d.width(), d.height() xw1 = max(int(x1 - margin * w), 0) yw1 = max(int(y1 - margin * h), 0) xw2 = min(int(x2 + margin * w), img_w - 1) yw2 = min(int(y2 + margin * h), img_h - 1) cv2.rectangle(img, (x1, y1), (x2, y2), (255, 255, 255), 2) cv2.rectangle(img, (xw1, yw1), (xw2, yw2), (255, 0, 0), 2) faces[i] = cv2.resize(img[yw1:yw2 + 1, xw1:xw2 + 1], (img_size, img_size)) # predict ages inputs = torch.from_numpy( np.transpose(faces.astype(np.float32), (0, 3, 1, 2))).to(device) starttime = time.time() ### delete age_out, gender_out = model(inputs) ### delete endtime = time.time() print('Only age model. Executed Time:', (endtime - starttime), 'sec') age_prob = F.softmax(age_out, dim=-1).cpu().numpy() ages = np.arange(0, 101) predicted_ages = (age_prob * ages).sum(axis=-1) predicted_gender = gender_out.max(1)[1] print( f'predicted_ages:{predicted_ages}, predicted_gender:{predicted_gender}' ) for i, (d, ages, gender) in enumerate( zip(detected, predicted_ages, predicted_gender)): starttime = time.time() ### delete df = produce_data(ages, gender) # print(df) ### delete endtime = time.time() print('produce_data. Executed Time:', (endtime - starttime), 'sec') starttime = time.time() ### delete test_model_input, linear_feature_columns, dnn_feature_columns = data_preprocess( df) # FIXED!!!! 因為df維度與train不一樣,所以爆炸 (ex. df只有男 => 爆炸) pred_movie_list, pred_rating = recommend_movies( './recommend_system/save_model/xDeepFM_MSE1.0181.h5', test_model_input, linear_feature_columns, dnn_feature_columns, 'cuda:0', df) ### delete endtime = time.time() print('recommend model. Executed Time:', (endtime - starttime), 'sec') gender_out = 'M' if gender == 0 else 'F' print( f'age_out: {int(round(ages))}, gender_out: {gender_out}\n, pred_movie_list: {pred_movie_list}' ) label = f"{int(round(ages))}, {gender_out}, {pred_rating[0] :.2f}\n{pred_movie_list[0]}" # draw_label(img, (d.left(), d.top()), label) draw_label(img, (d.left(), d.bottom()), label) if args.output_dir is not None: output_path = output_dir.joinpath(name) cv2.imwrite(str(output_path), img) else: cv2.imshow("result", img) key = cv2.waitKey(-1) if img_dir else cv2.waitKey(30) if key == 27: # ESC break ### delete endtime_without = time.time() print('Without loading model. Executed Time:', (endtime_without - starttime_without), 'sec')
def main(): args = get_args() if args.opts: cfg.merge_from_list(args.opts) cfg.freeze() # create model print("=> creating model '{}'".format(cfg.MODEL.ARCH)) model = get_model(model_name=cfg.MODEL.ARCH, pretrained=None) device = "cuda" if torch.cuda.is_available() else "cpu" model = model.to(device) # load checkpoint resume_path = args.resume if Path(resume_path).is_file(): print("=> loading checkpoint '{}'".format(resume_path)) checkpoint = torch.load(resume_path, map_location="cpu") model.load_state_dict(checkpoint['state_dict']) print("=> loaded checkpoint '{}'".format(resume_path)) else: raise ValueError("=> no checkpoint found at '{}'".format(resume_path)) if device == "cuda": cudnn.benchmark = True #preds = [] #gt = [] test_list_1 = [] for i,j,k in os.walk('./gdrive/MyDrive/data/26953_Bébé'): test_list_1 = np.char.add(np.array([args.data_dir + '/26953_Bébé/']*len(k)), k) break for i,j,k in os.walk(args.data_dir +'/2112_Epicerie_salee'): test_list_2 = np.char.add(np.array([args.data_dir + '/2112_Epicerie_salee/']*len(k)), k) break #test_dataset1 = ProductDataset(args.data_dir, "all", img_size=cfg.MODEL.IMG_SIZE, augment=False,name_list=test_list_1) #test_loader1 = DataLoader(test_dataset1, batch_size=cfg.TEST.BATCH_SIZE, shuffle=False, # num_workers=cfg.TRAIN.WORKERS, drop_last=False) test_dataset2 = ProductDataset(args.data_dir, "all", img_size=cfg.MODEL.IMG_SIZE, augment=False,name_list=test_list_2) test_loader2 = DataLoader(test_dataset2, batch_size=cfg.TEST.BATCH_SIZE, shuffle=False, num_workers=cfg.TRAIN.WORKERS, drop_last=False) model.eval() #loss_monitor = AverageMeter() #accuracy_monitor = AverageMeter() true_label = [] predicted_label = [] with torch.no_grad(): with tqdm(test_loader2) as _tqdm: for i, (x, y) in enumerate(_tqdm): x = x.to(device) y = y.to(device) # compute output _,predicted = model(x).max(1) true_label += y.tolist() predicted_label += predicted.tolist() correct_num = predicted.eq(y).sum().item() sample_num = x.size(0) #loss_monitor.update(cur_loss, sample_num) #accuracy_monitor.update(correct_num, sample_num) pd.DataFrame(predicted_label).to_csv('./gdrive/MyDrive/data/pred2.csv') pd.DataFrame(true_label).to_csv('./gdrive/MyDrive/data/true2.csv')
def main(): args = get_args() if args.opts: cfg.merge_from_list(args.opts) cfg.freeze() start_epoch = 0 checkpoint_dir = Path(args.checkpoint) checkpoint_dir.mkdir(parents=True, exist_ok=True) # create model print("=> creating model '{}'".format(cfg.MODEL.ARCH)) model = get_model(model_name=cfg.MODEL.ARCH) if cfg.TRAIN.OPT == "sgd": optimizer = torch.optim.SGD(model.parameters(), lr=cfg.TRAIN.LR, momentum=cfg.TRAIN.MOMENTUM, weight_decay=cfg.TRAIN.WEIGHT_DECAY) else: optimizer = torch.optim.Adam(model.parameters(), lr=cfg.TRAIN.LR) device = "cuda" if torch.cuda.is_available() else "cpu" model = model.to(device) # optionally resume from a checkpoint resume_path = args.resume if resume_path: if Path(resume_path).is_file(): print("=> loading checkpoint '{}'".format(resume_path)) checkpoint = torch.load(resume_path, map_location="cpu") start_epoch = checkpoint['epoch'] model.load_state_dict(checkpoint['state_dict']) print("=> loaded checkpoint '{}' (epoch {})".format( resume_path, checkpoint['epoch'])) optimizer.load_state_dict(checkpoint['optimizer_state_dict']) else: print("=> no checkpoint found at '{}'".format(resume_path)) if args.multi_gpu: model = nn.DataParallel(model) if device == "cuda": cudnn.benchmark = True train_list = [] test_list = [] if args.class_name == 'all': for name in ["26953_Bébé", '2112_Epicerie_salee']: train_list_t = [] test_list_t = [] for i, j, k in os.walk(args.data_dir + '/' + name): train_list_t = np.array([args.data_dir + '/' + name + '/'] * int(len(k) * 0.9)) test_list_t = np.array([args.data_dir + '/' + name + '/'] * (len(k) - int(len(k) * 0.9))) t = np.random.choice(k, int(len(k) * 0.9), False) v = np.setdiff1d(k, t, True) train_list += list(np.char.add(train_list_t, t)) test_list += list(np.char.add(test_list_t, v)) break else: for i, j, k in os.walk(args.data_dir + '/' + args.class_name): train_list_t = np.array( [args.data_dir + '/' + args.class_name + '/'] * int(len(k) * 0.8)) test_list_t = np.array( [args.data_dir + '/' + args.class_name + '/'] * (len(k) - int(len(k) * 0.8))) t = np.random.choice(k, int(len(k) * 0.8), False) v = np.setdiff1d(k, t, True) train_list += list(np.char.add(train_list_t, t)) test_list += list(np.char.add(test_list_t, v)) break criterion = nn.CrossEntropyLoss().to(device) train_dataset = ProductDataset(args.data_dir, args.class_name, img_size=cfg.MODEL.IMG_SIZE, augment=True, name_list=train_list) train_loader = DataLoader(train_dataset, batch_size=cfg.TRAIN.BATCH_SIZE, shuffle=True, num_workers=cfg.TRAIN.WORKERS, drop_last=True) test_dataset = ProductDataset(args.data_dir, args.class_name, img_size=cfg.MODEL.IMG_SIZE, augment=False, name_list=test_list) test_loader = DataLoader(test_dataset, batch_size=cfg.TEST.BATCH_SIZE, shuffle=False, num_workers=cfg.TRAIN.WORKERS, drop_last=False) scheduler = StepLR(optimizer, step_size=cfg.TRAIN.LR_DECAY_STEP, gamma=cfg.TRAIN.LR_DECAY_RATE, last_epoch=start_epoch - 1) train_writer = None if args.tensorboard is not None: opts_prefix = "_".join(args.opts) train_writer = SummaryWriter(log_dir=args.tensorboard + "/" + opts_prefix + "_train") test_writer = SummaryWriter(log_dir=args.tensorboard + "/" + opts_prefix + "_test") best_test_acc = 0 for epoch in range(start_epoch, cfg.TRAIN.EPOCHS): # train train_loss, train_acc = train(train_loader, model, criterion, optimizer, epoch, device) #train_loss, train_acc = 0,0 # test test_loss, test_acc = validate(test_loader, model, criterion, epoch, device) #test_loss, test_acc = 0,0 if args.tensorboard is not None: train_writer.add_scalar("loss", train_loss, epoch) train_writer.add_scalar("acc", train_acc, epoch) test_writer.add_scalar("loss", test_loss, epoch) test_writer.add_scalar("acc", test_acc, epoch) # checkpoint if test_acc > best_test_acc: print( f"=> [epoch {epoch:03d}] best test acc was improved from {best_test_acc:.3f} to {test_acc:.3f}" ) model_state_dict = model.module.state_dict( ) if args.multi_gpu else model.state_dict() torch.save( { 'epoch': epoch + 1, 'arch': cfg.MODEL.ARCH, 'state_dict': model_state_dict, 'optimizer_state_dict': optimizer.state_dict() }, str( Path(args.data_dir).joinpath( "epoch{:03d}_{:.5f}_{:.4f}.pth".format( epoch, test_loss, test_acc)))) best_test_acc = test_acc else: print( f"=> [epoch {epoch:03d}] best test acc was not improved from {best_test_acc:.3f} ({test_acc:.3f})" ) # adjust learning rate scheduler.step() print("=> training finished") print(f"additional opts: {args.opts}") print(f"best test acc: {best_test_acc:.3f}")
def main(): args = get_args() if args.opts: cfg.merge_from_list(args.opts) cfg.freeze() start_epoch = 0 checkpoint_dir = Path(args.checkpoint) checkpoint_dir.mkdir(parents=True, exist_ok=True) # display nb of workers print(f"number of train workers {cfg.TRAIN.WORKERS}") # create model print("=> creating model '{}'".format(cfg.MODEL.ARCH)) model = get_model(model_name=cfg.MODEL.ARCH) if cfg.TRAIN.OPT == "sgd": optimizer = torch.optim.SGD(model.parameters(), lr=cfg.TRAIN.LR, momentum=cfg.TRAIN.MOMENTUM, weight_decay=cfg.TRAIN.WEIGHT_DECAY) else: optimizer = torch.optim.Adam(model.parameters(), lr=cfg.TRAIN.LR) device = "cuda" if torch.cuda.is_available() else "cpu" model = model.to(device) # optionally resume from a checkpoint resume_path = args.resume if resume_path: if Path(resume_path).is_file(): print("=> loading checkpoint '{}'".format(resume_path)) checkpoint = torch.load(resume_path, map_location="cpu") start_epoch = checkpoint['epoch'] model.load_state_dict(checkpoint['state_dict']) print("=> loaded checkpoint '{}' (epoch {})".format( resume_path, checkpoint['epoch'])) optimizer.load_state_dict(checkpoint['optimizer_state_dict']) else: print("=> no checkpoint found at '{}'".format(resume_path)) if args.multi_gpu: model = nn.DataParallel(model) if device == "cuda": cudnn.benchmark = True criterion = nn.CrossEntropyLoss().to(device) train_dataset = FaceDataset(args.data_dir, "train", img_size=cfg.MODEL.IMG_SIZE, augment=True, age_stddev=cfg.TRAIN.AGE_STDDEV) train_loader = DataLoader(train_dataset, batch_size=cfg.TRAIN.BATCH_SIZE, shuffle=True, num_workers=cfg.TRAIN.WORKERS, drop_last=True) val_dataset = FaceDataset(args.data_dir, "valid", img_size=cfg.MODEL.IMG_SIZE, augment=False) val_loader = DataLoader(val_dataset, batch_size=cfg.TEST.BATCH_SIZE, shuffle=False, num_workers=cfg.TRAIN.WORKERS, drop_last=False) scheduler = StepLR(optimizer, step_size=cfg.TRAIN.LR_DECAY_STEP, gamma=cfg.TRAIN.LR_DECAY_RATE, last_epoch=start_epoch - 1) best_val_mae = 10000.0 train_writer = None if args.tensorboard is not None: opts_prefix = "_".join(args.opts) train_writer = SummaryWriter(log_dir=args.tensorboard + "/" + opts_prefix + "_train") val_writer = SummaryWriter(log_dir=args.tensorboard + "/" + opts_prefix + "_val") for epoch in range(start_epoch, cfg.TRAIN.EPOCHS): # train train_loss, train_acc = train(train_loader, model, criterion, optimizer, epoch, device) # validate val_loss, val_acc, val_mae = validate(val_loader, model, criterion, epoch, device) if args.tensorboard is not None: train_writer.add_scalar("loss", train_loss, epoch) train_writer.add_scalar("acc", train_acc, epoch) val_writer.add_scalar("loss", val_loss, epoch) val_writer.add_scalar("acc", val_acc, epoch) val_writer.add_scalar("mae", val_mae, epoch) # checkpoint if val_mae < best_val_mae: print( f"=> [epoch {epoch:03d}] best val mae was improved from {best_val_mae:.3f} to {val_mae:.3f}" ) model_state_dict = model.module.state_dict( ) if args.multi_gpu else model.state_dict() torch.save( { 'epoch': epoch + 1, 'arch': cfg.MODEL.ARCH, 'state_dict': model_state_dict, 'optimizer_state_dict': optimizer.state_dict() }, str( checkpoint_dir.joinpath( "epoch{:03d}_{:.5f}_{:.4f}.pth".format( epoch, val_loss, val_mae)))) best_val_mae = val_mae else: print( f"=> [epoch {epoch:03d}] best val mae was not improved from {best_val_mae:.3f} ({val_mae:.3f})" ) # adjust learning rate scheduler.step() print("=> training finished") print(f"additional opts: {args.opts}") print(f"best val mae: {best_val_mae:.3f}")
def main(): args = get_args() if args.opts: cfg.merge_from_list(args.opts) cfg.freeze() start_epoch = 0 checkpoint_dir = Path(args.checkpoint) checkpoint_dir.mkdir(parents=True, exist_ok=True) # create model print("=> creating model '{}'".format(cfg.MODEL.ARCH)) model = get_model(model_name=cfg.MODEL.ARCH) multitask(model) if cfg.TRAIN.OPT == "sgd": optimizer = torch.optim.SGD(model.parameters(), lr=cfg.TRAIN.LR, momentum=cfg.TRAIN.MOMENTUM, weight_decay=cfg.TRAIN.WEIGHT_DECAY) else: optimizer = torch.optim.Adam(model.parameters(), lr=cfg.TRAIN.LR) device = "cuda" if torch.cuda.is_available() else "cpu" model = model.to(device) # optionally resume from a checkpoint resume_path = args.resume if resume_path: if Path(resume_path).is_file(): print("=> loading checkpoint '{}'".format(resume_path)) checkpoint = torch.load(resume_path, map_location="cpu") start_epoch = checkpoint['epoch'] model.load_state_dict(checkpoint['state_dict']) print("=> loaded checkpoint '{}' (epoch {})" .format(resume_path, checkpoint['epoch'])) optimizer.load_state_dict(checkpoint['optimizer_state_dict']) else: print("=> no checkpoint found at '{}'".format(resume_path)) if args.multi_gpu: model = nn.DataParallel(model) if device == "cuda": cudnn.benchmark = True get_ca = True if "megaage" in args.dataset.lower() else True # display cummulative acuracy value_ca = True if "megaage" in args.dataset.lower() else False # use CA to update saved model if get_ca: print("Cummulative Accuracy will be calculated for", args.dataset) if value_ca: print("Cummulative Accuracy will be compared to update saved model") criterion = nn.CrossEntropyLoss().to(device) train_dataset = FaceDataset(args.data_dir, "train", args.dataset, img_size=cfg.MODEL.IMG_SIZE, augment=args.aug, age_stddev=cfg.TRAIN.AGE_STDDEV, label=True, expand= args.expand, gender=True) train_loader = DataLoader(train_dataset, batch_size=cfg.TRAIN.BATCH_SIZE, shuffle=True, num_workers=cfg.TRAIN.WORKERS, drop_last=False) val_dataset = FaceDataset(args.data_dir, "valid", args.dataset, img_size=cfg.MODEL.IMG_SIZE, augment=False, label=True, expand= args.expand, gender=True) val_loader = DataLoader(val_dataset, batch_size=cfg.TEST.BATCH_SIZE, shuffle=False, num_workers=cfg.TRAIN.WORKERS, drop_last=False) scheduler = StepLR(optimizer, step_size=cfg.TRAIN.LR_DECAY_STEP, gamma=cfg.TRAIN.LR_DECAY_RATE, last_epoch=start_epoch - 1) best_val_mae = 10000.0 train_writer = None global_ca = {3: 0.0, 5: 0.0, 7: 0.0} train_count = len(train_dataset) val_count = len(val_dataset) all_train_loss = [] all_train_accu = [] all_val_loss = [] all_val_accu = [] # range(start_epoch, cfg.TRAIN.EPOCHS): for epoch in range(cfg.TRAIN.EPOCHS): # train train_loss, train_acc = train( train_loader, model, criterion, optimizer, epoch, device, train_count) # validate val_loss, val_acc, val_mae, new_ca= validate( val_loader, model, criterion, epoch, device, val_count, get_ca) all_train_loss.append(float(train_loss)) all_train_accu.append(float(train_acc)) all_val_loss.append(float(val_loss)) all_val_accu.append(float(val_mae)) # checkpoint if ((not value_ca) and (val_mae < best_val_mae)) or ((get_ca and value_ca) and (new_ca[3] > global_ca[3])): print( f"=> [epoch {epoch:03d}] best val mae was improved from {best_val_mae:.3f} to {val_mae:.3f}") model_state_dict = model.module.state_dict( ) if args.multi_gpu else model.state_dict() torch.save( { 'epoch': epoch + 1, 'arch': cfg.MODEL.ARCH, 'state_dict': model_state_dict, 'optimizer_state_dict': optimizer.state_dict() }, str(checkpoint_dir.joinpath("epoch{:03d}_{}_{:.5f}_{:.4f}_{}_{}_ldl.pth".format( epoch, args.dataset, val_loss, val_mae, datetime.now().strftime("%Y%m%d"), cfg.MODEL.ARCH))) ) best_val_mae = val_mae best_checkpoint = str(checkpoint_dir.joinpath("epoch{:03d}_{}_{:.5f}_{:.4f}_{}_{}_ldl.pth".format(epoch, args.dataset, val_loss, val_mae, datetime.now().strftime("%Y%m%d"), cfg.MODEL.ARCH))) if get_ca: global_ca = new_ca else: print( f"=> [epoch {epoch:03d}] best val mae was not improved from {best_val_mae:.3f} ({val_mae:.3f})") # adjust learning rate scheduler.step() print("=> training finished") print(f"additional opts: {args.opts}") print(f"best val mae: {best_val_mae:.3f}") if get_ca: print("CA3: {:.2f} CA5: {:.2f} CA7: {:.2f}".format(global_ca[3] * 100, global_ca[5]*100, global_ca[7]*100)) print("best mae saved model:", best_checkpoint) x = np.arange(cfg.TRAIN.EPOCHS) plt.xlabel("Epoch") plt.ylabel("Train Loss") plt.plot(x, all_train_loss) plt.savefig("savefig/{}_{}_{}_train_loss.png".format(args.dataset, cfg.MODEL.ARCH, datetime.now().strftime("%Y%m%d"))) plt.clf() plt.ylabel("Train Accuracy") plt.plot(x, all_train_accu) plt.savefig("savefig/{}_{}_{}_train_accu.png".format(args.dataset, cfg.MODEL.ARCH, datetime.now().strftime("%Y%m%d"))) plt.clf() plt.ylabel("Validation Loss") plt.plot(x, all_val_loss) plt.savefig("savefig/{}_{}_{}_val_loss.png".format(args.dataset, cfg.MODEL.ARCH, datetime.now().strftime("%Y%m%d"))) plt.clf() plt.ylabel("Validation Accuracy") plt.plot(x, all_val_accu) plt.savefig("savefig/{}_{}_{}_val_mae.png".format(args.dataset, cfg.MODEL.ARCH, datetime.now().strftime("%Y%m%d")))
def main_fd_flask(file_path, fileName): start = timeit.default_timer() args = get_args() if args.opts: cfg.merge_from_list(args.opts) cfg.freeze() # if args.output_dir is not None: # if args.img_dir is None: # raise ValueError("=> --img_dir argument is required if --output_dir is used") # output_dir = Path(args.output_dir) output_dir.mkdir(parents=True, exist_ok=True) # # create model # print("=> creating model '{}'".format(cfg.MODEL.ARCH)) # model = get_model(model_name=cfg.MODEL.ARCH, pretrained=None) # print("=check= torch.cuda.is_available, '{}'".format(torch.cuda.is_available())) # device = "cuda" if torch.cuda.is_available() else "cpu" # model = model.to(device) # load checkpoint resume_path = args.resume # if resume_path is None: # resume_path = Path(__file__).resolve().parent.joinpath("misc", "epoch044_0.02343_3.9984.pth") # # if not resume_path.is_file(): # print(f"=> model path is not set; start downloading trained model to {resume_path}") # url = "https://github.com/yu4u/age-estimation-pytorch/releases/download/v1.0/epoch044_0.02343_3.9984.pth" # urllib.request.urlretrieve(url, str(resume_path)) # print("=> download finished") # if Path(resume_path).is_file(): # print("=> loading checkpoint '{}'".format(resume_path)) # checkpoint = torch.load(resume_path, map_location="cpu") # model.load_state_dict(checkpoint['state_dict']) # print("=> loaded checkpoint '{}'".format(resume_path)) # else: # raise ValueError("=> no checkpoint found at '{}'".format(resume_path)) # print("=> device '{}'".format(device)) # if device == "cuda": # cudnn.benchmark = True # model.eval() margin = args.margin # img_dir = args.img_dir # detector = dlib.get_frontal_face_detector() img_size = cfg.MODEL.IMG_SIZE image_generator = yield_images_from_dir_flask(file_path, fileName) with torch.no_grad(): for img, name in image_generator: # print(name) input_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) img_h, img_w, _ = np.shape(input_img) # detect faces using dlib detector detected = detector(input_img, 1) # print((len(detected), img_size, img_size, 3)) faces = np.empty((len(detected), img_size, img_size, 3)) # print("faces= " , len(detected)) if len(detected) > 0: for i, d in enumerate(detected): x1, y1, x2, y2, w, h = d.left(), d.top(), d.right() + 1, d.bottom() + 1, d.width(), d.height() xw1 = max(int(x1 - margin * w), 0) yw1 = max(int(y1 - margin * h), 0) xw2 = min(int(x2 + margin * w), img_w - 1) yw2 = min(int(y2 + margin * h), img_h - 1) cv2.rectangle(img, (x1, y1), (x2, y2), (255, 255, 255), 2) cv2.rectangle(img, (xw1, yw1), (xw2, yw2), (255, 0, 0), 2) faces[i] = cv2.resize(img[yw1:yw2 + 1, xw1:xw2 + 1], (img_size, img_size)) # predict ages inputs = torch.from_numpy(np.transpose(faces.astype(np.float32), (0, 3, 1, 2))).to(device) outputs = F.softmax(model(inputs), dim=-1).cpu().numpy() ages = np.arange(0, 101) predicted_ages = (outputs * ages).sum(axis=-1) # draw results for i, d in enumerate(detected): age_label = "{}".format(int(predicted_ages[i])) # print(d, age_label) draw_label(img, (d.left(), d.top()), age_label) if args.output_dir is not None: # newfilename = datetime.today().strftime('%Y%m%d_%H%M%S') + "_" + f.filename # print(name) output_path = output_dir.joinpath(datetime.today().strftime('%Y%m%d_%H%M%S') + "_" + name) # print(str(output_path)) cv2.imwrite(str(output_path), img) # else: # cv2.imshow("result", img) # key = cv2.waitKey(-1) if img_dir else cv2.waitKey(30) # # if key == 27: # ESC # break stop = timeit.default_timer() print('exc Time: ', stop - start , " s, fileName= ", fileName)
def config_choise(args, flag=9): ''' 0: mobilenetv2 dilated-c1_deepsup 1: resnet18 dilated-ppm_deepsup 2: resnet50 dilated-ppm_deepsup 3: resnet101-upernet 4: resnet101 dilated-ppm_deepsup ''' cfg_list = [ # 0 'config/ade20k-mobilenetv2dilated-c1_deepsup.yaml', # 1 'config/ade20k-resnet18dilated-ppm_deepsup.yaml', # 2 'config/ade20k-resnet50dilated-ppm_deepsup.yaml', # 3 'config/ade20k-resnet101-upernet.yaml', # 4 'config/ade20k-resnet101dilated-ppm_deepsup.yaml', #5 remo psp 'config/remo_ade20k-resnet50dilated-ppm_deepsup.yaml', # 6 remo uper 'config/ade20k-resnet50-upernet.yaml', # 7 remo person stuff 'config/remo_ade20k-resnet50dilated-ppm_deepsup_person_stuff.yaml', # 8 18 'config/remo_ade20k-resnet18dilated-ppm_deepsup.yaml', # 9 '/home/zhangming/work/mask/scene/semantic-segmentation-pytorch/config/remo_ade20k-resnet50dilated-ppm_deepsup_kk.yaml', ] weight_list = [ # 0 '', # 1 'Module/baseline-resnet18dilated-ppm_deepsup/decoder_epoch_20.pth', # 2 'Module/baseline-resnet50dilated-ppm_deepsup/decoder_epoch_20.pth', # 3 'Module/baseline-resnet101-upernet/decoder_epoch_50.pth', # 4 # 'Module/baseline-resnet50-upernet/decoder_epoch_30.pth', 'Module/baseline-resnet101dilated-ppm_deepsup/decoder_epoch_25.pth', # 5 remo psp 'Module/resnet50_ade20k_20/decoder_epoch_20.pth', # 6 remo uper 'Module/resnet50-upernet_40/decoder_epoch_40.pth', # 7 remo person stuff 'Module/ade20k-resnet50dilated-ppm_deepsup_person_stuff/decoder_epoch_40.pth', # 8 'Module/baseline-resnet18dilated-ppm_deepsup/decoder_epoch_20.pth', # 9 'remo_ade20k-resnet50dilated-ppm_deepsup_kk/decoder_epoch_15.pth', ] args.gpu = 0 args.cfg = cfg_list[flag] args.imgs = '/home/xjx/data/videos/mask/save_img' cfg.merge_from_file(args.cfg) cfg.merge_from_list(args.opts) cfg.MODEL.arch_encoder = cfg.MODEL.arch_encoder.lower() cfg.MODEL.arch_decoder = cfg.MODEL.arch_decoder.lower() cfg.MODEL.weights_encoder = weight_list[flag].replace('decoder', 'encoder') cfg.MODEL.weights_decoder = weight_list[flag] abs_path = '/home/zhangming/work/mask/scene/semantic-segmentation-pytorch/ckpt' cfg.MODEL.weights_encoder = os.path.join(abs_path, cfg.MODEL.weights_encoder) cfg.MODEL.weights_decoder = os.path.join(abs_path, cfg.MODEL.weights_decoder) cfg.list_test = ['x'] # cfg.DATASET.imgSizes= (300, 375, 450, 525, 600) cfg.DATASET.imgSizes = [450] cfg.DATASET.imgMaxSize = 1000 cfg.DATASET.random_flip = False return args, cfg