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 get_coco(root, image_set, transforms, mode='instances'): anno_file_template = "{}_{}2017.json" PATHS = { "train": ("train2017", os.path.join("annotations", anno_file_template.format(mode, "train"))), "val": ("val2017", os.path.join("annotations", anno_file_template.format(mode, "val"))), # "train": ("val2017", os.path.join("annotations", anno_file_template.format(mode, "val"))) } t = [ConvertCocoPolysToMask()] if transforms is not None: t.append(transforms) transforms = T.Compose(t) img_folder, ann_file = PATHS[image_set] img_folder = os.path.join(root, img_folder) ann_file = os.path.join(root, ann_file) dataset = CocoDetection(img_folder, ann_file, transforms=transforms) if image_set == "train": dataset = _coco_remove_images_without_annotations(dataset) # dataset = torch.utils.data.Subset(dataset, [i for i in range(500)]) return dataset
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}')
def trans(is_training = True): transforms = [] transforms.append(T.ToTensor()) if is_training: transforms.append(T.RandomHorizontalFlip(0.5)) return T.Compose(transforms)
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( '------------------------------------------------------------------------------------------------------' )
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)
print ("Preprocessing..") preprocessing() print ("Preprocessing finished!") 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 = transforms.Compose([transforms.Resize((224,224)), transforms.ToTensor(), transforms.Normalize(mean, std_dev)]) training_set = LocalDataset(IMAGES_PATH, TRAINING_PATH, transform=transform) validation_set = LocalDataset(IMAGES_PATH, VALIDATION_PATH, transform=transform) training_set_loader = DataLoader(dataset=training_set, batch_size=BATCH_SIZE, num_workers=THREADS, shuffle=True) validation_set_loader = DataLoader(dataset=validation_set, batch_size=BATCH_SIZE, num_workers=THREADS, shuffle=False) def train_model(model_name, model, lr=LEARNING_RATE, epochs=EPOCHS, momentum=MOMENTUM, weight_decay=0, train_loader=training_set_loader, test_loader=validation_set_loader): if not os.path.exists(RESULTS_PATH + "/" + model_name): os.makedirs(RESULTS_PATH + "/" + model_name) criterion = nn.CrossEntropyLoss() optimizer = SGD(model.parameters(), lr, momentum=momentum, weight_decay=weight_decay)
import gc # directory results if not os.path.exists(RESULTS_PATH): os.makedirs(RESULTS_PATH) cuda_available = torch.cuda.is_available() # Load dataset # pre-computed mean and standard_deviation mean = torch.Tensor([0.3877, 0.3647, 0.3547]) std_dev = torch.Tensor([0.2121, 0.2106, 0.2119]) transform = transforms.Compose([transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean, std_dev)]) training_set = LocalDataset(IMAGES_PATH, TRAINING_PATH, transform=transform) validation_set = LocalDataset(IMAGES_PATH, VALIDATION_PATH, transform=transform) test_set = LocalDataset(IMAGES_PATH, TEST_PATH, transform=transform) training_set_loader = DataLoader(dataset=training_set, batch_size=BATCH_SIZE, num_workers=THREADS, shuffle=True) validation_set_loader = DataLoader(dataset=validation_set, batch_size=BATCH_SIZE, num_workers=THREADS, shuffle=False) test_set_loader = DataLoader(dataset=test_set, batch_size=BATCH_SIZE, num_workers=THREADS, shuffle=False) if REGRESSION: classes = {"num_classes": 4} else: classes = {"num_classes": 16}
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(
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}')
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.Resize(args.img_size), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize([0.5] * 3, [0.5] * 3) ]) 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)
# 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)
def transform_val(self, input_data): rgb = np.array(input_data["image"]).astype(np.float32) lidar_depth = np.array(input_data["lidar_depth"]).astype(np.float32) radar_depth = np.array(input_data["radar_depth"]).astype(np.float32) if 'index_map' in input_data.keys(): index_map = np.array(input_data["index_map"]).astype(np.int) # Then, we add model-aware resizing if self.transform_mode == "DORN": if cfg.scaling is True: h, w, _ = tuple((np.array(rgb.shape)).astype(np.int32)) else: h, w, _ = tuple((np.array(rgb.shape) * 0.5).astype(np.int32)) h_new = self.t_cfg.crop_size_train[0] w_new = w resize_image_method = transforms.Resize([h_new, w_new], interpolation="bilinear") resize_depth_method = transforms.Resize([h_new, w_new], interpolation="nearest") elif self.transform_mode == "sparse-to-dense": h_new = self.t_cfg.crop_size_train[0] w_new = self.t_cfg.crop_size_train[1] resize_image_method = transforms.Resize([h_new, w_new], interpolation="bilinear") resize_depth_method = transforms.Resize([h_new, w_new], interpolation="nearest") transform_rgb = transforms.Compose([ # resize_image_method, transforms.CenterCrop(self.t_cfg.crop_size_val) ]) transform_depth = transforms.Compose([ # resize_depth_method, transforms.CenterCrop(self.t_cfg.crop_size_val) ]) rgb = transform_rgb(rgb) rgb = rgb / 255. lidar_depth = transform_depth(lidar_depth) rgb = np.array(rgb).astype(np.float32) lidar_depth = np.array(lidar_depth).astype(np.float32) rgb = to_tensor(rgb) lidar_depth = to_tensor(lidar_depth) radar_depth = transform_depth(radar_depth) radar_depth = np.array(radar_depth).astype(np.float32) radar_depth = to_tensor(radar_depth) # Perform transform on index map if 'index_map' in input_data.keys(): index_map = transform_depth(index_map) index_map = np.array(index_map).astype(np.int) index_map = to_tensor(index_map) index_map = index_map.unsqueeze(0) # Normalize to imagenet mean and std if self.transform_mode == "DORN": rgb = transforms.normalization_imagenet(rgb) #################### ## Filtering part ## #################### if self.sparsifier == "radar_filtered": # Indicating the invalid entries invalid_mask = ~input_data['valid_mask'] invalid_index = np.where(invalid_mask)[0] invalid_index_mask = invalid_index[None, None, ...].transpose(2, 0, 1) # Constructing mask for dense depth dense_mask = torch.ByteTensor( np.sum(index_map.numpy() == invalid_index_mask, axis=0)) radar_depth_filtered = radar_depth.clone() radar_depth_filtered[dense_mask.to(torch.bool)] = 0. radar_depth_filtered = radar_depth_filtered.unsqueeze(0) # ipdb.set_trace() #################### ###################################### ## Filtering using predicted labels ## ###################################### if self.sparsifier == "radar_filtered2": # ipdb.set_trace() invalid_mask = ~input_data['pred_labels'] invalid_index = np.where(invalid_mask)[0] invalid_index_mask = invalid_index[None, None, ...].transpose(2, 0, 1) dense_mask = torch.ByteTensor( np.sum(index_map.numpy() == invalid_index_mask, axis=0)) radar_depth_filtered2 = radar_depth.clone() radar_depth_filtered2[dense_mask.to(torch.bool)] = 0. radar_depth_filtered2 = radar_depth_filtered2.unsqueeze(0) ###################################### lidar_depth = lidar_depth.unsqueeze(0) radar_depth = radar_depth.unsqueeze(0) # Return different data for different modality ################ Input sparsifier ######### if self.modality == "rgb": inputs = rgb elif self.modality == "rgbd": if self.sparsifier == "radar": # Filter out the the points exceeding max_depth mask = (radar_depth > self.max_depth) radar_depth[mask] = 0 inputs = torch.cat((rgb, radar_depth), dim=0) elif self.sparsifier == "radar_filtered": # Filter out the points exceeding max_depth mask = (radar_depth_filtered > self.max_depth) radar_depth_filtered[mask] = 0 inputs = torch.cat((rgb, radar_depth_filtered), dim=0) # Using the learned classifyer elif self.sparsifier == "radar_filtered2": # Filter out the points exceeding max_depth mask = (radar_depth_filtered2 > self.max_depth) radar_depth_filtered2[mask] = 0 inputs = torch.cat((rgb, radar_depth_filtered2), dim=0) else: s_depth = self.get_sparse_depth(lidar_depth, radar_depth) inputs = torch.cat((rgb, s_depth), dim=0) else: raise ValueError("[Error] Unsupported modality. Consider ", self.avail_modality) labels = lidar_depth output_dict = { "rgb": rgb, "lidar_depth": lidar_depth, "radar_depth": radar_depth, "inputs": inputs, "labels": labels } if self.sparsifier == "radar_filtered": output_dict["radar_depth_filtered"] = radar_depth_filtered if self.sparsifier == "radar_filtered2": output_dict["radar_depth_filtered2"] = radar_depth_filtered2 # For 'index_map' compatibility if 'index_map' in input_data.keys(): output_dict["index_map"] = index_map return output_dict
def transform_train(self, input_data): # import ipdb; ipdb.set_trace() # Fetch the data rgb = np.array(input_data["image"]).astype(np.float32) lidar_depth = np.array(input_data["lidar_depth"]).astype(np.float32) radar_depth = np.array(input_data["radar_depth"]).astype(np.float32) if 'index_map' in input_data.keys(): index_map = np.array(input_data["index_map"]).astype(np.int) # Define augmentation factor scale_factor = np.random.uniform( self.t_cfg.scale_factor_train[0], self.t_cfg.scale_factor_train[1]) # random scaling angle_factor = np.random.uniform( -self.t_cfg.rotation_factor, self.t_cfg.rotation_factor) # random rotation degrees flip_factor = np.random.uniform(0.0, 1.0) < 0.5 # random horizontal flip # Compose customized transform for RGB and Depth separately color_jitter = transforms.ColorJitter(0.2, 0.2, 0.2) resize_image = transforms.Resize(scale_factor, interpolation="bilinear") resize_depth = transforms.Resize(scale_factor, interpolation="nearest") # # First, we uniformly downsample all the images by half # resize_image_initial = transforms.Resize(0.5, interpolation="bilinear") # resize_depth_initial = transforms.Resize(0.5, interpolation="nearest") # Then, we add model-aware resizing if self.transform_mode == "DORN": if cfg.scaling is True: h, w, _ = tuple((np.array(rgb.shape)).astype(np.int32)) else: h, w, _ = tuple((np.array(rgb.shape) * 0.5).astype(np.int32)) # ipdb.set_trace() h_new = self.t_cfg.crop_size_train[0] w_new = w resize_image_method = transforms.Resize([h_new, w_new], interpolation="bilinear") resize_depth_method = transforms.Resize([h_new, w_new], interpolation="nearest") elif self.transform_mode == "sparse-to-dense": h_new = self.t_cfg.crop_size_train[0] w_new = self.t_cfg.crop_size_train[1] resize_image_method = transforms.Resize([h_new, w_new], interpolation="bilinear") resize_depth_method = transforms.Resize([h_new, w_new], interpolation="nearest") # Get the border of random crop h_scaled, w_scaled = math.floor(h_new * scale_factor), math.floor( (w_new * scale_factor)) h_bound, w_bound = h_scaled - self.t_cfg.crop_size_train[ 0], w_scaled - self.t_cfg.crop_size_train[1] h_startpoint = round(np.random.uniform(0, h_bound)) w_startpoint = round(np.random.uniform(0, w_bound)) # Compose the transforms for RGB transform_rgb = transforms.Compose([ transforms.Rotate(angle_factor), resize_image, transforms.Crop(h_startpoint, w_startpoint, self.t_cfg.crop_size_train[0], self.t_cfg.crop_size_train[1]), transforms.HorizontalFlip(flip_factor) ]) # Compose the transforms for Depth transform_depth = transforms.Compose([ transforms.Rotate(angle_factor), resize_depth, transforms.Crop(h_startpoint, w_startpoint, self.t_cfg.crop_size_train[0], self.t_cfg.crop_size_train[1]), transforms.HorizontalFlip(flip_factor) ]) # Perform transform on rgb data # ToDo: whether we need to - imagenet mean here rgb = transform_rgb(rgb) rgb = color_jitter(rgb) rgb = rgb / 255. # Perform transform on lidar depth data lidar_depth /= float(scale_factor) lidar_depth = transform_depth(lidar_depth) rgb = np.array(rgb).astype(np.float32) lidar_depth = np.array(lidar_depth).astype(np.float32) rgb = to_tensor(rgb) lidar_depth = to_tensor(lidar_depth) # Perform transform on radar depth data radar_depth /= float(scale_factor) radar_depth = transform_depth(radar_depth) radar_depth = np.array(radar_depth).astype(np.float32) radar_depth = to_tensor(radar_depth) # Perform transform on index map if 'index_map' in input_data.keys(): index_map = transform_depth(index_map) index_map = np.array(index_map).astype(np.int) index_map = to_tensor(index_map) index_map = index_map.unsqueeze(0) # Normalize rgb using imagenet mean and std # ToDo: only do imagenet normalization on DORN if self.transform_mode == "DORN": rgb = transforms.normalization_imagenet(rgb) if self.sparsifier == "radar_filtered": #################### ## Filtering part ## #################### # Indicating the invalid entries invalid_mask = ~input_data['valid_mask'] invalid_index = np.where(invalid_mask)[0] invalid_index_mask = invalid_index[None, None, ...].transpose(2, 0, 1) # Constructing mask for dense depth dense_mask = torch.ByteTensor( np.sum(index_map.numpy() == invalid_index_mask, axis=0)) radar_depth_filtered = radar_depth.clone() radar_depth_filtered[dense_mask.to(torch.bool)] = 0. radar_depth_filtered = radar_depth_filtered.unsqueeze(0) if self.sparsifier == "radar_filtered2": ###################################### ## Filtering using predicted labels ## ###################################### invalid_mask = ~input_data['pred_labels'] invalid_index = np.where(invalid_mask)[0] invalid_index_mask = invalid_index[None, None, ...].transpose(2, 0, 1) dense_mask = torch.ByteTensor( np.sum(index_map.numpy() == invalid_index_mask, axis=0)) radar_depth_filtered2 = radar_depth.clone() radar_depth_filtered2[dense_mask.to(torch.bool)] = 0. radar_depth_filtered2 = radar_depth_filtered2.unsqueeze(0) ###################################### lidar_depth = lidar_depth.unsqueeze(0) radar_depth = radar_depth.unsqueeze(0) # Return different data for different modality if self.modality == "rgb": inputs = rgb elif self.modality == "rgbd": if self.sparsifier == "radar": # Filter out the the points exceeding max_depth mask = (radar_depth > self.max_depth) radar_depth[mask] = 0 inputs = torch.cat((rgb, radar_depth), dim=0) # Using the generated groundtruth elif self.sparsifier == "radar_filtered": # Filter out the points exceeding max_depth mask = (radar_depth_filtered > self.max_depth) radar_depth_filtered[mask] = 0 inputs = torch.cat((rgb, radar_depth_filtered), dim=0) # Using the learned classifyer elif self.sparsifier == "radar_filtered2": # Filter out the points exceeding max_depth mask = (radar_depth_filtered2 > self.max_depth) radar_depth_filtered2[mask] = 0 inputs = torch.cat((rgb, radar_depth_filtered2), dim=0) else: s_depth = self.get_sparse_depth(lidar_depth, radar_depth) inputs = torch.cat((rgb, s_depth), dim=0) else: raise ValueError("[Error] Unsupported modality. Consider ", self.avail_modality) labels = lidar_depth # Gathering output results output_dict = { "rgb": rgb, "lidar_depth": lidar_depth, "radar_depth": radar_depth, "inputs": inputs, "labels": labels } if self.sparsifier == "radar_filtered": output_dict["radar_depth_filtered"] = radar_depth_filtered if self.sparsifier == "radar_filtered2": output_dict["radar_depth_filtered2"] = radar_depth_filtered2 if 'index_map' in input_data.keys(): output_dict["index_map"] = index_map return output_dict
# trainloader = torch.utils.data.DataLoader(CSDataSet(args.data_dir, './dataset/list/cityscapes/train.lst', max_iters=args.num_steps*args.batch_size, crop_size=(h, w), # scale=args.random_scale, mirror=args.random_mirror, mean=IMG_MEAN), # 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)
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 get_transform(train): transforms = [] transforms.append(T.ToTensor()) if train: transforms.append(T.RandomHorizontalFlip(0.5)) return T.Compose(transforms)
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=f'dlcv_naive_{args.source}2{args.target}') size = 64 t0 = transforms.Compose([ transforms.Resize(size), transforms.ColorJitter(), transforms.RandomRotation(15, fill=(0,)), transforms.Grayscale(3), transforms.ToTensor(), transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5)) ]) 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)) ]) root = '../hw3_data/digits/' # dataset source, target = args.source, args.target train_source_dataset = Digits_Dataset(root+f'{source}/train', source, t0) train_target_dataset = Digits_Dataset(root+f'{target}/train', target, t0)
print("Preprocessing finished!") 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,
type=str, default='cuda:0', help='cpu or cuda:0 or cuda:1') args = parser.parse_args() return args if __name__ == '__main__': args = parse_args() wandb.init(config=args, project='dlcv_face_vae') train_transform = transforms.Compose([ #transforms.RandomHorizontalFlip(), transforms.ToTensor(), ]) valid_transform = transforms.Compose([ transforms.ToTensor(), ]) train_dataset = Face_Dataset('../hw3_data/face/train', train_transform) valid_dataset = Face_Dataset('../hw3_data/face/test', valid_transform) train_dataloader = DataLoader(train_dataset, batch_size=args.batch, shuffle=True, num_workers=8) valid_dataloader = DataLoader(valid_dataset, batch_size=args.batch * 2, shuffle=False,