def get_section_tutorial(OurFaceNet): st.write() ''' # Tutorial In this section we want to visualize how the face recognition is done. For this purpose we wil first select a few images of people (IDs) which will serve as the anchor images. Those images are taken from the 'Large-scale CelebFaces Attributes' dataset [(CelebA)](http://mmlab.ie.cuhk.edu.hk/projects/CelebA.html). After that, we then use a couple example images of the same people but in different settings. The list of variations includes the following: * Different backgrounds * Different lighting, bright, dark, color, etc. * Facing different angles * Wearing hats, accessories, etc. * Covering face with eyeglasses, sun-glasses, mustache, etc. * Different hair cuts, e.g. long hair, short hair, bangs, etc. * Same person in different age (young vs old) * Different facial expressions ''' st.write() st.write() load_tutorial_anchor_images() test_images = load_tutorial_test_images() st.write() st.write() """ In the inference phase, the test image is feed into the trained model. It calculates an embedding which is a numerical vector that represents the person (face). This embedding should include all relevant facial features in order to identify a person. The generated embedding is then used to compare it with all known people. This is done pairwise (test person <-> known person) with a distance function which calculates a similarity value. You are free to use any distance function that maps two vectors to one scalar value. In our case, we decide to train our model with the use of the euclidean distance (L2 Norm). """ st.write() st.write() st.image(Image.open(Path('documentation/images/InferenceProcess.jpeg')), caption=f"Inference Process", use_column_width=True ) st.write() st.write() ''' ''' if len(test_images) > 0: st.subheader("Inference") start_inference = st.button(label="Start Inference") if start_inference: col_1, col_2, col_3 = st.beta_columns(3) visited = [False, False] for img_path in test_images: img_tensor = transforms.ToTensor()(Image.open(img_path).resize([224, 224])) pred_id, msg = OurFaceNet.inference( img_tensor, use_threshold=False, fuzzy_matches=False ) msg = f"{msg.replace('!', ' -')} Person (ID): {pred_id}" temp_test_img_label = img_path.stem.split(" ")[0] if str(pred_id) == temp_test_img_label: t = "<div><span class='highlight green'><span class='bold'>Passed</span> </span></div>" else: t = "<div> <span class='highlight red'><span class='bold'>Failed</span></span></div>" if not visited[0]: col_1.markdown(t, unsafe_allow_html=True) col_1.image(Image.open(img_path), caption=f"{msg}", use_column_width=True) visited[0] = True elif not visited[1]: col_2.markdown(t, unsafe_allow_html=True) col_2.image(Image.open(img_path), caption=f"{msg}", use_column_width=True) visited[1] = True else: col_3.markdown(t, unsafe_allow_html=True) col_3.image(Image.open(img_path), caption=f"{msg}", use_column_width=True) visited = [False, False]
def run(opt): torch.manual_seed(opt.seed) torch.backends.cudnn.benchmark = not opt.not_cuda_benchmark and not opt.test print('Setting up data...') Dataset = get_dataset(opt.dataset, opt.task) # if opt.task==mot -> JointDataset f = open(opt.data_cfg) # 选择哪一个数据集进行训练测试 '../src/lib/cfg/mot15.json', data_config = json.load(f) trainset_paths = data_config['train'] # 训练集路径 dataset_root = data_config['root'] # 数据集所在目录 print("Dataset root: %s" % dataset_root) f.close() # Image data transformations transforms = T.Compose([T.ToTensor()]) # Dataset dataset = Dataset(opt=opt, root=dataset_root, paths=trainset_paths, img_size=(1088, 608), augment=True, transforms=transforms) opt = opts().update_dataset_info_and_set_heads(opt, dataset) print("opt:\n", opt) logger = Logger(opt) # os.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID' # os.environ['CUDA_VISIBLE_DEVICES'] = opt.gpus_str # 多GPU训练 # print("opt.gpus_str: ", opt.gpus_str) # opt.device = torch.device('cuda:0' if opt.gpus[0] >= 0 else 'cpu') # 设置GPU opt.device = device opt.gpus = my_visible_devs print('Creating model...') model = create_model(opt.arch, opt.heads, opt.head_conv) # 初始化优化器 optimizer = torch.optim.Adam(model.parameters(), opt.lr) start_epoch = 0 if opt.load_model != '': model, optimizer, start_epoch = load_model(model, opt.load_model, optimizer, opt.resume, opt.lr, opt.lr_step) # Get dataloader if opt.is_debug: train_loader = torch.utils.data.DataLoader( dataset=dataset, batch_size=opt.batch_size, shuffle=True, pin_memory=True, drop_last=True) # debug时不设置线程数(即默认为0) else: train_loader = torch.utils.data.DataLoader(dataset=dataset, batch_size=opt.batch_size, shuffle=True, num_workers=opt.num_workers, pin_memory=True, drop_last=True) print('Starting training...') Trainer = train_factory[opt.task] trainer = Trainer(opt=opt, model=model, optimizer=optimizer) # trainer.set_device(opt.gpus, opt.chunk_sizes, opt.device) trainer.set_device(opt.gpus, opt.chunk_sizes, device) best = 1e10 for epoch in range(start_epoch + 1, opt.num_epochs + 1): mark = epoch if opt.save_all else 'last' # Train an epoch log_dict_train, _ = trainer.train(epoch, train_loader) logger.write('epoch: {} |'.format(epoch)) for k, v in log_dict_train.items(): logger.scalar_summary('train_{}'.format(k), v, epoch) logger.write('{} {:8f} | '.format(k, v)) if opt.val_intervals > 0 and epoch % opt.val_intervals == 0: save_model(os.path.join(opt.save_dir, 'model_{}.pth'.format(mark)), epoch, model, optimizer) else: # mcmot_last_track or mcmot_last_det if opt.id_weight > 0: # do tracking(detection and re-id) save_model( os.path.join(opt.save_dir, 'mcmot_last_track_' + opt.arch + '.pth'), epoch, model, optimizer) else: # only do detection # save_model(os.path.join(opt.save_dir, 'mcmot_last_det_' + opt.arch + '.pth'), # epoch, model, optimizer) save_model( os.path.join(opt.save_dir, 'mcmot_last_det_' + opt.arch + '.pth'), epoch, model, optimizer) logger.write('\n') if epoch in opt.lr_step: save_model( os.path.join(opt.save_dir, 'model_{}.pth'.format(epoch)), epoch, model, optimizer) lr = opt.lr * (0.1**(opt.lr_step.index(epoch) + 1)) print('Drop LR to', lr) for param_group in optimizer.param_groups: param_group['lr'] = lr if epoch % 10 == 0: save_model( os.path.join(opt.save_dir, 'model_{}.pth'.format(epoch)), epoch, model, optimizer) logger.close()
def train( cfg, data_cfg, weights_from="", weights_to="", save_every=10, img_size=(1088, 608), resume=False, epochs=100, batch_size=16, accumulated_batches=1, freeze_backbone=False, opt=None, ): # The function starts timme = strftime("%Y-%d-%m %H:%M:%S", gmtime()) timme = timme[5:-3].replace('-', '_') timme = timme.replace(' ', '_') timme = timme.replace(':', '_') weights_to = osp.join(weights_to, 'run' + timme) mkdir_if_missing(weights_to) if resume: latest_resume = osp.join(weights_from, 'latest.pt') torch.backends.cudnn.benchmark = True # unsuitable for multiscale # Configure run f = open(data_cfg) data_config = json.load(f) trainset_paths = data_config['train'] dataset_root = data_config['root'] f.close() transforms = T.Compose([T.ToTensor()]) # Get dataloader dataset = JointDataset(dataset_root, trainset_paths, img_size, augment=True, transforms=transforms) dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True, num_workers=8, pin_memory=True, drop_last=True, collate_fn=collate_fn) # Initialize model model = Darknet(cfg, dataset.nID) cutoff = -1 # backbone reaches to cutoff layer start_epoch = 0 if resume: checkpoint = torch.load(latest_resume, map_location='cpu') # Load weights to resume from model.load_state_dict(checkpoint['model']) model.cuda().train() # Set optimizer optimizer = torch.optim.SGD(filter(lambda x: x.requires_grad, model.parameters()), lr=opt.lr, momentum=.9) start_epoch = checkpoint['epoch'] + 1 if checkpoint['optimizer'] is not None: optimizer.load_state_dict(checkpoint['optimizer']) del checkpoint # current, saved else: # Initialize model with backbone (optional) if cfg.endswith('yolov3.cfg'): load_darknet_weights(model, osp.join(weights_from, 'darknet53.conv.74')) cutoff = 75 elif cfg.endswith('yolov3-tiny.cfg'): load_darknet_weights(model, osp.join(weights_from, 'yolov3-tiny.conv.15')) cutoff = 15 model.cuda().train() # Set optimizer optimizer = torch.optim.SGD(filter(lambda x: x.requires_grad, model.parameters()), lr=opt.lr, momentum=.9, weight_decay=1e-4) model = torch.nn.DataParallel(model) # Set scheduler scheduler = torch.optim.lr_scheduler.MultiStepLR( optimizer, milestones=[int(0.5 * opt.epochs), int(0.75 * opt.epochs)], gamma=0.1) # An important trick for detection: freeze bn during fine-tuning if not opt.unfreeze_bn: for i, (name, p) in enumerate(model.named_parameters()): p.requires_grad = False if 'batch_norm' in name else True # model_info(model) t0 = time.time() for epoch in range(epochs): epoch += start_epoch logger.info( ('%8s%12s' + '%10s' * 6) % ('Epoch', 'Batch', 'box', 'conf', 'id', 'total', 'nTargets', 'time')) # Freeze darknet53.conv.74 for first epoch if freeze_backbone and (epoch < 2): for i, (name, p) in enumerate(model.named_parameters()): if int(name.split('.')[2]) < cutoff: # if layer < 75 p.requires_grad = False if (epoch == 0) else True ui = -1 rloss = defaultdict(float) # running loss optimizer.zero_grad() for i, (imgs, targets, _, _, targets_len) in enumerate(dataloader): if sum([len(x) for x in targets]) < 1: # if no targets continue continue # SGD burn-in burnin = min(1000, len(dataloader)) if (epoch == 0) & (i <= burnin): lr = opt.lr * (i / burnin)**4 for g in optimizer.param_groups: g['lr'] = lr # Compute loss, compute gradient, update parameters loss, components = model(imgs.cuda(), targets.cuda(), targets_len.cuda()) components = torch.mean(components.view(-1, 5), dim=0) loss = torch.mean(loss) loss.backward() # accumulate gradient for x batches before optimizing if ((i + 1) % accumulated_batches == 0) or (i == len(dataloader) - 1): optimizer.step() optimizer.zero_grad() # Running epoch-means of tracked metrics ui += 1 for ii, key in enumerate(model.module.loss_names): rloss[key] = (rloss[key] * ui + components[ii]) / (ui + 1) # rloss indicates running loss values with mean updated at every epoch s = ('%8s%12s' + '%10.3g' * 6) % ( '%g/%g' % (epoch, epochs - 1), '%g/%g' % (i, len(dataloader) - 1), rloss['box'], rloss['conf'], rloss['id'], rloss['loss'], rloss['nT'], time.time() - t0) t0 = time.time() if i % opt.print_interval == 0: logger.info(s) # Save latest checkpoint checkpoint = { 'epoch': epoch, 'model': model.module.state_dict(), 'optimizer': optimizer.state_dict() } #copyfile(cfg, weights_to + '/cfg/yolo3.cfg') #copyfile(data_cfg, weights_to + '/cfg/ccmcpe.json') latest = osp.join(weights_to, 'latest.pt') torch.save(checkpoint, latest) if epoch % save_every == 0 and epoch != 0: # making the checkpoint lite checkpoint["optimizer"] = [] torch.save( checkpoint, osp.join(weights_to, "weights_epoch_" + str(epoch) + ".pt")) # Calculate mAP if epoch % opt.test_interval == 0: with torch.no_grad(): mAP, R, P = test.test(cfg, data_cfg, weights=latest, batch_size=batch_size) test.test_emb(cfg, data_cfg, weights=latest, batch_size=batch_size) # Call scheduler.step() after opimizer.step() with pytorch > 1.1.0 scheduler.step()
def train_one_epoch( model, arch, optimizer, lr_scheduler, data_loader, device, epoch, print_freq, ngpus_per_node, model_without_ddp, args ): model.train() metric_logger = utils.MetricLogger(delimiter=" ") metric_logger.add_meter("lr", utils.SmoothedValue(window_size=1, fmt="{value:.6f}")) # header = "Epoch: [{}]".format(epoch) for images, targets in metric_logger.log_every( iterable=data_loader, print_freq=print_freq, # header=header, iter_num=args.iter_num ): images = list(image.to(device) for image in images) targets = [{k: v.to(device) for k, v in t.items()} for t in targets] """ [{"boxes": tensor([], device="cuda:0"), "labels": tensor([], device="cuda:0", dtype=torch.int64), "masks": tensor([], device="cuda:0", dtype=torch.uint8), "iscrowd": tensor([], device="cuda:0", dtype=torch.int64)}] """ try: loss_dict = model(images, targets) losses = sum(loss for loss in loss_dict.values()) # reduce losses over all GPUs for logging purposes loss_dict_reduced = utils.reduce_dict(loss_dict) losses_reduced = sum(loss for loss in loss_dict_reduced.values()) loss_value = losses_reduced.item() if not math.isfinite(loss_value): logger.fatal("Loss is {}, stopping training".format(loss_value)) logger.fatal(loss_dict_reduced) sys.exit(1) optimizer.zero_grad() losses.backward() optimizer.step() lr_scheduler.step() metric_logger.update(loss=losses_reduced, **loss_dict_reduced) metric_logger.update(lr=optimizer.param_groups[0]["lr"]) except Exception as e: logger.warning(e, exc_info=True) # logger.info("print target for debug") # print(targets) args.iter_num += 1 # save checkpoint here if not args.multiprocessing_distributed or (args.multiprocessing_distributed and args.rank % ngpus_per_node == 0): if args.iter_num % 1000 == 0: utils.save_on_master({ "model": model_without_ddp.state_dict(), "optimizer": optimizer.state_dict(), "lr_scheduler": lr_scheduler.state_dict(), "epoch": epoch, "iter_num": args.iter_num, "args": args, }, "{}/{}_{}.pth".format(checkpoint_dir, arch.__name__, args.iter_num) ) os.makedirs("{}/debug_image/".format(checkpoint_dir), exist_ok=True) if args.iter_num < 5000: continue model.eval() # from barez import overlay_ann debug_image = None debug_image_list = [] cnt = 0 for image_path in glob.glob("./table_test/*"): cnt += 1 image_name = os.path.basename(image_path) # print(image_name) image = cv2.imread(image_path) rat = 1300 / image.shape[0] image = cv2.resize(image, None, fx=rat, fy=rat) transform = transforms.Compose([transforms.ToTensor()]) image = transform(image) # put the model in evaluation mode with torch.no_grad(): tensor = [image.to(device)] prediction = model(tensor) image = torch.squeeze(image, 0).permute(1, 2, 0).mul(255).numpy().astype(np.uint8) for pred in prediction: for idx, mask in enumerate(pred['masks']): if pred['scores'][idx].item() < 0.5: continue m = mask[0].mul(255).byte().cpu().numpy() box = list(map(int, pred["boxes"][idx].tolist())) score = pred["scores"][idx].item() # image = overlay_ann(image, m, box, "", score) # if debug_image is None: # debug_image = image # else: # debug_image = np.concatenate((debug_image, image), axis=1) # if cnt == 10: # cnt = 0 # debug_image_list.append(debug_image) # debug_image = None avg_length = np.mean([i.shape[1] for i in debug_image_list]) di = None for debug_image in debug_image_list: rat = avg_length / debug_image.shape[1] debug_image = cv2.resize(debug_image, None, fx=rat, fy=rat) if di is None: di = debug_image else: di = np.concatenate((di, debug_image), axis=0) di = cv2.resize(di, None, fx=0.4, fy=0.4) cv2.imwrite("{}/debug_image/{}.jpg".format(checkpoint_dir, args.iter_num), di) model.train() # hard stop if args.iter_num == 50000: logger.info("ITER NUM == 50k, training successfully!") raise SystemExit
def simple_augment(): simple_augment_ = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)), ]) return simple_augment_
def test_emb( opt, batch_size=16, img_size=(1088, 608), print_interval=40, ): """ :param opt: :param batch_size: :param img_size: :param print_interval: :return: """ data_cfg = opt.data_cfg f = open(data_cfg) data_cfg_dict = json.load(f) f.close() nC = 1 test_paths = data_cfg_dict['test_emb'] dataset_root = data_cfg_dict['root'] if opt.gpus[0] >= 0: opt.device = torch.device('cuda') else: opt.device = torch.device('cpu') print('Creating model...') model = create_model(opt.arch, opt.heads, opt.head_conv) model = load_model(model, opt.load_model) # model = torch.nn.DataParallel(model) model = model.to(opt.device) model.eval() # Get data loader transforms = T.Compose([T.ToTensor()]) dataset = JointDataset(opt, dataset_root, test_paths, img_size, augment=False, transforms=transforms) data_loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=False, num_workers=8, drop_last=False) embedding, id_labels = [], [] print('Extracting features...') for batch_i, batch in enumerate(data_loader): t = time.time() output = model(batch['input'].cuda())[-1] id_head = _tranpose_and_gather_feat(output['id'], batch['ind'].cuda()) id_head = id_head[batch['reg_mask'].cuda() > 0].contiguous() emb_scale = math.sqrt(2) * math.log(opt.nID - 1) id_head = emb_scale * F.normalize(id_head) id_target = batch['ids'].cuda()[batch['reg_mask'].cuda() > 0] for i in range(0, id_head.shape[0]): if len(id_head.shape) == 0: continue else: feat, label = id_head[i], id_target[i].long() if label != -1: embedding.append(feat) id_labels.append(label) if batch_i % print_interval == 0: print( 'Extracting {}/{}, # of instances {}, time {:.2f} sec.'.format( batch_i, len(data_loader), len(id_labels), time.time() - t)) print('Computing pairwise similarity...') if len(embedding) < 1: return None embedding = torch.stack(embedding, dim=0).cuda() id_labels = torch.LongTensor(id_labels) n = len(id_labels) print(n, len(embedding)) assert len(embedding) == n embedding = F.normalize(embedding, dim=1) p_dist = torch.mm(embedding, embedding.t()).cpu().numpy() gt = id_labels.expand(n, n).eq(id_labels.expand(n, n).t()).numpy() up_triangle = np.where(np.triu(p_dist) - np.eye(n) * p_dist != 0) p_dist = p_dist[up_triangle] gt = gt[up_triangle] far_levels = [1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1] far, tar, threshold = metrics.roc_curve(gt, p_dist) interp = interpolate.interp1d(far, tar) tar_at_far = [interp(x) for x in far_levels] for f, fa in enumerate(far_levels): print('TPR@FAR={:.7f}: {:.4f}'.format(fa, tar_at_far[f])) return tar_at_far
def main(opt): torch.manual_seed(opt.seed) torch.backends.cudnn.benchmark = not opt.not_cuda_benchmark and not opt.test print('Setting up data...') Dataset = get_dataset(opt.dataset, opt.task) f = open(opt.data_cfg) data_config = json.load(f) trainset_paths = data_config['train'] dataset_root = data_config['root'] f.close() transforms = T.Compose([T.ToTensor()]) dataset = Dataset(opt, dataset_root, trainset_paths, (1088, 608), augment=True, transforms=transforms) opt = opts().update_dataset_info_and_set_heads(opt, dataset) print(opt) logger = Logger(opt) os.environ['CUDA_VISIBLE_DEVICES'] = opt.gpus_str opt.device = torch.device('cuda' if opt.gpus[0] >= 0 else 'cpu') print('Creating model...') model = create_model(opt.arch, opt.heads, opt.head_conv) optimizer = torch.optim.Adam(model.parameters(), opt.lr) start_epoch = 0 if opt.load_model != '': model, optimizer, start_epoch = load_model( model, opt.load_model, optimizer, opt.resume, opt.lr, opt.lr_step) # Get dataloader train_loader = torch.utils.data.DataLoader( dataset, batch_size=opt.batch_size, shuffle=True, num_workers=opt.num_workers, pin_memory=True, drop_last=True ) print('Starting training...') Trainer = train_factory[opt.task] trainer = Trainer(opt, model, optimizer) trainer.set_device(opt.gpus, opt.chunk_sizes, opt.device) best = 1e10 for epoch in range(start_epoch + 1, opt.num_epochs + 1): mark = epoch if opt.save_all else 'last' log_dict_train, _ = trainer.train(epoch, train_loader) logger.write('epoch: {} |'.format(epoch)) for k, v in log_dict_train.items(): logger.scalar_summary('train_{}'.format(k), v, epoch) logger.write('{} {:8f} | '.format(k, v)) if opt.val_intervals > 0 and epoch % opt.val_intervals == 0: save_model(os.path.join(opt.save_dir, 'model_{}.pth'.format(mark)), epoch, model, optimizer) else: save_model(os.path.join(opt.save_dir, 'model_last.pth'), epoch, model, optimizer) logger.write('\n') if epoch in opt.lr_step: save_model(os.path.join(opt.save_dir, 'model_{}.pth'.format(epoch)), epoch, model, optimizer) lr = opt.lr * (0.1 ** (opt.lr_step.index(epoch) + 1)) print('Drop LR to', lr) for param_group in optimizer.param_groups: param_group['lr'] = lr if epoch % 5 == 0: save_model(os.path.join(opt.save_dir, 'model_{}.pth'.format(epoch)), epoch, model, optimizer) logger.close()
import torch from dataset import Dataset from torch.utils.data import DataLoader import numpy as np import os, sys from osgeo import gdal_array import gdal import argparse from torchvision.transforms import transforms as T sys.path.append(r'/home/zhoudengji/ghx/data/code/mycnn') from model import MyCNN x_transform = T.Compose([ T.ToTensor(), # 标准化至[-1,1],规定均值和标准差 # T.Normalize([0.5, 0.5, 0.5, 0.5], [0.5, 0.5, 0.5, 0.5]) # torchvision.transforms.Normalize(mean, std, inplace=False) ]) # mask只需要转换为tensor y_transform = T.ToTensor() def nomlize(array): return np.divide(array, np.max(array)) # 测试 def test(): model = MyCNN(4, 512, 512) # model = models.UNet(2) model.load_state_dict(torch.load(args.weight, map_location='cpu')) model.eval()
def train(): start_time = time.time() learning_rate = 0.001 Epoch_num = 50 Batch_size = 1024 Resolution = 36 save_path = 'save/' # https://tutorials.pytorch.kr/intermediate/tensorboard_tutorial.html # The direction for tensorboard writer = SummaryWriter(save_path) writer.add_scalar('epoch', Epoch_num) writer.add_scalar('batch size', Batch_size) writer.add_scalar('learning_rate', learning_rate) writer.add_scalar('resolution', Resolution) tr_transform = transforms.Compose([ transforms.Resize((Resolution, Resolution)), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)) ]) te_transform = transforms.Compose([ transforms.Resize((Resolution, Resolution)), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)) ]) # https://gldmg.tistory.com/43 # This reference is to store and get .npy file # https://wikidocs.net/14304 # Check if the file is located. train_path = 'data/pre_train' train_file = 'data/train.npy' test_path = 'data/pre_test' test_file = 'data/test.npy' if os.path.isfile(train_file): load = np.load(train_file, allow_pickle=True) tr_x, tr_y = load[0], load[1] else: tr_x, tr_y = make_tensor(train_path) np.save(train_file, np.array([tr_x, tr_y])) if os.path.isfile(test_file): load = np.load(test_file, allow_pickle=True) te_x, te_y = load[0], load[1] else: te_x, te_y = make_tensor(test_path) np.save(test_file, np.array([te_x, te_y])) processing_time = time.time() time_check('processing', start_time, processing_time) tr_data = CustomDataset(tr_x, tr_y, tr_transform) tr_loader = DataLoader(tr_data, batch_size=Batch_size, shuffle=True) te_data = CustomDataset(te_x, te_y, te_transform) te_loader = DataLoader(te_data, batch_size=Batch_size, shuffle=False) loader_time = time.time() time_check('loading', processing_time, loader_time) # model model = models.resnet18() model.fc = nn.Linear(512, 4) model = model.cuda() # Summary Model summary(model, input_size=(3, Resolution, Resolution)) criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) # Start training model.train() for epoch in range(Epoch_num): train_loss = 0 correct = 0 total = 0 for inputs, targets in tr_loader: inputs = inputs.cuda() targets = targets.cuda() outputs = model(inputs) # Ground True vs Prediction value # print(outputs) # print(targets) loss = criterion(outputs, targets) optimizer.zero_grad() loss.backward() optimizer.step() train_loss += loss.item() _, predicted = outputs.max(1) total += targets.size(0) correct += predicted.eq(targets).sum().item() loss = train_loss / len(tr_loader) acc = 100 * correct / total if epoch % 5 == 0: print('Train - Epoch : %d, Loss : %.2f, Accuracy : %.2f' % (epoch, loss, acc)) writer.add_scalar('Training loss', loss, epoch) writer.add_scalar('Accuracy', acc, epoch) train_time = time.time() time_check('train', loader_time, train_time) # https://tutorials.pytorch.kr/beginner/saving_loading_models.html torch.save(model, save_path + '/model.pt') # Evaluation model.eval() test_loss = 0 correct = 0 total = 0 with torch.no_grad(): for batch_idx, (inputs, targets) in enumerate(te_loader): inputs = inputs.cuda() targets = targets.cuda() outputs = model(inputs) loss = criterion(outputs, targets) test_loss += loss.item() _, predicted = outputs.max(1) total += targets.size(0) correct += predicted.eq(targets).sum().item() loss = test_loss / len(te_loader) acc = 100 * correct / total print('Evaluation - Loss : %.2f, Accuracy : %.2f' % (loss, acc)) test_time = time.time() time_check('test', train_time, test_time) writer.close()
def pixelshuffle_upsample(lr, scale, upsample_model): lr = transforms.ToTensor()(lr).unsqueeze(0) lr = lr.cuda() lr = upsample_model(lr) return lr.squeeze(0)
def bicubic_upsample(lr, scale): lr = lr.resize([lr.size[0] * scale, lr.size[1] * scale], resample=Image.BICUBIC) return transforms.ToTensor()(lr)
def __init__(self): """Initialize ResMaskNet @misc{luanresmaskingnet2020, Author = {Luan Pham & Tuan Anh Tran}, Title = {Facial Expression Recognition using Residual Masking Network}, url = {https://github.com/phamquiluan/ResidualMaskingNetwork}, Year = {2020} } """ self.transform = transforms.Compose( [transforms.ToPILImage(), transforms.ToTensor()]) self.FER_2013_EMO_DICT = { 0: "angry", 1: "disgust", 2: "fear", 3: "happy", 4: "sad", 5: "surprise", 6: "neutral", } # load configs and set random seed configs = json.load( open( os.path.join(get_resource_path(), "ResMaskNet_fer2013_config.json"))) self.image_size = (configs["image_size"], configs["image_size"]) self.use_gpu = torch.cuda.is_available() # if self.use_gpu: # self.state = torch.load( # os.path.join( # get_resource_path(), "ResMaskNet_Z_resmasking_dropout1_rot30.pth" # ) # ) # else: # self.state = torch.load( # os.path.join( # get_resource_path(), "ResMaskNet_Z_resmasking_dropout1_rot30.pth" # ), # map_location={"cuda:0": "cpu"}, # ) self.model = resmasking_dropout1(in_channels=3, num_classes=7) if self.use_gpu: self.model.load_state_dict( torch.load( os.path.join( get_resource_path(), "ResMaskNet_Z_resmasking_dropout1_rot30.pth"))['net']) self.model.cuda() else: self.model.load_state_dict( torch.load( os.path.join(get_resource_path(), "ResMaskNet_Z_resmasking_dropout1_rot30.pth"), map_location={"cuda:0": "cpu"}, )['net']) self.model.eval()
def main(): # img_folders = ["../coco_img/bg2_0/", "../coco_img/bg2_127/", "../coco_img/bg2_255/", # "../coco_img/obj2_0/", "../coco_img/obj2_127/", "../coco_img/obj2_255/"] img_folders = [ "../coco_img/merged_bg2_0/", "../coco_img/merged_bg2_127/", "../coco_img/merged_bg2_255/", "../coco_img/merged_obj2_0/", "../coco_img/merged_obj2_127/", "../coco_img/merged_obj2_255/" ] img_folders = ["../coco_img/org/"] model_name = "MLCCOCO" model = MultilabelObject(None, 80).cuda() log_dir = "./" checkpoint = torch.load(os.path.join(log_dir, 'model_best.pth.tar'), encoding='bytes') new_checkpoint = OrderedDict() for k in checkpoint[b'state_dict']: new_checkpoint[k.decode('utf-8')] = checkpoint[b'state_dict'][k] model.load_state_dict(new_checkpoint) model.eval() with open("classes_list.pickle", "rb") as f: classes_list = pickle.load(f) for img_folder in img_folders: crop_size = 224 image_size = 256 batch_size = 64 normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) val_transform = transforms.Compose([ transforms.Scale(image_size), transforms.CenterCrop(crop_size), transforms.ToTensor(), normalize ]) cocomlc = COCO_MLC(img_folder, val_transform) test_loader = torch.utils.data.DataLoader(cocomlc, batch_size=batch_size, shuffle=False, num_workers=8, pin_memory=True) t = tqdm(test_loader, desc='testing {}'.format(img_folder)) result = {} for batch_idx, (imgs, paths) in enumerate(t): images = imgs.cuda() # print(images.shape) probs, labels, labels_probs = infer_batch(model, classes_list, inputs=images, threshold=0.5) for i in range(0, len(paths)): path = paths[i] result[path] = { "prob": probs[i], "labels": labels[i], "labels_probs": labels_probs[i] } pickle_file_name = "{}_{}.pickle".format( model_name, os.path.basename(os.path.normpath(img_folder))) pickle_path = os.path.join(".", "result_pickle", pickle_file_name) with open(pickle_path, 'wb') as handle: pickle.dump(result, handle) print("Done, Saved to {}".format(pickle_path))
def get_section_one_shot_learning(OurFaceNet): # Sidebar st.sidebar.header("One-Shot Learning") st.sidebar.write("You can add a new person (ID) to the model.\ Afterwards, you can test the verification with some test images.") st.sidebar.subheader("Add Person (ID)") person_name = st.sidebar.text_input("Enter name of person (ID):", max_chars=40) anchor_file = st.sidebar.file_uploader("Select anchor image:", type=['jpg', 'png', 'jpeg']) # Main page ''' # One-Shot Learning ''' st.subheader(f"Step 1: Add new Person!") ''' Check the sidebar, in order to add a new person (ID) to the database. After you entered a name and uploaded the image, it will be added and preprocessed automatically into the database. ''' if person_name is not None and anchor_file is not None: # add anchor to known IDs OurFaceNet.create_anchor_embeddings(anchor_dict={person_name: anchor_file}) st.subheader("Done. New Person Added!") anchor_image = Image.open(anchor_file) st.image(anchor_image, caption=f"Person (ID): {person_name}", use_column_width=True) st.subheader("Step 2: Select Test Images") st.write("Now, after getting setup you can select some random images to test out the verification system. \ Select a directory with all (face) images you want to verify." ) test_images_path = st.text_input("Relative Path to test directory: ") if test_images_path == "": st.warning("Path to directory is missing! Please add path to test images.") return test_image_dir = Path(test_images_path) if test_image_dir.is_dir(): test_images = load_tutorial_test_images(test_image_dir) else: st.warning("Path to directory is missing! Please add path to test images.") # Step 3: Inference if len(test_images) > 0: st.subheader("Step 3: Inference") st.write(f"Now we will verify the given test images w.r.t. given Person (ID): {person_name}.") st.write("") start_inference = st.button(label="Start Inference") if start_inference: col_1, col_2, col_3 = st.beta_columns(3) visited = [False, False] for img_path in test_images: test_image = Image.open(img_path).resize([224, 224]) img_tensor = transforms.ToTensor()(test_image) # Prediction pred_id, msg = OurFaceNet.inference( img_tensor, use_threshold=False, fuzzy_matches=False ) temp_test_img_label = ' '.join([img_path.stem.split(" ")[0], img_path.stem.split(" ")[1]]) if str(pred_id) == temp_test_img_label: t = "<div><span class='highlight green'><span class='bold'>Passed</span> </span></div>" msg = f"{msg} Person (ID): {pred_id}" else: t = "<div> <span class='highlight red'><span class='bold'>Failed</span></span></div>" msg = "Unknown person. No identity match found!" if not visited[0]: col_1.markdown(t, unsafe_allow_html=True) col_1.image(test_image, caption=f"{msg}", use_column_width=True) visited[0] = True elif not visited[1]: col_2.markdown(t, unsafe_allow_html=True) col_2.image(test_image, caption=f"{msg}", use_column_width=True) visited[1] = True else: col_3.markdown(t, unsafe_allow_html=True) col_3.image(test_image, caption=f"{msg}", use_column_width=True) visited = [False, False]
def test(): transform_test = transforms.Compose([ transforms.ToTensor(), # transforms.Normalize(0.41,2) ]) # testset1 = datasets.ImageFolder(args.test_root1, transform=transform_test) # # testset2 = datasets.ImageFolder(args.test_root2, transform=transform_test) # # test_loader1 = DataLoader(dataset=testset1, # batch_size=1, # shuffle=False) # # test_loader2 = DataLoader(dataset=testset2, # batch_size=1, # shuffle=False) # transform = transforms.Compose([transforms.ToTensor(), # # transforms.Lambda(lambda x: global_contrast_normalization(x, scale='l1')), # transforms.Normalize([0.5], [0.5])]) encoder, decoder = Encoder(args), Decoder(args) # model_dict = torch.load(args.model) # encoder_dict = model_dict['encoder'] # decoder_dict = model_dict['decoder'] # encoder.load_state_dict(encoder_dict) # decoder.load_state_dict(decoder_dict) encooder, decoder = load_model(encoder, decoder, args.model) encoder.to('cuda') decoder.to('cuda') encoder.eval() decoder.eval() # all_data=torch.zeros((3,128,128)) thr = 0.09000 #0.0908 import numpy as np Tensor = torch.cuda.FloatTensor from PIL import Image cnt = 0 # thr=0.06 for part1 for img in tqdm(img_list1): points = {} img_path = os.path.join(args.test_root1, img) image = Image.open(img_path) image = transform_test(image) image = image.unsqueeze(0) if image.shape[1] != 3: image = image.repeat(1, 3, 1, 1) image = image.type(Tensor) data_rebuild1 = encoder.forward(image) data_rebuild1 = decoder.forward(data_rebuild1) # criterion=nn.MSELoss() # recon_loss = criterion(data_rebuild1,image) # recon_loss=recon_loss.detach().to('cpu').numpy() residual = torch.abs(data_rebuild1.squeeze()[0, :, :] - image.squeeze()[0, :, :]) point_set = residual.ge(thr) # point_set=point_set.detach().to('cpu').numpy() point = point_set.nonzero().cpu().numpy() points['points'] = ['{},{}'.format(p[0], p[1]) for p in point] if (point.shape[0] > 5): save_json(img, points, args.json_part1) # print(points) # all_data+=residual.detach().cpu().squeeze() if args.show: data_rebuild1 = data_rebuild1.detach().to('cpu').squeeze().permute( 1, 2, 0).numpy() data = image.to('cpu') data = data.squeeze().detach().permute(1, 2, 0) data = data.numpy() points = point_set.to('cpu') im_show = data.copy() im_show[points, :] = 1 ########### muti_img = np.hstack([data, data_rebuild1, im_show]) #cv2.imshow('flaw_locate',im_show) #cv2.imshow('ori',data) #cv2.imshow('rebuild1', data_rebuild1) cv2.imshow("muti_img", muti_img) #cv2.waitKey(0) # cv2.destoryAllWindows() cnt = cnt + 1 # cv2.imwrite('/home/zww/cv/defect/auto-encoder-net/image/%s.jpg'%str(cnt),data_rebuild1*255) cv2.waitKey(0)
def do_marking_run(class_marking_percentage, experiment_directory, tensorboard_log_directory, augment=True): # Setup experiment directory if os.path.isdir(experiment_directory): error_message = f"Directory {experiment_directory} already exists. By default we assume you don't want to "\ "repeat the marking stage." logger.info(error_message) return logfile_path = os.path.join(experiment_directory, 'marking.log') setup_logger_tqdm(filepath=logfile_path) # Load randomly sampled images from random class along with list of original indexes training_set = torchvision.datasets.CIFAR10(root="experiments/datasets", download=True) class_id, images, original_indexes = get_images_for_marking_cifar10( training_set, class_marking_percentage=class_marking_percentage, tensorboard_log_directory=tensorboard_log_directory) # Marking network is the resnet18 we trained on CIFAR10 marking_network = torchvision.models.resnet18(pretrained=False, num_classes=10) checkpoint_path = "experiments/table1/step1/checkpoint.pth" marking_network_checkpoint = torch.load(checkpoint_path) marking_network.load_state_dict( marking_network_checkpoint["model_state_dict"]) # Carriers marking_network_fc_feature_size = 512 carriers = torch.randn(len(training_set.classes), marking_network_fc_feature_size) carriers /= torch.norm(carriers, dim=1, keepdim=True) torch.save(carriers, os.path.join(experiment_directory, "carriers.pth")) # Run! optimizer = lambda x: torch.optim.AdamW(x, lr=0.1) epochs = 100 batch_size = 32 output_directory = os.path.join(experiment_directory, "marked_images") if not augment: augmentation = None marked_images = do_marking(output_directory, marking_network, images, original_indexes, carriers, class_id, NORMALIZE_CIFAR10, optimizer, tensorboard_log_directory, epochs=epochs, batch_size=batch_size, overwrite=True, augmentation=augmentation) # Show marked images in Tensorboard tensorboard_summary_writer = SummaryWriter( log_dir=tensorboard_log_directory) images_for_tensorboard = [transforms.ToTensor()(x) for x in marked_images] img_grid = torchvision.utils.make_grid(images_for_tensorboard, nrow=16) tensorboard_summary_writer.add_image('marked_images', img_grid) # Record marking completion with open(os.path.join(experiment_directory, "marking.complete"), "w") as fh: fh.write("1")
def main(): parser = argparse.ArgumentParser(description='Chainer example: MNIST') parser.add_argument('--batchsize', '-b', type=int, default=100, help='Number of images in each mini-batch') parser.add_argument('--epoch', '-e', type=int, default=20, help='Number of sweeps over the dataset to train') parser.add_argument('--frequency', '-f', type=int, default=-1, help='Frequency of taking a snapshot') parser.add_argument('--device', '-d', type=str, default='-1', help='Device specifier. Either ChainerX device ' 'specifier or an integer. If non-negative integer, ' 'CuPy arrays with specified device id are used. If ' 'negative integer, NumPy arrays are used') parser.add_argument('--out', '-o', default='result', help='Directory to output the result') parser.add_argument('--resume', '-r', type=str, help='Resume the training from snapshot') parser.add_argument('--autoload', action='store_true', help='Automatically load trainer snapshots in case' ' of preemption or other temporary system failure') parser.add_argument('--unit', '-u', type=int, default=1000, help='Number of units') group = parser.add_argument_group('deprecated arguments') group.add_argument('--gpu', '-g', dest='device', type=int, nargs='?', const=0, help='GPU ID (negative value indicates CPU)') args = parser.parse_args() device = torch.device(args.device) print('Device: {}'.format(device)) print('# Minibatch-size: {}'.format(args.batchsize)) print('# epoch: {}'.format(args.epoch)) print('') # Set up a neural network to train # Classifier reports softmax cross entropy loss and accuracy at every # iteration, which will be used by the PrintReport extension below. model = Classifier(MLP(784, args.unit, 10)) model.to(device) # Setup an optimizer optimizer = torch.optim.Adam(model.parameters()) # Load the MNIST dataset transform = transforms.ToTensor() train = datasets.MNIST('data', train=True, download=True, transform=transform) test = datasets.MNIST('data', train=False, transform=transform) train_iter = pytorch_trainer.iterators.SerialIterator( train, args.batchsize) test_iter = pytorch_trainer.iterators.SerialIterator(test, args.batchsize, repeat=False, shuffle=False) # Set up a trainer updater = training.updaters.StandardUpdater(train_iter, optimizer, model, device=device) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) # Evaluate the model with the test dataset for each epoch trainer.extend(extensions.Evaluator(test_iter, model, device=device), call_before_training=True) # Dump a computational graph from 'loss' variable at the first iteration # The "main" refers to the target link of the "main" optimizer. # trainer.extend(extensions.DumpGraph('main/loss')) # Take a snapshot for each specified epoch frequency = args.epoch if args.frequency == -1 else max(1, args.frequency) # Take a snapshot each ``frequency`` epoch, delete old stale # snapshots and automatically load from snapshot files if any # files are already resident at result directory. trainer.extend(extensions.snapshot(n_retains=1, autoload=args.autoload), trigger=(frequency, 'epoch')) # Write a log of evaluation statistics for each epoch trainer.extend(extensions.LogReport(), call_before_training=True) # Save two plot images to the result dir trainer.extend(extensions.PlotReport(['main/loss', 'validation/main/loss'], 'epoch', file_name='loss.png'), call_before_training=True) trainer.extend(extensions.PlotReport( ['main/accuracy', 'validation/main/accuracy'], 'epoch', file_name='accuracy.png'), call_before_training=True) # Print selected entries of the log to stdout # Here "main" refers to the target link of the "main" optimizer again, and # "validation" refers to the default name of the Evaluator extension. # Entries other than 'epoch' are reported by the Classifier link, called by # either the updater or the evaluator. trainer.extend(extensions.PrintReport([ 'epoch', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy', 'elapsed_time' ]), call_before_training=True) # Print a progress bar to stdout trainer.extend(extensions.ProgressBar()) if args.resume is not None: # Resume from a snapshot (Note: this loaded model is to be # overwritten by --autoload option, autoloading snapshots, if # any snapshots exist in output directory) trainer.load_state_dict(torch.load(args.resume)) # Run the training trainer.run()
from torchvision.transforms import transforms from torch.utils.data import DataLoader import torchvision.datasets as datasets # //TODO: Custom Transforms transform = transforms.Compose([ transforms.Resize((30, 30)), transforms.ToTensor(), # //* 0-255 to 0-1, numpy to tensors transforms.Normalize( [0.5, 0.5, 0.5], # //* 0-1 to [-1,1] , formula (x-mean)/std [0.5, 0.5, 0.5]) ]) # //! custom Dataloader function def load_data(train_path, test_path): train_loader = DataLoader(datasets.ImageFolder(train_path, transform=transform), batch_size=64, shuffle=True) test_loader = DataLoader(datasets.ImageFolder(test_path, transform=transform), batch_size=32, shuffle=True) # //TODO: load all classes(43) classes = datasets.ImageFolder(train_path, transform=transform).classes return train_loader, test_loader, classes
class NetShell: default_scale = 224 default_transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) class _Path: def __init__(self): self.root = '../..' self.dataset_root = 'cookie/data' self.dataset_dir = 'CIFAR10' self.save_root = 'cookie/save' self.save_dir = None def dataset_path(self): dataset_path = f'{self.root}/{self.dataset_root}' if self.dataset_dir: dataset_path = dataset_path + '/' + self.dataset_dir if not os.path.exists(dataset_path): os.makedirs(dataset_path) return dataset_path def save_path(self): save_path = f'{self.root}/{self.save_root}' if self.save_dir: save_path = save_path + '/' + self.save_dir if not os.path.exists(save_path): os.makedirs(save_path) return save_path class _Train: def __init__(self): self.transform = NetShell.default_transform self.shuffle = True self.max_epoch = 200 self.save_checkpoint = -1 self.save_epoch = -1 self.early_stop_max = 5 class _Test: def __init__(self): self.transform = NetShell.default_transform self.shuffle = True class _Save: def __init__(self): self.optimizer = True self.state = True class _Options: def __init__(self): self.train = NetShell._Train() self.test = NetShell._Test() self.save = NetShell._Save() def __init__(self, net, Dataset=None, criterion=torch.nn.CrossEntropyLoss()): self.net = net self.cuda = True self.options = NetShell._Options() self.path = NetShell._Path() self.criterion = criterion self.Dataset = Dataset if Dataset else torchvision.datasets.CIFAR10 self.optimizer = optim.SGD(self.net.parameters(), lr=0.001, momentum=0.9) self.state = { 'epoch': 0, 'iter': 0, 'special_mark': None, } @staticmethod def sav_loader(path=None, auto_load_path=None, Dataset=None, load_optimizer=False): if auto_load_path: files = os.listdir(auto_load_path) files.sort() path = f'{auto_load_path}/{files[-1]}' with open(path, 'rb') as f: sav = torch.load(f) net = sav['net'] ns = NetShell(net, Dataset=Dataset) state = sav.get('state') if state: ns.state = state optimizer = sav.get('optimizer') if load_optimizer and optimizer: ns.optimizer.load_state_dict(optimizer) return ns def train(self, batch_size=8, num_workers=2, checkpoint=2000, sampling_test=True, early_stop=False): if self.Dataset: dataset = self.Dataset(root=self.path.dataset_path(), transform=self.options.train.transform, train=True) else: dataset = torchvision.datasets.CIFAR10( root=self.path.dataset_path(), transform=self.options.train.transform, download=True) trainloader = torch.utils.data.DataLoader( dataset, batch_size=batch_size, shuffle=self.options.train.shuffle, num_workers=num_workers) base_epoch = self.state['epoch'] cuda = self.cuda net = self.net optimizer = self.optimizer criterion = self.criterion checkpoint_timer = 0 checkpoint_save = self.options.train.save_checkpoint epoch_save = self.options.train.save_epoch if cuda: net.cuda() es_history = 0 es_flag = 0 for epoch in range(base_epoch, self.options.train.max_epoch): then = datetime.now() running_loss = 0 total_itr = 0 for itr, data in enumerate(trainloader, 0): xs, truth = data if cuda: xs, truth = Variable(xs.cuda()), Variable(truth.cuda()) else: xs, truth = Variable(xs), Variable(truth) optimizer.zero_grad() ys = net(xs) loss = criterion(ys, truth) loss.backward() optimizer.step() running_loss += loss.data.item() if itr != 0 and itr % checkpoint == 0: now = datetime.now() average_loss = running_loss / checkpoint print( f'[{epoch + 1}, {itr:5d}] loss:{average_loss:.10f} | {(now - then).seconds}s' ) running_loss = 0.0 then = now checkpoint_timer += 1 if checkpoint_save > 0 and checkpoint_timer % checkpoint_save == 0: self.state['iter'] = itr self.save() total_itr = itr self.state['iter'] = total_itr self.state['epoch'] = epoch + 1 if epoch_save > 0 and (epoch + 1) % epoch_save == 0: self.save() if sampling_test: accuracy = self.test(batch_size=batch_size, num_workers=num_workers) if early_stop: if accuracy <= es_history: es_flag += 1 if es_flag >= self.options.train.early_stop_max: return else: es_flag = 0 es_history = accuracy def test(self, batch_size=8, num_workers=2): if self.Dataset: dataset = self.Dataset(root=self.path.dataset_path(), transform=self.options.test.transform, train=False) else: dataset = torchvision.datasets.CIFAR10( root=self.path.dataset_root, train=False, transform=self.options.test.transform, download=True) testloader = torch.utils.data.DataLoader( dataset, batch_size=batch_size, shuffle=self.options.test.shuffle, num_workers=num_workers) net = self.net cuda = self.cuda if cuda: net.cuda() correct = 0 total = 0 for data in testloader: xs, truth = data if cuda: xs, truth = Variable(xs.cuda()), Variable(truth.cuda()) else: xs, truth = Variable(xs), Variable(truth) ys = net(xs) _, predicted = torch.max(ys.data, 1) total += truth.size(0) correct += (predicted == truth).sum() acc = 100.0 * correct.float() / total print(f'Accuracy of the network on the test dataset_root: {acc:.2f} %') return acc def save(self): pkg = {'net': self.net} suffix = 'n' if self.options.save.optimizer: pkg['optimizer'] = self.optimizer.state_dict() suffix += 'o' if self.options.save.state: pkg['state'] = self.state suffix += 's' suffix += '.sav' nhash = self.net_hash() fp = f"{self.path.save_path()}/{nhash}.{suffix}" torch.save(pkg, fp) print(f'saved as {fp}') def net_hash(self): special_mark = self.state.get('special_mark') if special_mark: special_mark = f'x{special_mark}' else: special_mark = '' return f"{self.net._get_name()}{special_mark}_ep{self.state['epoch']}_{self.state['iter']}"
def train( cfg, data_cfg, resume=False, epochs=100, batch_size=16, accumulated_batches=1, freeze_backbone=False, opt=None, ): weights = '../weights' # 改到上一层, 这样方便文件夹复制 mkdir_if_missing(weights) latest = osp.join(weights, 'latest.pt') # 这个是为了resume上次存好的checkpoint,注意不要覆盖! torch.backends.cudnn.benchmark = True # unsuitable for multiscale # Configure run print("loading data") sys.stdout.flush() f = open(data_cfg) data_config = json.load(f) trainset_paths = data_config['train'] dataset_root = data_config['root'] f.close() cfg_dict = parse_model_cfg(cfg) img_size = [int(cfg_dict[0]['width']), int(cfg_dict[0]['height'])] # Get dataloader transforms = T.Compose([T.ToTensor()]) dataset = JointDataset(dataset_root, trainset_paths, img_size, augment=True, transforms=transforms) dataloader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True, num_workers=8, pin_memory=False, drop_last=True, collate_fn=collate_fn) # Initialize model print("building model") sys.stdout.flush() model = Darknet(cfg_dict, dataset.nID) cutoff = -1 # backbone reaches to cutoff layer start_epoch = 0 if resume: if opt.latest: latest_resume = "/home/master/kuanzi/weights/72_epoch_arcface.pt" print("Loading the latest weight...", latest_resume) checkpoint = torch.load(latest_resume, map_location='cpu') # Load weights to resume from model.load_state_dict(checkpoint['model']) model.cuda().train() # Set optimizer classifer_param_value = list(map(id, model.classifier.parameters())) classifer_param = model.classifier.parameters() base_params = filter(lambda p: id(p) not in classifer_param_value, model.parameters()) print("classifer_param\n", classifer_param) # [2218660649072] print("classifer_param_value\n", classifer_param_value) # [2218660649072] print("base_params\n", base_params) # <filter object at 0x0000020493D95048> sys.stdout.flush() # optimizer = torch.optim.SGD(filter(lambda x: x.requires_grad, model.parameters()), lr=opt.lr * 0.1, momentum=.9) optimizer = torch.optim.SGD([ {'params': filter(lambda x: x.requires_grad, base_params), 'lr': opt.lr * 0.01}, {'params': classifer_param, 'lr': opt.lr}], momentum=.9) # optimizer = torch.optim.SGD(filter(lambda x: x.requires_grad, model.parameters()), lr=opt.lr, momentum=.9) start_epoch = checkpoint['epoch'] + 1 if checkpoint['optimizer'] is not None: # Anyway, if you’re “freezing” any part of your network, and your optimizer is only passed “unfrozen” model parameters # (i.e. your optimizer filters out model parameters whose requires_grad is False), # then when resuming, you’ll need to unfreeze the network again and re-instantiate the optimizer afterwards. optimizer.load_state_dict(checkpoint['optimizer']) del checkpoint # current, saved else: # pretrain = "/home/master/kuanzi/weights/jde_1088x608_uncertainty.pt" pretrain = "/home/master/kuanzi/weights/jde_864x480_uncertainty.pt" #576x320 print("Loading jde finetune weight...", pretrain) sys.stdout.flush() checkpoint = torch.load(pretrain, map_location='cpu') model_dict = model.state_dict() pretrained_dict = {k: v for k, v in checkpoint['model'].items() if not k.startswith("classifier")} # 去掉全连接层 model_dict.update(pretrained_dict) model.load_state_dict(model_dict) model.cuda().train() print ("model weight loaded") sys.stdout.flush() classifer_param_value = list(map(id, model.classifier.parameters())) classifer_param = model.classifier.parameters() base_params = filter(lambda p: id(p) not in classifer_param_value, model.parameters()) print("classifer_param\n", classifer_param) # [2218660649072] print("classifer_param_value\n", classifer_param_value) # [2218660649072] print("base_params\n", base_params) # <filter object at 0x0000020493D95048> sys.stdout.flush() # optimizer = torch.optim.SGD(filter(lambda x: x.requires_grad, model.parameters()), lr=opt.lr * 0.1, momentum=.9) optimizer = torch.optim.SGD([ {'params': filter(lambda x: x.requires_grad, base_params), 'lr': opt.lr * 0.01}, {'params': classifer_param, 'lr': opt.lr}], momentum=.9) print("chk epoch:\n", checkpoint['epoch']) sys.stdout.flush() start_epoch = checkpoint['epoch'] + 1 else: # Initialize model with backbone (optional) print("Loading backbone...") sys.stdout.flush() if cfg.endswith('yolov3.cfg'): load_darknet_weights(model, osp.join(weights ,'darknet53.conv.74')) cutoff = 75 elif cfg.endswith('yolov3-tiny.cfg'): load_darknet_weights(model, osp.join(weights , 'yolov3-tiny.conv.15')) cutoff = 15 model.cuda().train() # Set optimizer optimizer = torch.optim.SGD(filter(lambda x: x.requires_grad, model.parameters()), lr=opt.lr, momentum=.9, weight_decay=1e-4) model = torch.nn.DataParallel(model) # Set scheduler scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=[int(0.5*opt.epochs), int(0.75*opt.epochs)], gamma=0.1) # An important trick for detection: freeze bn during fine-tuning if not opt.unfreeze_bn: for i, (name, p) in enumerate(model.named_parameters()): p.requires_grad = False if 'batch_norm' in name else True model_info(model) t0 = time.time() print("begin training...") sys.stdout.flush() for epoch in range(epochs): epoch += start_epoch logger.info(('%8s%12s' + '%10s' * 6) % ( 'Epoch', 'Batch', 'box', 'conf', 'id', 'total', 'nTargets', 'time')) # Freeze darknet53.conv.74 for first epoch if freeze_backbone and (epoch < 2): for i, (name, p) in enumerate(model.named_parameters()): if int(name.split('.')[2]) < cutoff: # if layer < 75 p.requires_grad = False if (epoch == 0) else True ui = -1 rloss = defaultdict(float) # running loss optimizer.zero_grad() for i, (imgs, targets, _, _, targets_len) in enumerate(dataloader): if sum([len(x) for x in targets]) < 1: # if no targets continue continue # SGD burn-in burnin = min(1000, len(dataloader)) if (epoch == 0) & (i <= burnin): lr = opt.lr * (i / burnin) **4 for g in optimizer.param_groups: g['lr'] = lr # Compute loss, compute gradient, update parameters loss, components = model(imgs.cuda(), targets.cuda(), targets_len.cuda()) components = torch.mean(components.view(-1, 5),dim=0) loss = torch.mean(loss) loss.backward() # accumulate gradient for x batches before optimizing if ((i + 1) % accumulated_batches == 0) or (i == len(dataloader) - 1): optimizer.step() optimizer.zero_grad() # Running epoch-means of tracked metrics ui += 1 for ii, key in enumerate(model.module.loss_names): rloss[key] = (rloss[key] * ui + components[ii]) / (ui + 1) s = ('%8s%12s' + '%10.3g' * 6) % ( '%g/%g' % (epoch, epochs - 1), '%g/%g' % (i, len(dataloader) - 1), rloss['box'], rloss['conf'], rloss['id'],rloss['loss'], rloss['nT'], time.time() - t0) t0 = time.time() if i % opt.print_interval == 0: logger.info(s) # # Save latest checkpoint # checkpoint = {'epoch': epoch, # 'model': model.module.state_dict(), # 'optimizer': optimizer.state_dict()} # torch.save(checkpoint, latest) # Calculate mAP if epoch % opt.test_interval ==0 and epoch != 0: epoch_chk = osp.join(weights, str(epoch) + '_epoch_arcface.pt') checkpoint = {'epoch': epoch, 'model': model.module.state_dict(), 'optimizer': optimizer.state_dict()} torch.save(checkpoint, epoch_chk) # """ 训练与测试解耦,以下工作单独进行 """ # with torch.no_grad(): # # mAP, R, P = test.test(cfg, data_cfg, weights=latest, batch_size=batch_size, print_interval=40) # # print ("test.test:\t", mAP, "\t", R, "\t", P) # test_mapgiou.test_giou(cfg, data_cfg, weights=latest, batch_size=batch_size, print_interval=40) # test_mapgiou.test_emb(cfg, data_cfg, weights=latest, batch_size=batch_size, print_interval=40) # Call scheduler.step() after opimizer.step() with pytorch > 1.1.0 scheduler.step()
def train_single_task(t_id, task, tasks, vis_p, learner, config, transfer_matrix, total_steps): training_params = config.pop('training-params') learner_params = config.pop('learner-params', {}) assert 'model-params' not in config, "Can't have model-specific " \ "parameters while tuning at the " \ "stream level." if learner_params: learner.set_h_params(**learner_params) batch_sizes = training_params.pop('batch_sizes') # optim_func = training_params.pop('optim_func') optim_func = learner.optim_func optim_params = config.pop('optim') schedule_mode = training_params.pop('schedule_mode') split_optims = training_params.pop('split_optims') dropout = config.pop('dropout') if 'dropout' in config else None stream_setting = training_params.pop('stream_setting') plot_all = training_params.pop('plot_all') normalize = training_params.pop('normalize') augment_data = training_params.pop('augment_data') transformations = [] if augment_data: transformations.extend([ transforms.ToPILImage(), transforms.RandomHorizontalFlip(), transforms.RandomCrop(32, 4), transforms.ToTensor() ]) lca_n = training_params.pop('lca') if plot_all: vis_p = get_training_vis_conf(vis_p, tune.get_trial_dir()) # print('NEW vis: ', vis_p) task_vis = visdom.Visdom(**vis_p) # env = [env[0], env[-1]] # vis_p['env'] = '_'.join(env) # vis_p['log_to_filename'] = os.path.join(vis_logdir, vis_p['env']) # g_task_vis = visdom.Visdom(**vis_p) logger.info(get_env_url(task_vis)) else: task_vis = None t_trans = [[] for _ in range(len(task['split_names']))] t_trans[0] = transformations.copy() datasets_p = dict(task=task, transforms=t_trans, normalize=normalize) datasets = _load_datasets(**datasets_p) train_loader, eval_loaders = get_classic_dataloaders(datasets, batch_sizes) assert t_id == task['id'] start1 = time.time() model = learner.get_model(task['id'], x_dim=task['x_dim'], n_classes=task['n_classes'], descriptor=task['descriptor'], dataset=eval_loaders[:2]) model_creation_time = time.time() - start1 loss_fn = task['loss_fn'] training_params['loss_fn'] = loss_fn prepare_batch = _prepare_batch if hasattr(model, 'prepare_batch_wrapper'): prepare_batch = model.prepare_batch_wrapper(prepare_batch, t_id) if hasattr(model, 'loss_wrapper'): training_params['loss_fn'] = \ model.loss_wrapper(training_params['loss_fn']) # if hasattr(model, 'backward_hook'): # training_params[] # optim = set_optim_params(optim_func, optim_params, model, split_optims) optim_fact = partial(set_optim_params, optim_func=optim_func, optim_params=optim_params, split_optims=split_optims) # if schedule_mode == 'steps': # lr_scheduler = torch.optim.lr_scheduler.\ # MultiStepLR(optim[0], milestones=[25, 40]) # elif schedule_mode == 'cos': # lr_scheduler = torch.optim.lr_scheduler.\ # CosineAnnealingLR(optim[0], T_max=200, eta_min=0.001) # elif schedule_mode is None: # lr_scheduler = None # else: # raise NotImplementedError() if dropout is not None: set_dropout(model, dropout) assert not config, config start2 = time.time() rescaled, t, metrics, b_state_dict = train_model( model, datasets_p, batch_sizes, optim_fact, prepare_batch, task, train_loader, eval_loaders, training_params, config) training_time = time.time() - start2 start3 = time.time() if not isinstance(model, ExhaustiveSearch): #todo Handle the state dict loading uniformly for all learners RN only # the exhaustive search models load the best state dict after training model.load_state_dict(b_state_dict['state_dict']) iterations = list(metrics.pop('training_iteration').values()) epochs = list(metrics.pop('training_epoch').values()) assert len(iterations) == len(epochs) index = dict(epochs=epochs, iterations=iterations) update_summary(index, task_vis, 'index', 0.5) grouped_xs = dict() grouped_metrics = defaultdict(list) grouped_legends = defaultdict(list) for metric_n, metric_v in metrics.items(): split_n = metric_n.split() if len(split_n) < 2: continue name = ' '.join(split_n[:-1]) grouped_metrics[split_n[-1]].append(list(metric_v.values())) grouped_legends[split_n[-1]].append(name) if split_n[-1] in grouped_xs: if len(metric_v) > len(grouped_xs[split_n[-1]]): longer_xs = list(metric_v.keys()) assert all(a == b for a, b in zip(longer_xs, grouped_xs[split_n[-1]])) grouped_xs[split_n[-1]] = longer_xs else: grouped_xs[split_n[-1]] = list(metric_v.keys()) for (plot_name, val), (_, legends) in sorted( zip(grouped_metrics.items(), grouped_legends.items())): assert plot_name == _ val = fill_matrix(val) if len(val) == 1: val = np.array(val[0]) else: val = np.array(val).transpose() x = grouped_xs[plot_name] task_vis.line(val, X=x, win=plot_name, opts={ 'title': plot_name, 'showlegend': True, 'width': 500, 'legend': legends, 'xlabel': 'iterations', 'ylabel': plot_name }) avg_data_time = list(metrics['data time_ps'].values())[-1] avg_forward_time = list(metrics['forward time_ps'].values())[-1] avg_epoch_time = list(metrics['epoch time_ps'].values())[-1] avg_eval_time = list(metrics['eval time_ps'].values())[-1] total_time = list(metrics['total time'].values())[-1] entropies, ent_legend = [], [] for metric_n, metric_v in metrics.items(): if metric_n.startswith('Trainer entropy'): entropies.append(list(metric_v.values())) ent_legend.append(metric_n) if entropies: task_vis.line(np.array(entropies).transpose(), X=iterations, win='ENT', opts={ 'title': 'Arch entropy', 'showlegend': True, 'width': 500, 'legend': ent_legend, 'xlabel': 'Iterations', 'ylabel': 'Loss' }) if hasattr(learner, 'arch_scores') and hasattr(learner, 'get_top_archs'): update_summary(learner.arch_scores[t_id], task_vis, 'scores') archs = model.get_top_archs(5) list_top_archs(archs, task_vis) if 'training_archs' in metrics: plot_trajectory(model.ssn.graph, metrics['training_archs'], model.ssn.stochastic_node_ids, task_vis) postproc_time = time.time() - start3 start4 = time.time() save_path = tune.get_trial_dir() finish_res = learner.finish_task(datasets[0], t_id, task_vis, save_path) finish_time = time.time() - start4 start5 = time.time() eval_tasks = tasks # eval_tasks = tasks[:t_id + 1] if stream_setting else tasks evaluation = evaluate_on_tasks(eval_tasks, learner, batch_sizes[1], training_params['device'], ['Val', 'Test'], normalize, cur_task=t_id) assert evaluation['Val']['accuracy'][t_id] == b_state_dict['value'] stats = {} eval_time = time.time() - start5 stats.update(finish_res) test_accs = metrics['Test accuracy_0'] if not test_accs: lca = np.float('nan') else: if len(test_accs) <= lca_n: last_key = max(test_accs.keys()) assert len(test_accs) == last_key + 1,\ f"Can't compute LCA@{lca_n} if steps were skipped " \ f"(got {list(test_accs.keys())})" test_accs = test_accs.copy() last_acc = test_accs[last_key] for i in range(last_key + 1, lca_n + 1): test_accs[i] = last_acc lca = np.mean([test_accs[i] for i in range(lca_n + 1)]) accs = {} key = 'accuracy' # logger.warning(evaluation) for split in evaluation.keys(): transfer_matrix[split].append(evaluation[split][key]) for i in range(len(tasks)): split_acc = evaluation[split][key] if i < len(split_acc): accs['{}_T{}'.format(split, i)] = split_acc[i] else: accs['{}_T{}'.format(split, i)] = float('nan') plot_heatmaps(list(transfer_matrix.keys()), list(map(fill_matrix, transfer_matrix.values())), task_vis) # logger.warning(t_id) # logger.warning(transfer_matrix) avg_val = np.mean(evaluation['Val']['accuracy']) avg_val_so_far = np.mean(evaluation['Val']['accuracy'][:t_id + 1]) avg_test = np.mean(evaluation['Test']['accuracy']) avg_test_so_far = np.mean(evaluation['Test']['accuracy'][:t_id + 1]) step_time_s = time.time() - start1 step_sum = model_creation_time + training_time + postproc_time + \ finish_time + eval_time best_it = b_state_dict.get('cum_best_iter', b_state_dict['iter']) tune.report( t=t_id, best_val=b_state_dict['value'], avg_acc_val=avg_val, avg_acc_val_so_far=avg_val_so_far, avg_acc_test_so_far=avg_test_so_far, lca=lca, avg_acc_test=avg_test, test_acc=evaluation['Test']['accuracy'][t_id], duration_seconds=step_time_s, duration_iterations=t, duration_best_it=best_it, duration_finish=finish_time, duration_model_creation=model_creation_time, duration_training=training_time, duration_postproc=postproc_time, duration_eval=eval_time, duration_sum=step_sum, # entropy=stats.pop('entropy'), new_params=learner.new_params(t_id), total_params=learner.n_params(t_id), total_steps=total_steps + t, fw_t=round(avg_forward_time * 1000) / 1000, data_t=round(avg_data_time * 1000) / 1000, epoch_t=round(avg_epoch_time * 1000) / 1000, eval_t=round(avg_eval_time * 1000) / 1000, total_t=round(total_time * 1000) / 1000, env_url=get_env_url(vis_p), **accs, **stats) return rescaled, t, metrics, b_state_dict, stats
def __init__(self, clip_info): self.list = clip_info self.transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ])
from torch.utils.data import DataLoader from torch import nn, optim from torchvision.transforms import transforms from unet import Unet from DataHelper import * from tqdm import tqdm import numpy as np import skimage.io as io PATH = './model/unet_model.pt' # 是否使用cuda device = torch.device("cuda" if torch.cuda.is_available() else "cpu") x_transforms = transforms.Compose( [transforms.ToTensor(), transforms.Normalize([0.5], [0.5])]) # mask只需要转换为tensor y_transforms = transforms.ToTensor() def train_model(model, criterion, optimizer, dataload, num_epochs=10): best_model = model min_loss = 1000 for epoch in range(num_epochs): print('Epoch {}/{}'.format(epoch, num_epochs - 1)) # print('-' * 10) dt_size = len(dataload.dataset) epoch_loss = 0 step = 0
def __init__(self, body_regressor_checkpoint, hand_regressor_checkpoint, smpl_dir, device=torch.device('cuda'), use_smplx=True): super().__init__('BodyMocap') self.device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu') print("Loading Body Pose Estimator") self.__load_body_estimator() self.visualizer = Visualizer('opengl') self.frame_id = 0 #count frames parser = argparse.ArgumentParser() parser.add_argument("--rot90", default=False, type= bool, help="clockwise rotate 90 degrees") #parser.add_argument("--camera_topic", default="/logi_c922_2/image_rect_color", help="choose a topic as input image") parser.add_argument("--body_only", default=False, type= bool, help="detect only body and save its result") parser.add_argument("--result_path", default="/home/student/result/", help="choose a topic as input image") parser.add_argument("--save_result", default=False, help="save result or not") args = parser.parse_args() self.rot90 = args.rot90 #self.camera_topic = args.camera_topic self.body_only = args.body_only self.result_path = args.result_path self.save_result = args.save_result self.load = [0,0] self.angle_leg = 0 self.angle_trunk = 0 self.start = 0 self.angles = np.empty((1,20),dtype = float) self.body_side = np.empty((25,3),dtype = float) # Load parametric model (SMPLX or SMPL) if use_smplx: smplModelPath = smpl_dir + '/SMPLX_NEUTRAL.pkl' self.smpl = SMPLX(smpl_dir, batch_size=1, num_betas = 10, use_pca = False, create_transl=False).to(self.device) self.use_smplx = True else: smplModelPath = smpl_dir + '/basicModel_neutral_lbs_10_207_0_v1.0.0.pkl' self.smpl = SMPL(smplModelPath, batch_size=1, create_transl=False).to(self.device) self.use_smplx = False #Load pre-trained neural network SMPL_MEAN_PARAMS = '/home/student/frankmocap/extra_data/body_module/data_from_spin/smpl_mean_params.npz' self.model_regressor = hmr(SMPL_MEAN_PARAMS).to(self.device) body_checkpoint = torch.load(body_regressor_checkpoint) self.model_regressor.load_state_dict(body_checkpoint['model'], strict=False) self.model_regressor.eval() #hand module init transform_list = [ transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))] self.normalize_transform = transforms.Compose(transform_list) #Load Hand network self.opt = TestOptions().parse([]) #Default options self.opt.single_branch = True self.opt.main_encoder = "resnet50" # self.opt.data_root = "/home/hjoo/dropbox/hand_yu/data/" self.opt.model_root = "/home/student/frankmocap/extra_data" self.opt.smplx_model_file = os.path.join(smpl_dir,'SMPLX_NEUTRAL.pkl') self.opt.batchSize = 1 self.opt.phase = "test" self.opt.nThreads = 0 self.opt.which_epoch = -1 self.opt.checkpoint_path = hand_regressor_checkpoint self.opt.serial_batches = True # no shuffle self.opt.no_flip = True # no flip self.opt.process_rank = -1 # self.opt.which_epoch = str(epoch) self.hand_model_regressor = H3DWModel(self.opt) # if there is no specified checkpoint, then skip assert self.hand_model_regressor.success_load, "Specificed checkpoints does not exists: {}".format(self.opt.checkpoint_path) self.hand_model_regressor.eval() self.hand_bbox_detector = HandBboxDetector('third_view', self.device) #subscriber and publisher initialization #input subscriber self.br = CvBridge() self.subscription_img = self.create_subscription(Image, '/side_img', self.callback_side,10) self.subscription_img = self.create_subscription(Image, '/front_img', self.callback_front,10) #output publisher self.publisher_pose = self.create_publisher(Image,'/pose',10) #images with keypoints annotation #self.publisher_keypoints = self.create_publisher(Float32MultiArray,'/keypoints',10) #keypoints coordinates self.publisher_risk = self.create_publisher(Int64,'/risk',10) #risk level self.publisher_angles = self.create_publisher(Float32MultiArray,'/angles',10)
#!/usr/bin/python # -*- coding:utf-8 -*- """ @author:fangpf @time: 2020/11/30 """ import torch from torchvision.transforms import transforms from model.inception_iccv import InceptionNet normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) transform = transforms.Compose( [transforms.Resize(size=(256, 128)), transforms.ToTensor(), normalize]) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") classes = [ 'Female', 'AgeLess16', 'Age17-30', 'Age31-45', 'BodyFat', 'BodyNormal', 'BodyThin', 'Customer', 'Clerk', 'BaldHead', 'LongHair', 'BlackHair', 'Hat', 'Glasses', 'Muffler', 'Shirt', 'Sweater', 'Vest', 'TShirt', 'Cotton', 'Jacket', 'Suit-Up', 'Tight', 'ShortSleeve', 'LongTrousers', 'Skirt', 'ShortSkirt', 'Dress', 'Jeans', 'TightTrousers', 'LeatherShoes', 'SportShoes', 'Boots', 'ClothShoes', 'CasualShoes', 'Backpack', 'SSBag', 'HandBag', 'Box', 'PlasticBag', 'PaperBag', 'HandTrunk', 'OtherAttchment', 'Calling', 'Talking', 'Gathering', 'Holding', 'Pusing', 'Pulling', 'CarryingbyArm', 'CarryingbyHand' ] classes_name = [
def evaluate(args): ''' This script is used to generate a evaluation figure. ''' use_gpu = torch.cuda.is_available() if use_gpu: print("GPU Enabled") print(f"Current GPU Memory Usage: {torch.cuda.memory_allocated()}") #Create the data t = transforms.Compose([ transforms.Resize(args.input_size), transforms.ToTensor(), ]) t2 = transforms.Compose([ transforms.Resize(args.mask_size), transforms.ToTensor(), ]) data_set = landpy.MyDataLoader(args.data_dir, args.mask_size, image_transforms=t, mask_transforms=t2) #Set Batch Size batch_size = 1 dataset_size = len(data_set) print(f"Number of Images {dataset_size}") train_loader, test_loader = landpy.create_data_loaders( data_set, 0.8, batch_size) unet_model = landpy.UNet(3, 7) if use_gpu: unet_model = unet_model.cuda() unet_model.load_state_dict(torch.load(args.model_path)) else: unet_model.load_state_dict( torch.load(args.model_path, map_location=torch.device('cpu'))) unet_model.eval() num_images = 3 figure_row = 0 sat_image, actual_mask, label = next(iter(test_loader)) fig, ax = plt.subplots(nrows=num_images, ncols=3, figsize=(20, 20)) for i, (test_image, labels, class_labels) in enumerate(test_loader): if use_gpu: test_image = test_image.cuda() torch.cuda.empty_cache() predictions = unet_model(test_image) soft_max_output = torch.nn.LogSoftmax(dim=1)(predictions) if use_gpu: soft_max_output = soft_max_output.cpu() numpy_output = soft_max_output.data.numpy() final_prediction = np.argmax(numpy_output, axis=1) prediction_img = landpy.construct_image(final_prediction[0], args.mask_size) ax[figure_row][0].imshow( np.transpose(test_image[0].data.numpy(), (1, 2, 0))) ax[figure_row][0].set_title("Real Image") ax[figure_row][1].imshow( np.transpose(labels[0].data.numpy(), (1, 2, 0))) ax[figure_row][1].set_title("Actual Mask") ax[figure_row][2].imshow(np.transpose(prediction_img, (1, 2, 0))) ax[figure_row][2].set_title("Prediction Mask") figure_row += 1 if figure_row == num_images: break fig_path = os.path.join(args.figure_path, 'evaluation_figure.png') plt.savefig(fig_path)
x = ReLU(self.fc4(code)) x = ReLU(self.fc5(x)) x = self.fc6(x) return x def encoders(self, x): x = ReLU(self.fc1(x)) x = ReLU(self.fc2(x)) code = ReLU(self.fc3(x)) return code tr = transforms.Compose([transforms.ToTensor()]) train = MNIST('./data', transform=tr, download=True) test = MNIST('./data', transform=tr, train=False, download=True) epoch = 10 batch_size = 30 train = DataLoader(train, batch_size, True) test = DataLoader(test, batch_size, False) vae = VAE((1, 28, 28), 120) sgd = tch.optim.RMSprop(vae.parameters()) mse = nn.MSELoss() # dev = tch.device('cuda:0') # vae.to(dev) for j in range(epoch):
from torch.utils.data import DataLoader import torchvision from torchvision.transforms import transforms as tfs from torchvision import models from torchvision.models import ResNet import numpy as np from visdom import Visdom import os data_dir='./data/hymenoptera_data' train_dataset=torchvision.datasets.ImageFolder(root=os.path.join(data_dir,'train'), transform=tfs.Compose([ tfs.RandomResizedCrop(224), tfs.RandomHorizontalFlip(), tfs.ToTensor(), tfs.Normalize( mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225) ) ]) ) val_dataset=torchvision.datasets.ImageFolder(root=os.path.join(data_dir,'val'), transform=tfs.Compose([ tfs.RandomResizedCrop(224), tfs.RandomHorizontalFlip(), tfs.ToTensor(), tfs.Normalize( mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225) )
# -*- coding: utf-8 -*- """s15transform.ipynb Automatically generated by Colaboratory. Original file is located at https://colab.research.google.com/drive/1aAmDlTSAc1ypmMIHgcHpYVlTSFQL3Dbo """ from torchvision.transforms import transforms scale_transform = transforms.Compose([ transforms.Resize((128, 128)), transforms.Grayscale(num_output_channels=3), transforms.ToTensor(), ])
def __init__(self): ##The top config #self.data_root = '/media/hhy/data/USdata/MergePhase1/test_0.3' #self.log_dir = '/media/hhy/data/code_results/MILs/MIL_H_Attention' self.root = '/remote-home/my/Ultrasound_CV/data/Ruijin/clean' self.log_dir = '/remote-home/my/hhy/Ultrasound_MIL/experiments/PLN1/base/fold4' if not os.path.exists(self.log_dir): os.makedirs(self.log_dir) ##training config self.lr = 1e-4 self.epoch = 50 self.resume = -1 self.batch_size = 1 self.net = Attention() self.net.cuda() self.optimizer = Adam(self.net.parameters(), lr=self.lr) self.lrsch = torch.optim.lr_scheduler.MultiStepLR( self.optimizer, milestones=[10, 30, 50, 70], gamma=0.5) self.logger = Logger(self.log_dir) self.train_transform = transforms.Compose([ transforms.Resize((224, 224)), transforms.RandomResizedCrop((224, 224)), transforms.RandomHorizontalFlip(0.5), transforms.RandomVerticalFlip(0.5), transforms.ColorJitter(0.25, 0.25, 0.25, 0.25), transforms.ToTensor() ]) self.test_transform = transforms.Compose( [transforms.Resize((224, 224)), transforms.ToTensor()]) self.label_name = "手术淋巴结情况(0未转移;1转移)" self.trainbag = RuijinBags(self.root, [0, 1, 2, 3], self.train_transform, label_name=self.label_name) self.testbag = RuijinBags(self.root, [4], self.test_transform, label_name=self.label_name) train_label_list = list( map(lambda x: int(x['label']), self.trainbag.patient_info)) pos_ratio = sum(train_label_list) / len(train_label_list) print(pos_ratio) train_weight = [(1 - pos_ratio) if x > 0 else pos_ratio for x in train_label_list] # self.train_sampler = WeightedRandomSampler(weights=train_weight, num_samples=len(self.trainbag)) self.train_loader = DataLoader(self.trainbag, batch_size=self.batch_size, num_workers=8, shuffle=True) self.val_loader = DataLoader(self.testbag, batch_size=self.batch_size, shuffle=False, num_workers=8) if self.resume > 0: self.net, self.optimizer, self.lrsch, self.loss, self.global_step = self.logger.load( self.net, self.optimizer, self.lrsch, self.loss, self.resume) else: self.global_step = 0 # self.trainer = MTTrainer(self.net, self.optimizer, self.lrsch, self.loss, self.train_loader, self.val_loader, self.logger, self.global_step, mode=2) self.trainer = MILTrainer(self.net, self.optimizer, self.lrsch, None, self.train_loader, self.val_loader, self.logger, self.global_step)