def get_simclr_pipeline_transform(size, s=1, num_aug=5):
"""Return a set of data augmentation transformations as described in the SimCLR paper."""
color_jitter = transforms.ColorJitter(0.8 * s, 0.8 * s, 0.8 * s,
0.2 * s)
if num_aug == 5:
data_transforms = transforms.Compose([
transforms.RandomResizedCrop(size=size),
transforms.RandomHorizontalFlip(),
transforms.RandomApply([color_jitter], p=0.8),
transforms.RandomGrayscale(p=0.2),
GaussianBlur(kernel_size=int(0.1 * size)),
transforms.ToTensor()
])
elif num_aug == 7:
data_transforms = transforms.Compose([
transforms.RandomResizedCrop(size=size),
transforms.RandomHorizontalFlip(),
transforms.RandomApply([color_jitter], p=0.8),
transforms.RandomGrayscale(p=0.2),
GaussianBlur(kernel_size=int(0.1 * size)),
transforms.RandomRotation(degrees=45),
transforms.RandomAffine(degrees=45),
transforms.ToTensor()
])
return data_transforms
def get_query_transforms(image_set):
if image_set == 'train':
# SimCLR style augmentation
return transforms.Compose([
transforms.Resize((128, 128)),
transforms.RandomApply(
[
transforms.ColorJitter(0.4, 0.4, 0.4,
0.1) # not strengthened
],
p=0.8),
transforms.RandomGrayscale(p=0.2),
transforms.RandomApply([GaussianBlur([.1, 2.])], p=0.5),
transforms.ToTensor(),
# transforms.RandomHorizontalFlip(), HorizontalFlip may cause the pretext too difficult, so we remove it
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
if image_set == 'val':
return transforms.Compose([
transforms.Resize((128, 128)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
raise ValueError(f'unknown {image_set}')
def get_simclr_data_transforms_train(dataset_name):
if dataset_name == "stl10":
input_shape = (96, 96, 3)
s = 1
# get a set of data augmentation transformations as described in the SimCLR paper.
color_jitter = transforms.ColorJitter(0.8 * s, 0.8 * s, 0.8 * s,
0.2 * s)
return transforms.Compose([
transforms.RandomResizedCrop(size=input_shape[0]),
transforms.RandomHorizontalFlip(),
transforms.RandomApply([color_jitter], p=0.8),
transforms.RandomGrayscale(p=0.2),
GaussianBlur(kernel_size=int(0.1 * input_shape[0])),
transforms.ToTensor()
])
elif dataset_name == "cifar10":
return transforms.Compose([
transforms.RandomResizedCrop(32),
transforms.RandomHorizontalFlip(p=0.5),
transforms.RandomApply(
[transforms.ColorJitter(0.4, 0.4, 0.4, 0.1)], p=0.8),
transforms.RandomGrayscale(p=0.2),
transforms.ToTensor(),
transforms.Normalize([0.4914, 0.4822, 0.4465],
[0.2023, 0.1994, 0.2010])
])
else:
raise RuntimeError(f"unknown dataset: {dataset_name}")
def __init__(self):
self.transform = transforms.Compose([
transforms.RandomResizedCrop(224, interpolation=Image.BICUBIC),
transforms.RandomHorizontalFlip(p=0.5),
transforms.RandomApply([
transforms.ColorJitter(
brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1)
],
p=0.8),
transforms.RandomGrayscale(p=0.2),
GaussianBlur(p=1.0),
Solarization(p=0.0),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
self.transform_prime = transforms.Compose([
transforms.RandomResizedCrop(224, interpolation=Image.BICUBIC),
transforms.RandomHorizontalFlip(p=0.5),
transforms.RandomApply([
transforms.ColorJitter(
brightness=0.4, contrast=0.4, saturation=0.2, hue=0.1)
],
p=0.8),
transforms.RandomGrayscale(p=0.2),
GaussianBlur(p=0.1),
Solarization(p=0.2),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
def get_simclr_data_transforms(input_shape, s=1, blur=0.1):
# get a set of data augmentation transformations as described in the SimCLR paper.
color_jitter = transforms.ColorJitter(0.8 * s, 0.8 * s, 0.8 * s, 0.2 * s)
data_transforms = transforms.Compose([
transforms.RandomResizedCrop(size=eval(input_shape)[0]),
transforms.RandomHorizontalFlip(),
transforms.RandomApply([color_jitter], p=0.8),
transforms.RandomGrayscale(p=0.2),
transforms.RandomApply(
[GaussianBlur(kernel_size=int(0.1 * eval(input_shape)[0]))],
p=blur),
transforms.ToTensor()
])
return data_transforms
def __init__(self, hparams):
super().__init__()
self.data_dir = hparams["data_dir"] + "/snake_dataset/train"
self.batch_size = hparams.get("batch_size") or 64
self.train_val_split_ratio = hparams.get("train_val_split_ratio") or 0.9
self.num_workers = hparams.get("num_workers") or 1
self.pin_memory = hparams.get("pin_memory") or False
img_augmentation_transformations = [
# transforms.RandomAffine((-15, 15), translate=(0.2, 0.2)),
transforms.RandomHorizontalFlip(p=1.0),
transforms.RandomRotation((-15, 15)),
transforms.ColorJitter(hue=.05, saturation=.05),
]
self.transforms = transforms.Compose([
transforms.Resize((112, 112)),
transforms.ToTensor(),
transforms.RandomApply(img_augmentation_transformations, 0.5),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
])
self.data_train = None
self.data_val = None
def get_simclr_data_transforms2(input_shape, s=1., blur=0.1):
# get a set of data augmentation transformations as described in the SimCLR paper.
color_jitter = transforms.ColorJitter(0.8 * s, 0.8 * s, 0.8 * s, 0.2 * s)
data_transforms = transforms.Compose([
transforms.RandomResizedCrop(size=eval(input_shape)[0]),
transforms.RandomHorizontalFlip(),
transforms.RandomApply([color_jitter], p=0.5),
transforms.ToTensor()
])
return data_transforms
def Transforms(Input_Dim, S=1):
Color_Jitter = transforms.ColorJitter(0.8 * S, 0.8 * S, 0.8 * S, 0.2 * S)
Data_Transforms = transforms.Compose([
transforms.RandomResizedCrop(size=Input_Dim[0]),
transforms.RandomHorizontalFlip(),
transforms.RandomApply([Color_Jitter], p=0.75),
transforms.RandomGrayscale(p=0.2),
GaussianBlur(int(0.1 * Input_Dim[0])),
transforms.ToTensor(),
])
return Data_Transforms
def get_simclr_transform(size, s=1):
"""Return a set of data augmentation transformations as described in the SimCLR paper."""
color_jitter = transforms.ColorJitter(0.1 * s, 0.8 * s, 0.2 * s, 0 * s)
data_transforms = transforms.Compose(
[ #transforms.RandomResizedCrop(size=size),
transforms.RandomHorizontalFlip(),
transforms.RandomApply([color_jitter], p=1),
transforms.RandomGrayscale(p=0.2),
GaussianBlur(kernel_size=int(0.1 * size)),
transforms.ToTensor()
])
return data_transforms
def get_simclr_pipeline_transform(size, s=1):
"""transforms can be improved to match well with SimCLR paper. this doesnt seem to be exactly what paper says. can try more transforms as well"""
color_jitter = transforms.ColorJitter(0.8 * s, 0.8 * s, 0.8 * s,
0.2 * s) #
data_transforms = transforms.Compose([
transforms.RandomResizedCrop(size=size),
transforms.RandomHorizontalFlip(),
transforms.RandomApply([color_jitter], p=0.8),
transforms.RandomGrayscale(p=0.2),
GaussianBlur(kernel_size=int(0.1 * size)),
transforms.ToTensor()
])
return data_transforms
def get_simclr_transform(size, s=1):
"""Return a set of data augmentation transformations as described in the SimCLR paper."""
color_jitter = transforms.ColorJitter(0.8 * s, 0.8 * s, 0.8 * s, 0.2 * s)
data_transforms = transforms.Compose([
transforms.Resize(size=size),
transforms.RandomHorizontalFlip(),
transforms.RandomApply([color_jitter], p=0.8),
transforms.RandomGrayscale(p=0.2),
GaussianBlur(kernel_size=int(0.1 * size)),
transforms.ToTensor(),
transforms.Normalize(mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225))
])
return data_transforms
def get_simclr_pipeline_transform(size, s=1):
"""
Returns a set of data augmentation transformations
"""
color_jitter = transforms.ColorJitter(0.8 * s, 0.8 * s, 0.8 * s,
0.2 * s)
data_transforms = transforms.Compose([
transforms.RandomResizedCrop(size),
transforms.RandomHorizontalFlip(),
transforms.RandomApply([color_jitter], p=0.8),
transforms.RandomGrayscale(p=0.2),
GaussianBlur(kernel_size=int(0.1 * size)),
transforms.ToTensor(),
])
return data_transforms
def get_simclr_data_transforms(input_shape, s=1):
# get a set of data augmentation transformations as described in the SimCLR paper.
normalize = transforms.Normalize(mean=(0.4914, 0.4822, 0.4465),
std=(0.2023, 0.1994, 0.2010))
color_jitter = transforms.ColorJitter(0.8 * s, 0.8 * s, 0.8 * s, 0.2 * s)
data_transforms = transforms.Compose([
transforms.RandomResizedCrop(size=eval(input_shape)[0],
scale=(0.2, 1.)),
transforms.RandomHorizontalFlip(),
transforms.RandomApply([color_jitter], p=0.8),
transforms.RandomGrayscale(p=0.2),
#GaussianBlur(kernel_size=int(0.1 * eval(input_shape)[0])),
transforms.ToTensor(),
normalize
])
return data_transforms
def get_transforms(size):
base_transforms = transforms.Compose([transforms.Resize(size)])
additional_transforms = transforms.Compose([
transforms.RandomHorizontalFlip(p=0.5),
# transforms.RandomApply([transforms.RandomRotation(degrees=5)], p=0.5),
transforms.RandomChoice(
[transforms.CenterCrop(size),
transforms.RandomCrop(size)]),
transforms.RandomApply([
transforms.ColorJitter(
brightness=0.2, contrast=(0.9, 1.2), saturation=0.3, hue=0.01)
],
p=0.5),
transforms.ToTensor(),
# transforms.Normalize(means, stds),
Rescale(),
])
return base_transforms, additional_transforms
def get_faa_transforms_cifar_10(randomcrop=False, gauss=False):
if randomcrop:
random_crop = transforms.RandomCrop(32, padding=4)
else:
random_crop = transforms.RandomResizedCrop(28, scale=(0.2, 1.))
if not gauss:
transform_train = transforms.Compose([
random_crop,
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(_CIFAR_MEAN, _CIFAR_STD),
])
else:
transform_train = transforms.Compose([
random_crop,
transforms.RandomApply([moco.loader.GaussianBlur([.1, 2.])], p=0.5),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(_CIFAR_MEAN, _CIFAR_STD),
])
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(_CIFAR_MEAN, _CIFAR_STD),
])
print(transform_train)
transform_train.transforms.insert(0, Augmentation(fa_reduced_cifar10()))
print(transform_train)
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(_CIFAR_MEAN, _CIFAR_STD),
])
return transform_train, transform_test # okay then plug these into cifar 10, and u r set.
def create_transform(self):
'''
Defines the transformation applied to the images before being returned.
This can be extended as required
'''
to_tensor = transforms.ToTensor()
to_img = transforms.ToPILImage()
self.apply_noise = transforms.Lambda(lambda x: to_img(
torch.clamp(
to_tensor(x) + self.noise_factor * torch.randn_like(
to_tensor(x)), 0.0, 1.0)))
change_colour = transforms.ColorJitter(brightness=(0.5, 1.5),
contrast=(0.5, 1.5),
saturation=(0, 1.5),
hue=0)
transform_list = [
transforms.RandomHorizontalFlip(p=0.5),
transforms.RandomApply([change_colour], p=0.9)
]
self.augment_data = transforms.Compose(transform_list)
if not 'mean' in self.cfg.keys():
mean = [0.5, 0.5, 0.5]
else:
mean = [float(val) for val in self.cfg['mean'].split(',')]
if not 'std' in self.cfg.keys():
std = [0.5, 0.5, 0.5]
else:
std = [float(val) for val in self.cfg['std'].split(',')]
self.transform_to_tensor = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize(mean=mean, std=std)])
def get_simclr_pipeline_transform(size, s=1, channels=3):
"""Return a set of data augmentation transformations as described in the SimCLR paper."""
#Original
color_jitter = transforms.ColorJitter(0.8 * s, 0.8 * s, 0.8 * s, 0.2 * s)
data_transforms = transforms.Compose([transforms.RandomResizedCrop(size=size),
# transforms.RandomHorizontalFlip(),
transforms.RandomApply([color_jitter], p=0.8),
transforms.RandomGrayscale(p=0.2),
GaussianBlur(kernel_size=int(0.1 * size), channels=channels),
transforms.ToTensor()])
# data_transforms = transforms.Compose([iaa.Sequential([iaa.SomeOf((1, 5),
# [iaa.LinearContrast((0.5, 1.0)),
# iaa.GaussianBlur((0.5, 1.5)),
# iaa.Crop(percent=((0, 0.4),(0, 0),(0, 0.4),(0, 0.0)), keep_size=True),
# iaa.Crop(percent=((0, 0.0),(0, 0.02),(0, 0),(0, 0.02)), keep_size=True),
# iaa.Sharpen(alpha=(0.0, 0.5), lightness=(0.0, 0.5)),
# iaa.PiecewiseAffine(scale=(0.02, 0.03), mode='edge'),
# iaa.PerspectiveTransform(scale=(0.01, 0.02))],
# random_order=True)]).augment_image,
# transforms.ToTensor()])
return data_transforms
from albumentations import (
CLAHE, Blur, OpticalDistortion, GridDistortion, ElasticTransform,
Solarize, RandomBrightnessContrast, RandomBrightness, Cutout,
InvertImg, RandomContrast, RandomGamma, OneOf, Compose,
JpegCompression, RandomShadow, PadIfNeeded, ToGray)
tbaug = TenBrightAug()
incbaug = IncBrightAug()
colaug = ColorAug()
distortaug = DistortAug()
# grayimg = GrayImg()
# binimg = BinImg()
resizeimg = ResizeAug(800, 32)
jpgaug = JPEGAug(1)
randtf = transforms.RandomApply([distortaug, jpgaug])
tf01 = Compose([
JpegCompression(quality_lower=20, quality_upper=100),
# RandomShadow(num_shadows_lower=1, num_shadows_upper=2),
Cutout(num_holes=8, max_h_size=8, max_w_size=8),
InvertImg(p=0.3),
])
tf = transforms.Compose([
# distortaug,
# colaug,
# tbaug,
# incbaug,
# jpgaug,
# grayimg,
def RandomApply(self, **args):
return self._add(transforms.RandomApply(**args))
LABEL_TRANSFORM = transforms.Compose([
transforms.RandomResizedCrop((384, 768), scale=(0.5, 2.), interpolation=0),
transforms.RandomHorizontalFlip(),
Relabel(run_cc=False),
transforms.ToTensor()
])
TEST_LABEL_TRANSFORM = transforms.Compose([
transforms.Resize(size=(384, 768), interpolation=Image.NEAREST),
Relabel(run_cc=False),
transforms.ToTensor()
])
EXTENDED_TRANSFORM = transforms.Compose([
transforms.RandomApply([transforms.ColorJitter(0.4, 0.4, 0.4, 0.1)],
p=0.8),
transforms.RandomGrayscale(p=0.2),
GaussianBlur([.1, 2.]),
transforms.ToTensor(),
ImgNormalize()
])
class CityscapesDataset:
def __init__(self,
root_dir,
phase,
class_name,
instance_ratio=None,
spoco=False):
assert phase in ['train', 'val', 'test']
def __init__(self, root=r"C:\datasets\taco\tensors", augment_prob=0.0, reduce=0.0, image_size=84,
tensors=True,
random_seed=42, **kwargs):
self.reduce = reduce
self.tensors = tensors
random.seed(random_seed)
resize_train = transforms.Compose(
[
transforms.Resize(image_size),
transforms.CenterCrop(image_size),
]
)
resize_test = transforms.Compose(
[
transforms.Resize(image_size),
transforms.CenterCrop(image_size),
]
)
augment = transforms.Compose(
[
# transforms.RandomRotation(degrees=15),
transforms.RandomHorizontalFlip(p=0.5),
# transforms.ColorJitter(),
# transforms.RandomPerspective(p=0.2, distortion_scale=0.25),
]
)
normalize = transforms.Compose(
[
transforms.ToTensor(),
transforms.Normalize(mean=MEAN, std=STD)
]
)
self.test_transform = transforms.Compose(
[
resize_test,
normalize
]
)
self.train_transform = transforms.Compose(
[
resize_train,
transforms.RandomApply([augment], p=augment_prob),
normalize
]
)
if not tensors:
self.source_dataset_train = torchvision.datasets.ImageFolder(root=root)
else:
self.source_dataset_train = torchvision.datasets.DatasetFolder(root=root, loader=tensor_loader,
extensions=('pt',))
self.dataset_train_size = len(self.source_dataset_train)
items = []
labels = []
for i in range(self.dataset_train_size):
items.append(ImageItem(self.source_dataset_train, i))
labels.append(self.source_dataset_train[i][1])
is_test = [0] * self.dataset_train_size
super(TacoDataset, self).__init__(items, labels, is_test)
self.train_subdataset, self.test_subdataset = self.subdataset.train_test_split()
if reduce < 1:
self.train_subdataset = self.train_subdataset.downscale(1 - reduce)
else:
self.train_subdataset = self.train_subdataset.balance(reduce)
def __init__(self, opt):
# super(Batch_Balanced_Dataset, self).__init__()
self.tbaug = TenBrightAug()
self.incbaug = IncBrightAug()
self.colaug = ColorAug()
self.distortaug = DistortAug()
self.grayimg = GrayImg()
self.binimg = BinImg()
self.jpgaug = JPEGAug(0.8)
self.resizeimg = ResizeAug(opt.imgW, opt.imgH)
self.resizeimg_test = ResizeAug(opt.imgW, opt.imgH, rand_scale=False)
l1 = len(opt.train_data.strip().split(','))
if l1 == 1:
self.batch_sizes = [int(opt.batch_size)]
elif l1 == 3:
self.batch_sizes = [
int(opt.batch_size * opt.batch_ratio),
opt.batch_size - int(opt.batch_size * opt.batch_ratio)
]
elif l1 == 4:
b1 = int(opt.batch_size * opt.batch_ratio2)
self.batch_sizes = [int(b1 * opt.batch_ratio), 0, 0]
self.batch_sizes[1] = b1 - self.batch_sizes[0]
self.batch_sizes[
2] = opt.batch_size - self.batch_sizes[0] - self.batch_sizes[1]
if not opt.alldata:
self.test_books = [
'200021660', '200005598', 'hnsd006', 'umgy003', '100249416',
'umgy011', 'umgy010'
]
else:
print('use all data')
self.test_books = [
# '200021660',
# '200005598',
'hnsd006',
'umgy003',
'100249416',
'umgy011',
'umgy010'
]
self.train_tf1 = transforms.Compose([
self.distortaug, self.colaug, self.tbaug, self.incbaug,
self.grayimg, self.binimg, self.tbaug, self.incbaug, self.jpgaug,
self.resizeimg,
transforms.ToTensor()
])
self.train_tf0 = transforms.Compose(
[self.grayimg, self.resizeimg,
transforms.ToTensor()])
self.train_tf00 = Compose([
OneOf([
OpticalDistortion(distort_limit=0.05,
shift_limit=10,
border_mode=cv2.BORDER_WRAP,
p=0.5),
ElasticTransform(p=0.5,
alpha=1,
sigma=50,
alpha_affine=0.2,
border_mode=cv2.BORDER_CONSTANT)
]),
OneOf([
CLAHE(),
Solarize(),
RandomBrightness(),
RandomContrast(limit=0.2),
RandomBrightnessContrast(),
]),
JpegCompression(quality_lower=20, quality_upper=100),
RandomShadow(num_shadows_lower=1, num_shadows_upper=2),
PadIfNeeded(min_height=64,
min_width=100,
border_mode=cv2.BORDER_CONSTANT,
p=0.5),
Cutout(num_holes=8, max_h_size=16, max_w_size=16),
InvertImg(p=0.3),
ToGray()
])
self.train_tf01 = Compose([
JpegCompression(quality_lower=20, quality_upper=100),
Cutout(num_holes=4, max_h_size=8, max_w_size=8),
InvertImg(p=0.3)
])
self.randtf = transforms.RandomApply([self.distortaug])
self.train_tf2 = transforms.Compose(
[self.resizeimg_test, transforms.ToTensor()])
self.data_loader_list = []
self.datasets = []
self.data_samplers = []
self.opt = opt
self.train_data = opt.train_data.strip().split(',')
if not 'txt' in self.train_data[0]:
self.datasets.append(
RealImageLMDB(self.train_data[0],
transform=self.train_tf0,
transform2=self.train_tf00,
testBooks=self.test_books,
character=opt.character,
max_batch_length=opt.batch_max_length))
else:
self.datasets.append(
RealImageTxtLMDB(self.train_data[0],
transform=self.train_tf0,
transform2=self.train_tf00,
testBooks=self.test_books,
max_batch_length=opt.batch_max_length))
if len(self.train_data) == 3:
self.datasets.append(
SynthImageLMDB(self.train_data[1],
self.train_data[2],
transform=self.train_tf2,
transform2=self.train_tf01,
size=(opt.imgH, opt.imgW),
gray_bin_ratio=0.5,
max_label_length=opt.batch_max_length))
if len(self.train_data) == 4:
self.datasets.append(
RealImageTxtLMDB(self.train_data[3],
transform=self.train_tf0,
transform2=self.train_tf00,
testBooks=self.test_books,
max_batch_length=opt.batch_max_length))
for i in range(len(self.datasets)):
train_sampler = torch.utils.data.distributed.DistributedSampler(
self.datasets[i])
self.data_samplers.append(train_sampler)
self.data_loader_list.append(
DataLoader(self.datasets[i],
num_workers=int(opt.workers),
shuffle=False,
sampler=train_sampler,
batch_size=self.batch_sizes[i],
collate_fn=collate_fn,
pin_memory=True,
drop_last=True))
self.dataloader_iter_list = [iter(i) for i in self.data_loader_list]
self.test_tf = transforms.Compose(
[self.grayimg, self.resizeimg_test,
transforms.ToTensor()])
self.test_dataset = RealImageLMDB(self.train_data[0],
self.test_tf,
testBooks=self.test_books,
isTest=True,
character=opt.character)
self.test_sampler = torch.utils.data.distributed.DistributedSampler(
self.test_dataset)
self.test_loader = DataLoader(self.test_dataset,
num_workers=int(opt.workers),
shuffle=False,
sampler=self.test_sampler,
batch_size=max(2,
int(opt.batch_size / 8)),
collate_fn=collate_fn,
drop_last=True)
def DataModule(batch_size, ks, imagenet_stats):
# https://github.com/fastai/imagenette
# Define parameters for dataset construction:
dataset_url = 'https://s3.amazonaws.com/fast-ai-imageclas/imagenette2.tgz'
dataset_filename = dataset_url.split('/')[-1]
dataset_foldername = dataset_filename.split('.')[0]
data_path = './data'
dataset_filepath = os.path.join(data_path, dataset_filename)
dataset_folderpath = os.path.join(data_path, dataset_foldername)
os.makedirs(data_path,
exist_ok=True) # Create a data folder (@ project folder)
# If data does not exist, download it from specified URL:
download = False
if not os.path.exists(dataset_filepath):
download = True
else:
md5_hash = hashlib.md5()
file = open(dataset_filepath, "rb")
content = file.read()
md5_hash.update(content)
digest = md5_hash.hexdigest()
if digest != 'fe2fc210e6bb7c5664d602c3cd71e612':
download = True
if download:
download_url(dataset_url, data_path)
# Extract tar file containing dataset examples
with tarfile.open(dataset_filepath, 'r:gz') as tar:
tar.extractall(path=data_path)
# Define model-input transforms for data augmentation:
train_transform = TwoCropsTransform(
transforms.Compose([
transforms.RandomResizedCrop(scale=(0.2, 1), size=224),
transforms.RandomHorizontalFlip(),
transforms.RandomApply(
[transforms.ColorJitter(0.8, 0.8, 0.8, 0.2)], p=0.8),
transforms.RandomGrayscale(p=0.2),
# transforms.GaussianBlur(kernel_size=ks),
transforms.ToTensor(),
transforms.Normalize(**imagenet_stats)
]))
# Define train and val dataset wrappers:
dataset_train = torchvision.datasets.ImageFolder(
os.path.join(dataset_folderpath, 'train'), train_transform)
dataset_validation = torchvision.datasets.ImageFolder(
os.path.join(dataset_folderpath, 'val'), train_transform)
# Define train and val dataloaders:
train_dataloader = torch.utils.data.DataLoader(
dataset_train,
batch_size=batch_size,
num_workers=8,
drop_last=True,
shuffle=True,
)
validation_dataloader = torch.utils.data.DataLoader(
dataset_validation,
batch_size=batch_size,
num_workers=8,
drop_last=True,
shuffle=True,
)
return train_dataloader, validation_dataloader, transforms
os.makedirs(save_path, exist_ok=True)
device = "cuda" if T.cuda.is_available() else "cpu"
print("device:", device)
v = 0
a = 0.95
# SETUP DATA TRANSFORMS
if args.random:
r = args.random
train_transforms = transforms.Compose([
transforms.ToTensor(),
#transforms.RandomApply([
# transforms.GaussianBlur(3, sigma=(0.1, 2.0))
#], p=0.2),
transforms.RandomApply(
[transforms.Grayscale(num_output_channels=3)], p=0.2),
transforms.RandomApply([
transforms.ColorJitter(brightness=r,
contrast=r,
saturation=r,
hue=r)
]),
transforms.RandomApply(
[transforms.RandomAffine(r * 10, shear=r * 10)]),
transforms.RandomResizedCrop((32, 32), scale=(1 - r, 1.0)),
transforms.RandomHorizontalFlip(p=0.5),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
])
test_transforms = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
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
transformsList = [
# transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.RandomRotation(15),
transforms.RandomAffine(degrees=0, translate=(.3, .7)),
# transforms.ColorJitter(
# brightness=float(0.1*np.random.rand(1)),
# contrast=float(0.1*np.random.rand(1)),
# saturation=float(0.1*np.random.rand(1)),
# hue=float(0.1*np.random.rand(1))),
#transforms.RandomGrayscale(p=0.1)
]
data_aug_transforms = transformsList
data_aug_transforms = transforms.RandomApply(transformsList, p=0.5)
# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****
# norm_transform = transforms.Compose([data_aug_transforms]+[transforms.ToTensor()])
# test_transform = transforms.Compose([transforms.ToTensor()])
train_loader = torch.utils.data.DataLoader(dataset=train_dataset,
batch_size=batch_size,
shuffle=True)
val_loader = torch.utils.data.DataLoader(dataset=val_dataset,
batch_size=batch_size,
shuffle=False)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset,
batch_size=batch_size,
shuffle=False)
