def dense_process_data(index): images = list() for ind in indices['dense']: ptr = int(ind) if ptr <= record.num_frames: imgs = self._load_image(record.path, ptr) else: imgs = self._load_image(record.path, record.num_frames) images.extend(imgs) if self.phase == 'Fntest': images = [np.asarray(im) for im in images] clip_input = np.concatenate(images, axis=2) self.t = transforms.Compose([ transforms.Resize(256)]) clip_input = self.t(clip_input) normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) if record.crop_pos == 0: self.transform = transforms.Compose([ transforms.CenterCrop((256, 256)), transforms.ToTensor(), normalize, ]) elif record.crop_pos == 1: self.transform = transforms.Compose([ transforms.CornerCrop2((256, 256),), transforms.ToTensor(), normalize, ]) elif record.crop_pos == 2: self.transform = transforms.Compose([ transforms.CornerCrop1((256, 256)), transforms.ToTensor(), normalize, ]) return self.transform(clip_input) return self.transform(images)
def trans(is_training = True): transforms = [] transforms.append(T.ToTensor()) if is_training: transforms.append(T.RandomHorizontalFlip(0.5)) return T.Compose(transforms)
def make_coco_transforms(image_set): normalize = T.Compose([T.ToTensor()]) if image_set == 'train': return T.Compose([ T.RandomHorizontalFlip(0.5), normalize, ]) if image_set == 'val': return T.Compose([ normalize, ]) raise ValueError(f'unknown {image_set}')
cuda_available = torch.cuda.is_available() # directory results if not os.path.exists(RESULTS_PATH): os.makedirs(RESULTS_PATH) # Load dataset mean = m std_dev = s transform_train = transforms.Compose([ transforms.RandomApply([transforms.ColorJitter(0.1, 0.1, 0.1, 0.1)], p=0.5), transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize(mean, std_dev) ]) transform_test = transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize(mean, std_dev) ]) training_set = LocalDataset(IMAGES_PATH, TRAINING_PATH, transform=transform_train) validation_set = LocalDataset(IMAGES_PATH, VALIDATION_PATH, transform=transform_test)
def get_transform(train): transforms = [] transforms.append(T.ToTensor()) if train: transforms.append(T.RandomHorizontalFlip(0.5)) return T.Compose(transforms)
# batch_size=args.batch_size, shuffle=True, num_workers=4, pin_memory=True) # valloader = torch.utils.data.DataLoader(CSDataSet(args.data_dir, './dataset/list/cityscapes/val.lst', crop_size=(1024, 2048), mean=IMG_MEAN, scale=False, mirror=False), # batch_size=2, shuffle=False, pin_memory=True) value_scale = 255 mean = [0.485, 0.456, 0.406] mean = [item * 255 for item in mean] std = [0.229, 0.224, 0.225] std = [item * 255 for item in std] train_transform = my_trans.Compose([ # my_trans.Resize((args.height, args.width)), # my_trans.RandScale([0.5, 2.0]), # my_trans.RandomGaussianBlur(), my_trans.RandomHorizontalFlip(), # my_trans.Crop([args.height, args.width],crop_type='rand', padding=mean, ignore_label=255), my_trans.ToTensor(), # without div 255 my_trans.Normalize(mean=mean, std=std) ]) val_transform = my_trans.Compose([ # my_trans.Resize((args.height, args.width)), my_trans.ToTensor(), # without div 255 my_trans.Normalize(mean=mean, std=std) ]) data_dir = '/data/zzg/CamVid/' train_dataset = CamVid(data_dir, mode='train', p=None, transform=train_transform) trainloader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size,
def main(): global args, best_record args = parser.parse_args() if args.augment: transform_train = joint_transforms.Compose([ joint_transforms.RandomCrop(256), joint_transforms.Normalize(), joint_transforms.ToTensor(), ]) else: transform_train = None dataset_train = Data.WData(args.data_root, transform_train) dataloader_train = data.DataLoader(dataset_train, batch_size=args.batch_size, shuffle=True, num_workers=16) dataset_val = Data.WData(args.val_root, transform_train) dataloader_val = data.DataLoader(dataset_val, batch_size=args.batch_size, shuffle=None, num_workers=16) model = SFNet(input_channels=37, dilations=[2, 4, 8], num_class=2) # multi gpu model = torch.nn.DataParallel(model) print('Number of model parameters: {}'.format( sum([p.data.nelement() for p in model.parameters()]))) model = model.cuda() cudnn.benchmark = True # define loss function (criterion) and pptimizer criterion = torch.nn.CrossEntropyLoss(ignore_index=-1).cuda() optimizer = torch.optim.SGD([{ 'params': get_1x_lr_params(model) }, { 'params': get_10x_lr_params(model), 'lr': 10 * args.learning_rate }], lr=args.learning_rate, momentum=args.momentum, weight_decay=args.weight_decay) for epoch in range(args.start_epoch, args.epochs): adjust_learning_rate(optimizer, epoch) # train for one epoch train(dataloader_train, model, criterion, optimizer, epoch) # evaluate on validation set acc, mean_iou, val_loss = validate(dataloader_val, model, criterion, epoch) is_best = mean_iou > best_record['miou'] if is_best: best_record['epoch'] = epoch best_record['val_loss'] = val_loss.avg best_record['acc'] = acc best_record['miou'] = mean_iou save_checkpoint( { 'epoch': epoch + 1, 'val_loss': val_loss.avg, 'accuracy': acc, 'miou': mean_iou, 'model': model, }, is_best) print( '------------------------------------------------------------------------------------------------------' ) print('[epoch: %d], [val_loss: %5f], [acc: %.5f], [miou: %.5f]' % (epoch, val_loss.avg, acc, mean_iou)) print( 'best record: [epoch: {epoch}], [val_loss: {val_loss:.5f}], [acc: {acc:.5f}], [miou: {miou:.5f}]' .format(**best_record)) print( '------------------------------------------------------------------------------------------------------' )
def train(args, model, optimizer, loss, log_file=None, test_cnf=None, val_cnf=None, models_folder=None, tb_writer=None): log = log_file start = time.time() train_set = NTUSkeletonDataset.NTUSkeletonDataset( args['train_path'], cache_dir=args['cache_path'], selected_actions=args['selected_actions'], selected_joints=args['selected_joints'], transform=transforms.Compose([ skeleton_transforms.MoveOriginToJoint(), skeleton_transforms.GaussianFilter(), skeleton_transforms.ResizeSkeletonSegments(), skeleton_transforms.UniformSampleOrPad( args['maximum_sample_size']), skeleton_transforms.ToTensor(), skeleton_transforms.MovingPoseDescriptor( args['maximum_sample_size']) ]), use_cache=args['use_cache'], use_validation=args['use_validation'], validation_fraction=args['validation_fraction'], preprocessing_threads=args['preprocessing_threads']) end = time.time() num_train_samples = len(train_set) train_set.set_use_mode(NTUSkeletonDataset.DatasetMode.VALIDATION) num_val_samples = len(train_set) train_set.set_use_mode(NTUSkeletonDataset.DatasetMode.TRAIN) print( end - start, "Loaded {} train samples and {} validation samples".format( num_train_samples, num_val_samples)) start = time.time() test_set = NTUSkeletonDataset.NTUSkeletonDataset( args['test_path'], cache_dir=args['cache_path'], selected_actions=args['selected_actions'], selected_joints=args['selected_joints'], transform=transforms.Compose([ skeleton_transforms.MoveOriginToJoint(), skeleton_transforms.GaussianFilter(), skeleton_transforms.ResizeSkeletonSegments(), skeleton_transforms.UniformSampleOrPad( args['maximum_sample_size']), skeleton_transforms.ToTensor(), skeleton_transforms.MovingPoseDescriptor( args['maximum_sample_size']) ]), use_cache=args['use_cache'], use_validation=False, preprocessing_threads=args['preprocessing_threads']) end = time.time() print(end - start, "Loaded {} test samples".format(len(test_set))) train_loader = DataLoader(train_set, batch_size=args['batch_size'], shuffle=True) min_train_loss = np.inf min_train_epoch = -1 min_validation_loss = np.inf min_validation_epoch = -1 max_validation_acc = 0 max_validation_acc_epoch = -1 min_test_loss = np.inf min_test_epoch = -1 max_test_acc = 0 max_test_acc_epoch = -1 for epoch in range(1, args['epochs'] + 1): __log('\n################\n### EPOCH {}\n################\n'.format( epoch), color='cyan', log=log) train_loss, (mean_max_param, mean_avg_param, mean_max_grad, mean_avg_grad) = train_epoch(epoch, args, model, train_loader, optimizer, loss, log) if train_loss < min_train_loss: color = "green" min_train_loss = train_loss min_train_epoch = epoch else: color = "red" __log('[TRAIN] Mean loss: {}\t' 'Best_train_loss: {}\t at epoch: {}'.format( train_loss, min_train_loss, min_train_epoch), color=color, log=log) if epoch % 5 != 0: continue # Perform validation train_set.set_use_mode(NTUSkeletonDataset.DatasetMode.VALIDATION) validation_loss, validation_acc = validate(epoch, model, train_set, args, val_cnf, loss, log) train_set.set_use_mode(NTUSkeletonDataset.DatasetMode.TRAIN) test_color = None test_loss = 0. if validation_loss < min_validation_loss: min_validation_loss = validation_loss min_validation_epoch = epoch if validation_acc > max_validation_acc: color = "green" max_validation_acc = validation_acc max_validation_acc_epoch = epoch # Perform test on best models test_loss, test_acc = test(epoch, model, test_set, args, test_cnf, loss) if test_loss < min_test_loss: min_test_loss = test_loss min_test_epoch = epoch if test_acc > max_test_acc: max_test_acc = test_acc max_test_acc_epoch = epoch test_color = "blue" save_best_model(model, models_folder) else: test_color = "red" else: color = "red" __log('[VALIDATION] Mean loss\t: {}\t Best_validation_loss: {}\t' 'at epoch: {}'.format(validation_loss, min_validation_loss, min_validation_epoch), log=log) __log('[VALIDATION] Accuracy\t: {}\t Best_validation_acc: {}\t ' 'at epoch: {}'.format(validation_acc, max_validation_acc, max_validation_acc_epoch), color=color, log=log) if test_color: __log('[TEST] Mean loss\t: {}\t Best_test_loss: {}\t' 'at epoch: {}'.format(test_loss, min_test_loss, min_test_epoch), log=log) __log('[TEST] Accuracy\t: {}\t Best_test_acc: {}\t ' 'at epoch: {}'.format(test_acc, max_test_acc, max_test_acc_epoch), color=test_color, log=log) if test_color: tb_writer.add_scalars( 'Loss', { 'Train': train_loss, 'Validation': validation_loss, 'Test': test_acc }, epoch) tb_writer.add_scalar('Test-Accuracy', test_acc, epoch) else: tb_writer.add_scalars('Loss', { 'Train': train_loss, 'Validation': validation_loss }, epoch) tb_writer.add_scalar('Validation-Accuracy', validation_acc, epoch) tb_writer.add_scalars('Params', { 'Max': mean_max_param, 'Avg': mean_avg_param }, epoch) tb_writer.add_scalars('Grads', { 'Max': mean_max_grad, 'Avg': mean_avg_grad }, epoch) log.flush()
help="Name of the dataset: ['facades', 'maps', 'cityscapes']") parser.add_argument("--batch_size", type=int, default=1, help="Size of the batches") parser.add_argument("--lr", type=float, default=0.0002, help="Adams learning rate") args = parser.parse_args() device = ('cuda:0' if torch.cuda.is_available() else 'cpu') transforms = T.Compose([ T.Resize((256, 256)), T.ToTensor(), T.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]) ]) # models print('Defining models!') generator = UnetGenerator().to(device) discriminator = ConditionalDiscriminator().to(device) # optimizers g_optimizer = torch.optim.Adam(generator.parameters(), lr=args.lr, betas=(0.5, 0.999)) d_optimizer = torch.optim.Adam(discriminator.parameters(), lr=args.lr, betas=(0.5, 0.999)) # loss functions g_criterion = GeneratorLoss(alpha=100)
def main(): global best_acc if not os.path.isdir(args.out): mkdir_p(args.out) # Data print(f'==> Preparing cifar10') transform_train = transforms.Compose([ transforms.RandomCrop(32), transforms.RandomFlip(), transforms.ToTensor(), ]) transform_val = transforms.Compose([ transforms.CenterCrop(32), transforms.ToTensor(), ]) train_labeled_set, train_unlabeled_set, _, val_set, test_set = dataset.get_cifar10( './data', args.n_labeled, args.outdata, transform_train=transform_train, transform_val=transform_val) labeled_trainloader = data.DataLoader(train_labeled_set, batch_size=args.batch_size, shuffle=True, num_workers=0, drop_last=True) unlabeled_trainloader = data.DataLoader(train_unlabeled_set, batch_size=args.batch_size, shuffle=True, num_workers=0, drop_last=True) val_loader = data.DataLoader(val_set, batch_size=args.batch_size, shuffle=False, num_workers=0) test_loader = data.DataLoader(test_set, batch_size=args.batch_size, shuffle=False, num_workers=0) # Model print("==> creating WRN-28-2") def create_model(ema=False): model = models.WideResNet(num_classes=10) model = model.cuda() if ema: for param in model.parameters(): param.detach_() return model model = create_model() ema_model = create_model(ema=True) cudnn.benchmark = True print(' Total params: %.2fM' % (sum(p.numel() for p in model.parameters()) / 1000000.0)) train_criterion = SemiLoss() criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=args.lr) ema_optimizer = WeightEMA(model, ema_model, alpha=args.ema_decay) start_epoch = 0 # Resume title = 'noisy-cifar-10' if args.resume: # Load checkpoint. print('==> Resuming from checkpoint..') assert os.path.isfile( args.resume), 'Error: no checkpoint directory found!' args.out = os.path.dirname(args.resume) checkpoint = torch.load(args.resume) best_acc = checkpoint['best_acc'] start_epoch = checkpoint['epoch'] model.load_state_dict(checkpoint['state_dict']) ema_model.load_state_dict(checkpoint['ema_state_dict']) optimizer.load_state_dict(checkpoint['optimizer']) logger = Logger(os.path.join(args.out, 'log.txt'), title=title, resume=True) else: logger = Logger(os.path.join(args.out, 'log.txt'), title=title) logger.set_names([ 'Train Loss', 'Train Loss X', 'Train Loss U', 'Valid Loss', 'Valid Acc.', 'Test Loss', 'Test Acc.' ]) writer = SummaryWriter(args.out) step = 0 test_accs = [] # Train and val for epoch in range(start_epoch, args.epochs): print('\nEpoch: [%d | %d] LR: %f' % (epoch + 1, args.epochs, state['lr'])) train_loss, train_loss_x, train_loss_u = train( labeled_trainloader, unlabeled_trainloader, model, optimizer, ema_optimizer, train_criterion, epoch, use_cuda) _, train_acc = validate(labeled_trainloader, ema_model, criterion, epoch, use_cuda, mode='Train Stats') val_loss, val_acc = validate(val_loader, ema_model, criterion, epoch, use_cuda, mode='Valid Stats') test_loss, test_acc = validate(test_loader, ema_model, criterion, epoch, use_cuda, mode='Test Stats ') step = args.val_iteration * (epoch + 1) writer.add_scalar('losses/train_loss', train_loss, step) writer.add_scalar('losses/valid_loss', val_loss, step) writer.add_scalar('losses/test_loss', test_loss, step) writer.add_scalar('accuracy/train_acc', train_acc, step) writer.add_scalar('accuracy/val_acc', val_acc, step) writer.add_scalar('accuracy/test_acc', test_acc, step) # append logger file logger.append([ train_loss, train_loss_x, train_loss_u, val_loss, val_acc, test_loss, test_acc ]) # save model is_best = val_acc > best_acc best_acc = max(val_acc, best_acc) save_checkpoint( { 'epoch': epoch + 1, 'state_dict': model.state_dict(), 'ema_state_dict': ema_model.state_dict(), 'acc': val_acc, 'best_acc': best_acc, 'optimizer': optimizer.state_dict(), }, is_best) test_accs.append(test_acc) logger.close() writer.close() print('Mean acc:') print(np.mean(test_accs[-20:]))
def inference(args): if args.target=='mnistm': args.source = 'usps' elif args.target=='usps': args.source = 'svhn' elif args.target=='svhn': args.source = 'mnistm' else: raise NotImplementedError(f"{args.target}: not implemented!") size = args.img_size t1 = transforms.Compose([ transforms.Resize(size), transforms.Grayscale(3), transforms.ToTensor(), transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5)) ]) valid_target_dataset = Digits_Dataset_Test(args.dataset_path, t1) valid_target_dataloader = DataLoader(valid_target_dataset, batch_size=512, num_workers=6) load = torch.load( f"./p3/result/3_2/{args.source}2{args.target}/best_model.pth", map_location='cpu') feature_extractor = FeatureExtractor() feature_extractor.load_state_dict(load['F']) feature_extractor.cuda() feature_extractor.eval() label_predictor = LabelPredictor() label_predictor.load_state_dict(load['C']) label_predictor.cuda() label_predictor.eval() out_preds = [] out_fnames = [] count=0 for i,(imgs, fnames) in enumerate(valid_target_dataloader): bsize = imgs.size(0) imgs = imgs.cuda() features = feature_extractor(imgs) class_output = label_predictor(features) _, preds = class_output.max(1) preds = preds.detach().cpu() out_preds.append(preds) out_fnames += fnames count+=bsize print(f"\t [{count}/{len(valid_target_dataloader.dataset)}]", end=" \r") out_preds = torch.cat(out_preds) out_preds = out_preds.cpu().numpy() d = {'image_name':out_fnames, 'label':out_preds} df = pd.DataFrame(data=d) df = df.sort_values('image_name') df.to_csv(args.out_csv, index=False) print(f' [Info] finish predicting {args.dataset_path}')
# others parser.add_argument('--device', type=str, default='cuda:0', help='cpu or cuda:0 or cuda:1') args = parser.parse_args() if string is None else parser.parse_args(string) return args if __name__ == '__main__': args = parse_args() wandb.init(config=args, project='dlcv_gan_face') transform = transforms.Compose( [transforms.RandomHorizontalFlip(), transforms.ToTensor()]) train_dataset = Face_Dataset('../hw3_data/face/train', transform) valid_dataset = Face_Dataset('../hw3_data/face/test', transform) train_dataloader = DataLoader(train_dataset, batch_size=args.batch, shuffle=True, num_workers=args.num_workers) valid_dataloader = DataLoader(valid_dataset, batch_size=args.batch, num_workers=args.num_workers) train(args, train_dataloader, valid_dataloader)
sys.path.insert(0, "/cluster/home/julin/workspace/Semester_project_release") import os import torch import numpy as np from torch.utils.data import Dataset from dataset.nuscenes_dataset import Nuscenes_dataset from config.config_nuscenes import config_nuscenes as cfg from dataset.dense_to_sparse import UniformSampling, LidarRadarSampling from dataset import transforms as transforms from dataset.radar_preprocessing import filter_radar_points_gt import math import h5py import pickle import matplotlib.pyplot as plt to_tensor = transforms.ToTensor() #################################### ## Sparsifier Documentations: ## 1. uniform: Uniformly sampled LiDAR points. ## 2. lidar_radar: Sampled LiDAR points using the radar pattern. ## 3. radar: raw radar points (accumulated from three time steps. ## 4. radar_filtered: Filtered radar points using the heuristic algorithm. ## 5. radar_filtered2: Filtered radar points using the trained point classifier. #################################### # Define the dataset object for torch class nuscenes_dataset_torch(Dataset): def __init__( self,
import onnx import onnxruntime import numpy as np import torch import torchvision from detrac import Detrac import dataset.transforms as T root = r"D:\dataset\UA-DETRAC\Detrac_dataset" transforms = [] transforms.append(T.ToTensor()) transformscompose = T.Compose(transforms) detrac = Detrac(root, imgformat='jpg', transforms=transformscompose) img = [detrac[0][0]] onnx_model = onnx.load("carmodel2.onnx") onnx.checker.check_model(onnx_model) ort_session = onnxruntime.InferenceSession("carmodel2.onnx") checkpoint = torch.load(r"D:\dataset\UA-DETRAC\model_9.pth", map_location='cpu') model = torchvision.models.detection.fasterrcnn_resnet50_fpn(num_classes=5, pretrained=False) model.load_state_dict(checkpoint['model']) model.eval() torch_out = model(img) print(torch_out) def to_numpy(tensor): return tensor.detach().cpu().numpy(