def init(): data = '../data/target_128' traindir = os.path.join(data, 'train') mean = [0.5, 0.5, 0.5] std = [0.5, 0.5, 0.5] normalize = transforms.Normalize(mean, std) pre_transforms = transforms.Compose([ transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(), transforms.ColorJitter(0.05, 0.05, 0.05, 0.05) ]) post_transforms = transforms.Compose([ transforms.ToTensor(), normalize ]) train_dataset = EasyDR(traindir, pre_transforms, post_transforms, 2) train_loader = DataLoader(train_dataset, batch_size=1, shuffle=True, num_workers=1, drop_last=True, pin_memory=False) unet = generator() unet.load_state_dict(weight_to_cpu('../gan112/epoch_400/g.pkl')) return unet, train_loader
def transforms(): for i in tqdm(glob.glob(os.path.join(opt.train_data_root, '*.bmp'))): uid = uuid.uuid1() profix = "NEG" img = Image.open(i) if 'POS' in i.split('/')[-1]: profix = "POS" p = profix + "-" + str(uid) + "1.bmp" data = T.RandomHorizontalFlip(p=1)(img) data.save(os.path.join("./data/train", p)) p = profix + "-" + str(uid) + "2.bmp" data = T.RandomVerticalFlip(p=1)(img) data.save(os.path.join("./data/train", p)) p = profix + "-" + str(uid) + "3.bmp" data = img.rotate(90) data.save(os.path.join("./data/train", p)) p = profix + "-" + str(uid) + "4.bmp" data = img.rotate(270) data.save(os.path.join("./data/train", p)) p = profix + "-" + str(uid) + "5.bmp" data = T.RandomRotation(90)(img) data.save(os.path.join("./data/train", p)) p = profix + "-" + str(uid) + "6.bmp" data = T.RandomRotation(270)(img) data.save(os.path.join("./data/train", p))
def get_transforms(): tsfm = [] if rcp.transforms.topilimage: tsfm += [transforms.ToPILImage()] if rcp.transforms.randomrotation: tsfm += [transforms.RandomRotation(rcp.transforms.randomrotation)] if rcp.transforms.randomverticalflip: tsfm += [ transforms.RandomVerticalFlip(rcp.transforms.randomverticalflip) ] if rcp.transforms.randomhorizontalflip: tsfm += [ transforms.RandomHorizontalFlip( rcp.transforms.randomhorizontalflip) ] if rcp.transforms.colorjitter: tsfm += [transforms.ColorJitter(**rcp.transforms.colorjitter)] # if rcp.transforms.randomcrop: tsfm += [transforms.RandomCrop(rcp.transforms.randomcrop)] if rcp.transforms.resize: tsfm += [ transforms.Resize((rcp.transforms.resize, rcp.transforms.resize)) ] if rcp.transforms.totensor: tsfm += [transforms.ToTensor()] if rcp.transforms.normalize: tsfm += [transforms.Normalize(**rcp.transforms.normalize)] return transforms.Compose(tsfm)
def get_transforms(pretrained, augmented): if pretrained: # normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], # std=[0.229, 0.224, 0.225]) normalize = transforms.Normalize( mean=[0.723, 0.515, 0.662], # Norm TCGA std=[0.141, 0.156, 0.131]) else: # normalize = transforms.Normalize(mean=[0.7364, 0.5600, 0.7052], # std=[0.229, 0.1584, 0.1330]) normalize = transforms.Normalize( mean=[0.723, 0.515, 0.662], # Norm TCGA std=[0.141, 0.156, 0.131]) if augmented: print('Use Augmentation plus') trans = transforms.Compose([ # transforms.RandomResizedCrop(256), transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(), RandomRotate90(), transforms.ToTensor(), normalize ]) else: trans = transforms.Compose([transforms.ToTensor(), normalize]) return trans
def hard_augment(): hard_augment_ = transforms.Compose([ transforms.RandomHorizontalFlip(p=0.5), transforms.RandomRotation(degrees=(-90, 90)), transforms.RandomVerticalFlip(p=0.5), transforms.ToTensor(), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)), ]) return hard_augment_
def get_transforms(dataset, aug: Union[List, str], cutout: int): if 'imagenet' in dataset: return _get_imagenet_transforms() if dataset == 'cifar10': MEAN = [0.49139968, 0.48215827, 0.44653124] STD = [0.24703233, 0.24348505, 0.26158768] transf = [ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip() ] elif dataset == 'cifar100': MEAN = [0.507, 0.487, 0.441] STD = [0.267, 0.256, 0.276] transf = [ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip() ] elif dataset == 'svhn': MEAN = [0.4914, 0.4822, 0.4465] STD = [0.2023, 0.1994, 0.20100] transf = [ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip() ] elif dataset == 'mnist': MEAN = [0.13066051707548254] STD = [0.30810780244715075] transf = [ transforms.RandomAffine(degrees=15, translate=(0.1, 0.1), scale=(0.9, 1.1), shear=0.1) ] elif dataset == 'fashionmnist': MEAN = [0.28604063146254594] STD = [0.35302426207299326] transf = [ transforms.RandomAffine(degrees=15, translate=(0.1, 0.1), scale=(0.9, 1.1), shear=0.1), transforms.RandomVerticalFlip() ] else: raise ValueError('dataset not recognized: {}'.format(dataset)) normalize = [transforms.ToTensor(), transforms.Normalize(MEAN, STD)] train_transform = transforms.Compose(transf + normalize) test_transform = transforms.Compose(normalize) # add additional aug and cutout transformations _add_augs(train_transform, aug, cutout) return train_transform, test_transform
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/weighted_sampler/' 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.trainbag = RuijinBags(self.root, [0,1,2,3],self.train_transform) self.testbag = RuijinBags(self.root, [4], self.test_transform) 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, sampler=self.train_sampler) 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_batch1(self.net, self.optimizer, self.lrsch, None, self.train_loader, self.val_loader, self.logger, self.global_step)
def __init__(self, resize_to=(224, 224)): list_of_transforms = [ transforms.RandomVerticalFlip(), transforms.RandomRotation(degrees=(-180, 180)), transforms.Resize(size=resize_to), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ] self.transform = transforms.Compose(list_of_transforms)
def get_train_trans(SIZE): return transforms.Compose([ transforms.Resize((SIZE, SIZE)), transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(), transforms.RandomRotation(5), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ])
def medium_augment(): medium_augment_ = transforms.Compose([ transforms.CenterCrop((100, 100)), transforms.RandomCrop((80, 80)), transforms.RandomHorizontalFlip(p=0.5), transforms.RandomRotation(degrees=(-90, 90)), transforms.RandomVerticalFlip(p=0.5), transforms.ToTensor(), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)), ]) return medium_augment_
def eyetransfrom(imsize=224): eyetrans = transforms.Compose([ transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(), transforms.RandomRotation(degrees=(0, 360)), transforms.Resize(imsize), transforms.CenterCrop(imsize), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) return eyetrans
def get_transforms(self) -> tuple: MEAN = [0.28604063146254594] STD = [0.35302426207299326] transf = [ transforms.RandomAffine(degrees=15, translate=(0.1, 0.1), scale=(0.9, 1.1), shear=0.1), transforms.RandomVerticalFlip() ] normalize = [transforms.ToTensor(), transforms.Normalize(MEAN, STD)] train_transform = transforms.Compose(transf + normalize) test_transform = transforms.Compose(normalize) return train_transform, test_transform
def __init__(self, data_dir, batch_size, labeled_percents=20): self.mean = [0.485, 0.456, 0.406] self.std = [0.229, 0.224, 0.225] self.train_path = os.path.join(data_dir, "train") self.classes = [] for d in os.listdir(self.train_path): if ".txt" not in d: self.classes.append(d) self.transform = T.Compose([ T.Resize((128, 128), interpolation=2), T.RandomRotation(45), T.RandomVerticalFlip(), T.RandomGrayscale(), T.RandomSizedCrop((112, 112)), T.ToTensor(), T.Normalize(self.mean, self.std) ]) self.paths = [] self.true_labels = [] self.true_idxs = [] self.relabeled = [] self.labeled_idxs = [] self.unlabeled_idxs = [] ck = 0 last_cls = None for i, c in enumerate(self.classes): for file in list( glob.glob( os.path.join(self.train_path, os.path.join(c, "*.*")))): self.paths.append(file) self.true_labels.append(c) self.true_idxs.append(i) self.relabeled.append(i) unlabeled_limit = int( (len(self.true_idxs) - ck) * labeled_percents) for idx in range(ck, ck + unlabeled_limit): self.relabeled[idx] = NO_LABEL # collect indexes of labels both labeled and unlabeled for i, l in enumerate(self.relabeled): if l == -1: self.unlabeled_idxs.append(i) else: self.labeled_idxs.append(i)
def __init__( self, resize: int = 64, do_online_transform: bool = False, transform_before: Optional[Callable] = None, transform_after: Optional[Callable] = None, prob_random_horizontal_flip: float = 0.5, prob_random_vertical_flip: float = 0.5, min_scale_resize: float = 0.5, max_scale_resize: float = 1.0, # degree_random_rotation: float = 90, # prob_random_rotation: float = 0.5, ) -> None: self.resize = resize self.do_online_transform = do_online_transform self.transform_before = transform_before self.transform_after = transform_after self.prob_random_horizontal_flip = prob_random_horizontal_flip self.prob_random_vertical_flip = prob_random_vertical_flip self.min_scale_resize = min_scale_resize self.max_scale_resize = max_scale_resize # self.degree_random_rotation = degree_random_rotation # self.prob_random_rotation = prob_random_rotation _transforms = [ # transforms.RandomApply([transforms.RandomRotation(self.degree_random_rotation)], self.prob_random_rotation), transforms.RandomResizedCrop(self.resize, scale=(min_scale_resize, max_scale_resize)), transforms.RandomHorizontalFlip(prob_random_horizontal_flip), transforms.RandomVerticalFlip(prob_random_vertical_flip), ] _online_transforms = [transforms.Resize(self.resize)] if transform_before is not None: _transforms.insert(0, transform_before) _online_transforms.insert(0, transform_before) if transform_after is not None: _transforms.append(transform_after) _online_transforms.append(transform_after) self.train_transform = transforms.Compose(_transforms) self.online_transform = transforms.Compose(_online_transforms)
def build_data_loader(self): if self.train_set: transform = transforms.Compose([ transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(), transforms.ToTensor() ]) else: transform = transforms.ToTensor() cifar10_dtst = CIFAR10(root='data', download=True, train=self.train_set, transform=transform) cifar10_dl = data.DataLoader(cifar10_dtst, batch_size=self.batch_size, shuffle=True, num_workers=self.num_workers) return cifar10_dl
def build_transforms(cfg, split="train"): if split=="train": min_size = min(cfg.EXTERNAL.IMAGE.HEIGHT,cfg.EXTERNAL.IMAGE.WIDTH) max_size = max(cfg.EXTERNAL.IMAGE.HEIGHT,cfg.EXTERNAL.IMAGE.WIDTH) flip_horizontal_prob = 0.5 # cfg.INPUT.FLIP_PROB_TRAIN flip_vertical_prob = cfg.INPUT.VERTICAL_FLIP_PROB_TRAIN brightness = cfg.INPUT.BRIGHTNESS contrast = cfg.INPUT.CONTRAST saturation = cfg.INPUT.SATURATION hue = cfg.INPUT.HUE else: min_size = min(cfg.EXTERNAL.IMAGE.HEIGHT, cfg.EXTERNAL.IMAGE.WIDTH) max_size = max(cfg.EXTERNAL.IMAGE.HEIGHT, cfg.EXTERNAL.IMAGE.WIDTH) flip_horizontal_prob = 0.0 flip_vertical_prob = 0.0 brightness = 0.0 contrast = 0.0 saturation = 0.0 hue = 0.0 to_bgr255 = cfg.INPUT.TO_BGR255 normalize_transform = T.Normalize( mean=cfg.INPUT.PIXEL_MEAN, std=cfg.INPUT.PIXEL_STD, ) color_jitter = T.ColorJitter( brightness=brightness, contrast=contrast, saturation=saturation, hue=hue, ) transform = T.Compose( [ color_jitter, T.Resize(min_size, max_size), T.RandomHorizontalFlip(flip_horizontal_prob), T.RandomVerticalFlip(flip_vertical_prob), T.ToTensor(), normalize_transform, ] ) return transform
def get_transforms(opt): """ Return Composed torchvision transforms based on specified arguments. """ transforms_list = [] if "none" in opt.input_transforms: return every = "all" in opt.input_transforms if every or "vflip" in opt.input_transforms: transforms_list.append(transforms.RandomVerticalFlip()) if every or "hflip" in opt.input_transforms: transforms_list.append(transforms.RandomHorizontalFlip()) if every or "affine" in opt.input_transforms: transforms_list.append( transforms.RandomAffine( degrees=10, translate=(0.1, 0.1), scale=(0.8, 1.2), shear=20 ) ) if every or "perspective" in opt.input_transforms: transforms_list.append(transforms.RandomPerspective()) return transforms.RandomOrder(transforms_list)
def data_transformation(data_type, plot=False): train = [ transforms.Resize((224, 224)), transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip() ] validation = [ transforms.Resize((224, 224)) ] if not plot: train.append(transforms.ToTensor()) train.append(transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])) validation.append(transforms.ToTensor()) validation.append(transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])) transformation = { 'training': transforms.Compose(train), 'validation': transforms.Compose(validation) } return transformation[data_type]
def RandomVerticalFlip(self, **args): return self._add(transforms.RandomVerticalFlip(**args))
def train(): transform_train = transforms.Compose([ # transforms.Normalize(0.41,2), transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(), # 给数据集加随机噪声 transforms.ToTensor(), # transforms.Lambda(lambda x: x + torch.randn(3,128, 128)) ]) trainset = datasets.ImageFolder(args.train_root, transform=transform_train) train_loader = DataLoader(dataset=trainset, batch_size=args.batch_size, shuffle=True) encoder, decoder = Encoder(args), Decoder(args) criterion = nn.MSELoss() encoder.train() decoder.train() if torch.cuda.is_available(): encoder, decoder = encoder.cuda(), decoder.cuda() one = torch.Tensor([1]) mone = one * -1 if torch.cuda.is_available(): one = one.cuda() mone = mone.cuda() # Optimizers enc_optim = optim.Adam(encoder.parameters(), lr=args.lr) dec_optim = optim.Adam(decoder.parameters(), lr=args.lr) enc_scheduler = StepLR(enc_optim, step_size=30, gamma=0.5) dec_scheduler = StepLR(dec_optim, step_size=30, gamma=0.5) for epoch in range(args.epochs): step = 0 for (images, _) in train_loader: if torch.cuda.is_available(): images = images.cuda() enc_optim.zero_grad() dec_optim.zero_grad() # ======== Train Generator ======== # batch_size = images.size()[0] z = encoder(images) x_recon = decoder(z) recon_loss = criterion(x_recon, images) # ======== MMD Kernel Loss ======== # z_fake = Variable( torch.randn(images.size()[0], args.n_z) * args.sigma) if torch.cuda.is_available(): z_fake = z_fake.cuda() z_real = encoder(images) mmd_loss = imq_kernel(z_real, z_fake, h_dim=encoder.n_z) mmd_loss = mmd_loss.mean() total_loss = recon_loss - mmd_loss total_loss.backward() enc_optim.step() dec_optim.step() step += 1 if (step + 1) % 10 == 0: print( "Epoch: [%d/%d], Step: [%d/%d], Reconstruction Loss: %.4f" % (epoch + 1, args.epochs, step + 1, len(train_loader), recon_loss.data.item())) save_model(encoder, decoder, args.model)
torch.set_default_tensor_type(torch.FloatTensor) device = torch.device("cpu") transform = dict() mean = [ 0.054813755064775954, 0.0808928726780973, 0.08367144133595689, 0.05226083561943362 ] std = [ 0.15201123862047256, 0.14087982537762958, 0.139965362113942, 0.10123220339551285 ] transform['train'] = transforms.Compose([ transforms.RandomResizedCrop(512), transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(), transforms.RandomRotation(20), transforms.ToTensor(), transforms.Normalize(mean, std) ]) transform['val'] = transforms.Compose( [transforms.ToTensor(), transforms.Normalize(mean, std)]) class ProteinDataset(torch.utils.data.Dataset): def __init__(self, root, phase, image_labels=None, size=None,
def __init__(self, shape_paths, num_input_views, num_output_views, x_bound=(-0.5, 0.5), y_bound=None, z_bound=(1.5, 3), size_jitter=(0.5, 1.0), color_noise_level=0.0, depth_noise_level=0.0, mask_noise_p=0.0, min_lights=3, max_lights=8, width=640, height=480, device_id=0, camera_angle_min=0.0, camera_angle_max=math.pi / 2.0, camera_angle_spread=math.pi / 12.0, camera_translation_noise=0.0, camera_rotation_noise=0.0, color_background_dir=None, depth_background_dir=None, textures_dir=None, use_textures=False, random_materials=False, color_random_background=False, depth_random_background=False, use_spiral_outputs=False, use_constrained_cameras=False, disk_sample_cameras=False, use_model_materials=False, obj_default_pose=OBJ_DEFAULT_POSE): self.width = width self.height = height if not y_bound: y_bound = (x_bound[0] / self.width * self.height, x_bound[1] / self.width * self.height) self.x_bound = x_bound self.y_bound = y_bound self.z_bound = z_bound self.size_jitter = size_jitter self.min_lights = min_lights self.max_lights = max_lights self.color_noise_level = color_noise_level self.depth_noise_level = depth_noise_level self.mask_noise_p = mask_noise_p self.color_random_background = color_random_background self.depth_random_background = depth_random_background self.random_materials = random_materials self.num_inputs = num_input_views self.num_outputs = num_output_views self.use_spiral_outputs = use_spiral_outputs self.use_constrained_cameras = use_constrained_cameras self.disk_sample_cameras = disk_sample_cameras self.camera_angle_min = camera_angle_min self.camera_angle_max = camera_angle_max self.camera_angle_spread = camera_angle_spread self.camera_translation_noise = camera_translation_noise self.camera_rotation_noise = camera_rotation_noise # Object poses will be pre-rotated to this pose. self.obj_default_pose = obj_default_pose self.shape_paths = shape_paths self.roughness_values = _load_roughness_values() self.use_model_materials = use_model_materials self.use_textures = use_textures if use_textures: self.textures_dir = Path(textures_dir) logger.info("indexing textures", path=self.textures_dir) self.texture_paths = _index_paths(self.textures_dir, ext='.jpg') else: self.textures_dir = None self.texture_paths = [] if self.color_random_background and color_background_dir: self.color_background_dir = Path(color_background_dir) logger.info("indexing color backgrounds", path=self.color_background_dir) self.color_background_paths = _index_paths(self.color_background_dir, ext='.jpg') else: self.color_background_dir = None self.color_background_paths = [] if self.depth_random_background and depth_background_dir: self.depth_background_dir = Path(depth_background_dir) logger.info("indexing depth backgrounds", path=self.depth_background_dir) self.depth_background_paths = _index_paths(self.depth_background_dir, ext='.png', index_name='depth_paths.txt') else: self.depth_background_dir = None self.depth_background_paths = [] logger.info("dataset indexed", num_shapes=len(self.shape_paths), num_textures=len(self.texture_paths), num_color_backgrounds=len(self.color_background_paths), num_depth_backgrounds=len(self.depth_background_paths)) self._color_transform = transforms.Compose([ transforms.ToPILImage(), transforms.ColorJitter(0.1, 0.1, 0.05, 0.05), transforms.ToTensor(), ]) self._mask_transform = transforms.Compose([ # augment.masks.RandomMorphologicalTransform(p=0.5), # augment.masks.RandomTranslation(p=0.3), # augment.masks.RandomRotation(p=0.3), augment.masks.RandomAdd(p=0.15), augment.masks.RandomCut(p=0.05), augment.masks.RandomEllipses(p=0.2), ]) self._color_bg_transform = transforms.Compose([ transforms.ToPILImage(), transforms.ColorJitter(0.2, 0.2, 0.1, 0.1), transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(), transforms.RandomCrop((480, 640), pad_if_needed=True, padding_mode='reflect'), transforms.ToTensor(), ]) self._depth_bg_transform = transforms.Compose([ augment.tensors.TensorRandomHorizontalFlip(), augment.tensors.TensorRandomVerticalFlip(), augment.tensors.TensorRandomCrop((480, 640), pad_if_needed=True, padding_mode='reflect'), ]) self._renderer = None self._worker_id = None self._log = None self.device_id = device_id set_egl_device(device_id)
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/code_results' if not os.path.exists(self.log_dir): os.mkdir(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.RandomResizedCrop(224), transforms.ColorJitter(brightness = 0.25), 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.trainbag = RuijinBags(self.root, [0,1,2,3],self.test_transform) self.testbag = RuijinBags(self.root, [4], self.test_transform) # patient bags #self.trainbag = PatientBags(self.data_root+'/train', self.train_transform) #self.testbag = PatientBags(self.data_root+'/test', self.test_transform) ''' # random self.train_set = BMDataset(self.data_root+'/train',self.train_transform) self.test_set = BMDataset(self.data_root+'/test',self.test_transform) self.trainbag = BMBags(dataset=self.train_set) self.testbag = BMBags(dataset=self.test_set) ''' #self.train_loader = DataLoader(self.trainbag, batch_size=1, shuffle=True, num_workers=8) #self.val_loader = DataLoader(self.testbag, batch_size=1, shuffle=False, num_workers=8) self.train_loader = DataLoader(self.trainbag, batch_size=4, collate_fn = my_collate, shuffle=True, num_workers=8) #print (len(self.train_loader)) self.val_loader = DataLoader(self.testbag, batch_size=4, collate_fn = my_collate, 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)
def train(cfg, step): # 设置保存目录 model_save_dir = os.path.join(cfg["output_dir"], "weights" + step) if not os.path.exists(model_save_dir): os.makedirs(model_save_dir) history_save_dir = os.path.join(cfg["output_dir"], "visual" + step) if not os.path.exists(history_save_dir): os.makedirs(history_save_dir) # time_mark = '2020_03_06_' # 以当前时间作为保存的文件名标识 time_mark = time.strftime('%Y_%m_%d_', time.localtime(time.time())) file_path = os.path.join(model_save_dir, time_mark + "epoch_{epoch}-model_weights.pth") history_path = os.path.join(history_save_dir, time_mark + "result.csv") callbacks_s = call_backs(file_path, history_path) # 加载数据集 train_dataset = ImageSelectFolder( root=cfg["train_dataset"], label=cfg["label"], select_condition=cfg["train_select"], data_expansion=True, transform=transforms.Compose([ transforms.RandomApply( [ transforms.RandomCrop(size=(448, 448)), # transforms.RandomResizedCrop(size=cfg["img_width"]), ], p=0.3), transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2), transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(), transforms.RandomRotation(360), transforms.Resize((cfg["img_width"], cfg["img_hight"])), transforms.ToTensor(), transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)) ])) val_dataset = ImageSelectFolder( root=cfg["val_dataset"], label=cfg["label"], select_condition=cfg["val_select"], transform=transforms.Compose([ transforms.Resize((cfg["img_hight"], cfg["img_width"])), transforms.ToTensor(), transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)) ])) train_dataload = DataLoader(dataset=train_dataset, batch_size=cfg["batch_size"], shuffle=True) val_dataload = DataLoader(dataset=val_dataset, batch_size=cfg["batch_size"], shuffle=False) model = get_model(model_weight_path=cfg["model_weight_path"], model_name=cfg["model_name"], out_features=cfg["num_classes"], img_width=cfg["img_width"], img_hight=cfg["img_hight"], verbose=False) model.cuda() loss_function = nn.CrossEntropyLoss().cuda() optimizer = optim.Adam(model.parameters(), lr=cfg["lr"], weight_decay=1e-4) fit_generator = TrainFitGenerator(net=model, optimizer=optimizer, loss_function=loss_function, generator=train_dataload, epochs=cfg["nepochs"], validation_data=val_dataload, callbacks=callbacks_s) fit_generator.run() plot_training_metrics(fit_generator.history, history_save_dir, "loss", title=f"train and validation loss", is_show=False) plot_training_metrics(fit_generator.history, history_save_dir, "acc", title=f"train and validation accuracy", is_show=False)
def main(cfg, step): model_save_dir = os.path.join(cfg["output_dir"], "weights" + step) if not os.path.exists(model_save_dir): os.makedirs(model_save_dir) history_save_dir = os.path.join(cfg["output_dir"], "visual" + step) if not os.path.exists(history_save_dir): os.makedirs(history_save_dir) # time_mark = '2020_03_06_' # 以当前时间作为保存的文件名标识 time_mark = time.strftime('%Y_%m_%d_', time.localtime(time.time())) file_path = os.path.join(model_save_dir, time_mark + "epoch_{epoch}-model_weights.pth") history_path = os.path.join(history_save_dir, time_mark + "result.csv") callbacks_s = call_backs(file_path, history_path) train_dataset = ImageSelectFolder( root=cfg["train_dataset"], label=cfg["label"], select_condition=cfg["train_select"], data_expansion=True, transform=transforms.Compose([ transforms.RandomApply( [ transforms.RandomCrop(size=(448, 448)), # transforms.RandomResizedCrop(size=cfg["img_width"]), ], p=0.3), transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2), transforms.RandomHorizontalFlip(), transforms.RandomVerticalFlip(), transforms.RandomRotation(360), transforms.Resize((cfg["img_width"], cfg["img_hight"])), transforms.ToTensor(), transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)) ])) val_dataset = ImageSelectFolder( root=cfg["val_dataset"], label=cfg["label"], select_condition=cfg["val_select"], transform=transforms.Compose([ transforms.Resize((cfg["img_width"], cfg["img_hight"])), transforms.ToTensor(), transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)) ])) train_dataload = DataLoader(dataset=train_dataset, batch_size=cfg["batch_size"], shuffle=True) val_dataload = DataLoader(dataset=val_dataset, batch_size=cfg["batch_size"], shuffle=False) model = get_model(model_weight_path=cfg["model_weight_path"], model_name=cfg["model_name"], out_features=cfg["num_classes"], img_width=cfg["img_width"], img_hight=cfg["img_hight"], verbose=True) model.cuda() loss_function = nn.CrossEntropyLoss().cuda() # 定义额外的评价指标 recall = GetRecallScore(average="micro") precision = GetPrecisionScore(average="micro") f1 = GetF1Score(average="micro") metrics = {"recall": recall, "precision": precision, "f1 score": f1} train_transfer_learning(model, loss_function, train_dataload, val_dataload, cfg["tl_lr"], epochs=3, metrics=metrics) trrain_fine_tuning(model, loss_function, train_dataload, val_dataload, history_save_dir, lr=cfg["ft_lr"], epochs=cfg["nepochs"], callbacks=callbacks_s, metrics=metrics) del model
import torchvision.transforms.transforms as transforms from torchvision.datasets import CocoDetection from torch.utils.data import DataLoader import numpy as np # https://discuss.pytorch.org/t/how-to-efficiently-load-coco-dataset-to-dataloader/103380/5 # define pytorch transforms transform1 = transforms.Compose([ transforms.ToPILImage(), transforms.Resize((300, 300)), transforms.CenterCrop((100, 100)), transforms.RandomCrop((80, 80)), transforms.RandomHorizontalFlip(p=0.5), transforms.RandomRotation(degrees=(-90, 90)), transforms.RandomVerticalFlip(p=0.5), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ]) transform = transforms.Compose([ transforms.Resize((300, 300)), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) class ToYolo(torch.nn.Module): def __init__(self, x): super(ToYolo, self).__init__() self.x = x
def main(): # Create arg parser parser = argparse.ArgumentParser() parser = TopologyVAE.add_model_specific_args(parser) parser = WeightedNumpyDataset.add_model_specific_args(parser) parser = utils.DataWeighter.add_weight_args(parser) utils.add_default_trainer_args(parser, default_root="") parser.add_argument( "--augment_dataset", action='store_true', help="Use data augmentation or not", ) parser.add_argument( "--use_binary_data", action='store_true', help="Binarize images in the dataset", ) # Parse arguments hparams = parser.parse_args() hparams.root_dir = topology_get_path( k=hparams.rank_weight_k, n_max_epochs=hparams.max_epochs, predict_target=hparams.predict_target, hdims=hparams.target_predictor_hdims, metric_loss=hparams.metric_loss, metric_loss_kw=hparams.metric_loss_kw, beta_target_pred_loss=hparams.beta_target_pred_loss, beta_metric_loss=hparams.beta_metric_loss, latent_dim=hparams.latent_dim, beta_final=hparams.beta_final, use_binary_data=hparams.use_binary_data) print_flush(' '.join(sys.argv[1:])) print_flush(hparams.root_dir) pl.seed_everything(hparams.seed) # Create data if hparams.use_binary_data: if not os.path.exists( os.path.join(get_data_root(), 'topology_data/target_bin.npy')): gen_binary_dataset_from_all_files(get_data_root()) hparams.dataset_path = os.path.join(ROOT_PROJECT, get_topology_binary_dataset_path()) else: if not os.path.exists( os.path.join(get_data_root(), 'topology_data/target.npy')): gen_dataset_from_all_files(get_data_root()) hparams.dataset_path = os.path.join(ROOT_PROJECT, get_topology_dataset_path()) if hparams.augment_dataset: aug = transforms.Compose([ # transforms.Normalize(mean=, std=), # transforms.RandomCrop(30, padding=10), transforms.RandomRotation(45), transforms.RandomRotation(90), transforms.RandomRotation(180), transforms.RandomVerticalFlip(0.5) ]) else: aug = None datamodule = WeightedNumpyDataset(hparams, utils.DataWeighter(hparams), transform=aug) # Load model model = TopologyVAE(hparams) checkpoint_callback = pl.callbacks.ModelCheckpoint(period=max( 1, hparams.max_epochs // 10), monitor="loss/val", save_top_k=-1, save_last=True, mode='min') if hparams.load_from_checkpoint is not None: model = TopologyVAE.load_from_checkpoint(hparams.load_from_checkpoint) utils.update_hparams(hparams, model) trainer = pl.Trainer( gpus=[hparams.cuda] if hparams.cuda else 0, default_root_dir=hparams.root_dir, max_epochs=hparams.max_epochs, callbacks=[ checkpoint_callback, LearningRateMonitor(logging_interval='step') ], resume_from_checkpoint=hparams.load_from_checkpoint) print(f'Load from checkpoint') else: # Main trainer trainer = pl.Trainer( gpus=[hparams.cuda] if hparams.cuda is not None else 0, default_root_dir=hparams.root_dir, max_epochs=hparams.max_epochs, checkpoint_callback=True, callbacks=[ checkpoint_callback, LearningRateMonitor(logging_interval='step') ], terminate_on_nan=True, progress_bar_refresh_rate=5, # gradient_clip_val=20.0, ) # Fit trainer.fit(model, datamodule=datamodule) print( f"Training finished; end of script: rename {checkpoint_callback.best_model_path}" ) shutil.copyfile( checkpoint_callback.best_model_path, os.path.join(os.path.dirname(checkpoint_callback.best_model_path), 'best.ckpt'))