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'))
