def get_mini_imagenet_data_loader(task, num_per_class=1, split='train',shuffle = False,train_query_argue=False,train_support_argue=False):
normalize = transforms.Normalize(mean=[0.92206, 0.92206, 0.92206], std=[0.08426, 0.08426, 0.08426])
Arguementation = T.Compose([
T.RandomCrop(84, padding=8),
T.RandomHorizontalFlip(),
T.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4),
T.ToTensor(),
normalize,
T.RandomErasing(0.5)
])
Arguementation_support = transforms.Compose([
transforms.Resize(84),
# transforms.RandomHorizontalFlip(),
# transforms.RandomVer
transforms.ToTensor(),
normalize
])
# 针对Support不做增强
if split == 'train' and train_support_argue == False:
dataset = MiniImagenet(task,split=split,transform=transforms.Compose([transforms.ToTensor(),normalize]))
sampler = ClassBalancedSamplerOld(num_per_class,task.num_classes, task.train_num,shuffle=shuffle)
elif split == 'train' and train_support_argue == True:
dataset = MiniImagenet(task,split=split,transform=Arguementation_support)
sampler = ClassBalancedSamplerOld(num_per_class,task.num_classes, task.train_num,shuffle=shuffle)
# 只针对训练中的query set做增强，但对训练中的support set不做增强
else:
if train_query_argue == False:
dataset = MiniImagenet(task,split=split,transform=transforms.Compose([transforms.ToTensor(),normalize]))
sampler = ClassBalancedSampler(task.num_classes, task.test_num,shuffle=shuffle)
else:
dataset = MiniImagenet(task,split=split,transform=Arguementation)
sampler = ClassBalancedSampler(task.num_classes, task.test_num,shuffle=shuffle)
loader = DataLoader(dataset, batch_size=num_per_class*task.num_classes, sampler=sampler)
return loader
def __init__(self,
img_size: int,
original_size: int,
mean: float = 0,
std: float = 1,
brightness: float = 0.3,
contrast: float = 0.5,
saturation: float = 0.5,
hue: float = 0.3,
rotation_degree: int = 10,
hflip: float = 0.5,
debug: bool = False):
self.original_size = original_size
self.target_size = img_size
self.to_pil = transforms.ToPILImage()
self.color_jitter = transforms.ColorJitter(brightness=brightness,
contrast=contrast,
saturation=saturation,
hue=hue)
self.resize = transforms.Resize(img_size)
self.to_tensor = transforms.ToTensor()
self.normalize = transforms.Normalize(mean, std)
self.r_horizontal_flip = RandomHorizontalFlip(p=hflip)
self.r_rotation = RandomRotation(rotation_degree)
self.debug = debug
def get_transform(train):
transforms = []
if train:
# transforms.append(T.random_affine(degrees=1.98, translate=0.05, scale=0.05, shear=0.641))
transforms.append(T.ColorJitter(brightness=0.5, saturation=0.5))
transforms.append(T.RandomRotation())
transforms.append(T.ToTensor())
transforms.append(T.RandomHorizontalFlip(0.5))
else:
transforms.append(T.ToTensor())
return T.Compose(transforms)
def apply_transorms(self, img, target):
transorm_flip = transforms.RandomHorizontalFlip(0.5)
normalize = transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
jitter = transforms.ColorJitter(brightness=0.3, contrast=0.2, hue=0.1)
img = jitter(img)
img = F.to_tensor(img)
img, target = transorm_flip(img, target)
#img = normalize(img)
return img, target
def __init__(self,
base_size,
mean=(0.485, 0.456, 0.406),
std=(0.229, 0.224, 0.225),
contrast=1,
brightness=1,
sigma=1):
self.contrast_initial = contrast
self.contrast_final = contrast
if (contrast == 1):
self.contrast_final = contrast
else:
self.contrast_final = self.contrast_initial - 1
self.brightness_initial = brightness
self.brightness_final = brightness
if (brightness == 1):
self.brightness_final = brightness
else:
self.brightness_final = self.brightness_initial - 1
self.sigma_initial = sigma
self.sigma_final = sigma
if (sigma == 1):
self.sigma_final = sigma
else:
self.sigma_final = self.sigma_initial - 1
print("Contrast: ({}, {})".format(self.contrast_final,
self.contrast_initial))
print("Brightness: ({}, {})".format(self.brightness_final,
self.brightness_initial))
print("Sigma: ({}, {})".format(self.sigma_final, self.sigma_initial))
self.transforms = T.Compose([
T.RandomResize(base_size, base_size),
T.PILToTensor(),
T.ConvertImageDtype(torch.float),
T.ColorJitter(contrast=(self.contrast_final,
self.contrast_initial),
brightness=(self.brightness_final,
self.brightness_initial)),
#T.GaussianBlur(kernel_size=19, sigma=(self.sigma_final, self.sigma_initial)),
T.Normalize(mean=mean, std=std),
])
def get_transform(train):
base_size = 1000
crop_size = 768
min_size = int((0.5 if train else 1.0) * base_size)
max_size = int((2.0 if train else 1.0) * base_size)
transforms = []
transforms.append(T.RandomResize(min_size, max_size))
if train:
transforms.append(T.ColorJitter(0.5, 0.5, 0.5, 0.5))
transforms.append(T.RandomHorizontalFlip(0.5))
transforms.append(T.RandomVerticalFlip(0.5))
transforms.append(T.RandomCrop(crop_size))
transforms.append(T.ToTensor())
transforms.append(
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]))
return T.Compose(transforms)
def __init__(self, data_path, split, augment=True, load_everything=True):
self.count = 0
file_path = os.path.join(data_path, 'miniplaces_256_{}.h5'.format(split))
self.dataset = h5py.File(file_path)
self.normalize = transforms.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
transform = [
transforms.Scale(256),
transforms.RandomCrop(224),
# transforms.RandomResizedCrop(224)
]
if augment:
transform.extend([
transforms.ColorJitter(brightness=0.1, contrast=0.0, saturation=0.3, hue=0.05),
transforms.RandomHorizontalFlip(),
# transforms.RandomVerticalFlip(),
])
transform += [transforms.ToTensor()]
if augment:
transform.append(
affine_transforms.Affine(rotation_range=5.0, zoom_range=(0.85, 1.0), fill_mode='constant')
)
# if augment:
# transform.append(
# affine_transforms.Affine(rotation_range=10.0, translation_range=0.1, zoom_range=(0.5, 1.0), fill_mode='constant')
# )
transform += [
self.normalize]
self.preprocess = transforms.Compose(transform)
self.split = split
if split != 'test':
self.labels = np.array(self.dataset['labels'])
self.load_everything = load_everything
if self.load_everything:
self.images = np.array(self.dataset['images'])
def get(args):
""" Entry point. Call this function to get all Charades dataloaders """
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_file = args.train_file
val_file = args.val_file
train_dataset = Charades(
args.data,
'train',
train_file,
args.cache,
transform=transforms.Compose([
transforms.RandomResizedCrop(args.inputsize),
transforms.ColorJitter(brightness=0.4,
contrast=0.4,
saturation=0.4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(), # missing PCA lighting jitter
normalize,
]))
val_dataset = Charades(args.data,
'val',
val_file,
args.cache,
transform=transforms.Compose([
transforms.Resize(
int(256. / 224 * args.inputsize)),
transforms.CenterCrop(args.inputsize),
transforms.ToTensor(),
normalize,
]))
valvideo_dataset = Charades(args.data,
'val_video',
val_file,
args.cache,
transform=transforms.Compose([
transforms.Resize(
int(256. / 224 * args.inputsize)),
transforms.CenterCrop(args.inputsize),
transforms.ToTensor(),
normalize,
]))
return train_dataset, val_dataset, valvideo_dataset
def get_train_dataloader(data_path, image_size, batch_size, mean, std):
train_transforms = transforms.Compose([
transforms.Resize(image_size),
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(),
transforms.ToTensor(),
transforms.Normalize(mean, std),
])
train_dataset = CamVid(
data_path,
'train',
transforms=train_transforms,
)
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=args.b,
num_workers=4,
shuffle=True)
return train_loader
def build_transforms(is_train, size, crop_size,mode="baseline"):
mean = (0.485, 0.456, 0.406)
std = (0.229, 0.224, 0.225)
fill = tuple([int(v * 255) for v in mean])
ignore_value = 255
transforms=[]
min_scale=1
max_scale=1
if is_train:
min_scale=0.5
max_scale=2
transforms.append(T.RandomResize(int(min_scale*size),int(max_scale*size)))
if is_train:
if mode=="baseline":
pass
elif mode=="randaug":
transforms.append(T.RandAugment(2,1/3,prob=1.0,fill=fill,ignore_value=ignore_value))
elif mode=="custom1":
transforms.append(T.ColorJitter(0.5,0.5,(0.5,2),0.05))
transforms.append(T.AddNoise(10))
transforms.append(T.RandomRotation((-10,10), mean=fill, ignore_value=0))
else:
raise NotImplementedError()
transforms.append(
T.RandomCrop(
crop_size,crop_size,
fill,
ignore_value,
random_pad=is_train
))
transforms.append(T.RandomHorizontalFlip(0.5))
transforms.append(T.ToTensor())
transforms.append(T.Normalize(
mean,
std
))
return T.Compose(transforms)
os.makedirs(checkpoint_path)
checkpoint_path = os.path.join(checkpoint_path, '{net}-{epoch}-{type}.pth')
#tensorboard log directory
log_path = os.path.join(settings.LOG_DIR, args.net, settings.TIME_NOW)
if not os.path.exists(log_path):
os.makedirs(log_path)
writer = SummaryWriter(log_dir=log_path)
#get dataloader
train_transforms = transforms.Compose([
transforms.ToCVImage(),
#transforms.RandomResizedCrop(settings.IMAGE_SIZE),
transforms.Resize(settings.IMAGE_SIZE),
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(brightness=0.4, saturation=0.4, hue=0.4),
#transforms.RandomErasing(),
#transforms.CutOut(56),
transforms.ToTensor(),
transforms.Normalize(settings.TRAIN_MEAN, settings.TRAIN_STD)
])
test_transforms = transforms.Compose([
transforms.ToCVImage(),
#transforms.CenterCrop(settings.IMAGE_SIZE),
transforms.Resize(settings.IMAGE_SIZE),
transforms.ToTensor(),
transforms.Normalize(settings.TRAIN_MEAN, settings.TRAIN_STD)
])
train_dataloader = get_train_dataloader(settings.DATA_PATH,
return images
def h5_loader(path):
# 关于HDF5的文件操作，详见https://blog.csdn.net/yudf2010/article/details/50353292
h5f = h5py.File(path, "r") # r是读的意思
rgb = np.array(h5f['rgb']) # 使用array()函数可以将python的array_like数据转变成数组形式，使用matrix()函数转变成矩阵形式。
# 基于习惯，在实际使用中较常用array而少用matrix来表示矩阵。
rgb = np.transpose(rgb, (1, 2, 0)) # 关于np.transpose()对高维数组的转置，详见https://www.cnblogs.com/sunshinewang/p/6893503.html
depth = np.array(h5f['depth'])
return rgb, depth
iheight, iwidth = 480, 640 # raw image size
oheight, owidth = 228, 304 # image size after pre-processing
color_jitter = transforms.ColorJitter(0.4, 0.4, 0.4)
# 数据增强（论文中的方法）
def train_transform(rgb, depth):
s = np.random.uniform(1.0, 1.5) # random scaling
# print("scale factor s={}".format(s))
depth_np = depth / s
angle = np.random.uniform(-5.0, 5.0) # random rotation degrees
do_flip = np.random.uniform(0.0, 1.0) < 0.5 # random horizontal flip
# perform 1st part of data augmentation
transform = transforms.Compose([
transforms.Resize(250.0 / iheight), # this is for computational efficiency, since rotation is very slow
transforms.Rotate(angle),
transforms.Resize(s),
transforms.CenterCrop((oheight, owidth)),
# use_gpu = torch.cuda.is_avilable()
cudnn.benchmark = True
use_gpu = True
## Data loading code
# normalization to be applied to the training and validation tensors.
normalize = augment.Normalize(mean = [ 0.485, 0.456, 0.406 ],
std = [ 0.229, 0.224, 0.225 ])
# Dataset setup
# Choose what sort of data transformations and augmentations you wish to apply to
# the training.
# A set of random transformations which can be applied.
random_Transform_List = [transforms.RandomHorizontalFlip(),transforms.RandomRotation(30),
transforms.ColorJitter(brightness=0.5),transforms.Grayscale(num_output_channels=3)]
data_transforms = {
'train': augment.Compose([
#augment.ScalePad((1024,1024)),
#augment.RandomRotate(60),
#augment.RandomHorizontalFlip(),
augment.AnisotropicScale((224,224)),
transforms.RandomApply(random_Transform_List,p=0.5),
augment.ToTensor(),
normalize
]),
'val': augment.Compose([
#augment.ScalePad((1024,1024)),
augment.AnisotropicScale((224,224)),
augment.ToTensor(),
checkpoint_path = os.path.join(checkpoint_path, '{epoch}-{type}.pth')
if not os.path.exists(log_dir):
os.makedirs(log_dir)
writer = SummaryWriter(log_dir=log_dir)
train_dataset = CamVid(settings.DATA_PATH, 'train')
valid_dataset = CamVid(settings.DATA_PATH, 'val')
train_transforms = transforms.Compose([
transforms.RandomRotation(value=train_dataset.ignore_index),
transforms.RandomScale(value=train_dataset.ignore_index),
transforms.RandomGaussianBlur(),
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(),
transforms.Resize(settings.IMAGE_SIZE),
transforms.ToTensor(),
transforms.Normalize(settings.MEAN, settings.STD),
])
valid_transforms = transforms.Compose([
transforms.Resize(settings.IMAGE_SIZE),
transforms.ToTensor(),
transforms.Normalize(settings.MEAN, settings.STD),
])
train_dataset.transforms = train_transforms
valid_dataset.transforms = valid_transforms
train_loader = torch.utils.data.DataLoader(train_dataset,
def main():
SIZE_IMG = 224
# 224
global args
args = parser.parse_args()
# create model
if args.arch.startswith('resnet50'):
model = model_defs.resnet50_oneway(num_classes=2)
model = nn.DataParallel(model.model)
# dirty trick
# open log file
if args.train == 1:
log_dir = 'logs'
log_name = args.arch + '_new.csv'
if not os.path.isdir(log_dir):
os.mkdir(log_dir)
log_handle = get_file_handle(os.path.join(log_dir, log_name), 'wb+')
log_handle.write('Epoch, LearningRate, Momentum, WeightDecay,' + \
'Loss, Precision, Recall, Accuracy(IoU), FgWeight, BgWeight\n')
log_handle.close()
# check model directory
model_dir = 'models'
if not os.path.isdir(model_dir):
os.mkdir(model_dir)
# resume learning based on cmdline arguments
if ((args.start_epoch > 1) and (args.train == 1)):
load_epoch = args.start_epoch - 1
elif (args.train == 0):
load_epoch = args.load_epoch
else:
load_epoch = 0
if load_epoch > 0:
print("=> loading checkpoint for epoch = '{}'".format(load_epoch))
checkpoint_name = args.arch + '_ep_' + str(load_epoch) + '.pth.tar'
checkpoint = torch.load(os.path.join(model_dir, checkpoint_name))
model.load_state_dict(checkpoint['state_dict'])
# model = add_dropout2d(model);
model.cuda()
# transfer to cuda
print(model)
mean = load_pickle('./mean')
std = load_pickle('./std')
if args.train == 1:
train_data_dir, train_gt_dir = args.data, args.gt
train_loader = torch.utils.data.DataLoader(datasets.ImageFolder(
train_data_dir,
train_gt_dir,
transform_joint=transforms.Compose_Joint([
transforms.RandomCrop(SIZE_IMG),
transforms.RandomHorizontalFlip(),
transforms.RandomVerticalFlip(),
]),
transform=transforms.Compose([
transforms.ColorJitter(0.3, 0.3, 0.3, 0),
transforms.ToTensor(),
transforms.Normalize(mean=mean, std=std),
]),
target_transform=transforms.Compose([
transforms.ToTensorTarget(),
]),
do_copy=True,
),
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
weights = torch.from_numpy(np.array([1., 1.01])).float()
criterion = nn.CrossEntropyLoss(weights).cuda()
if args.optim == 'adam':
optimizer = torch.optim.Adam(model.parameters(),
lr=args.learning_rate,
weight_decay=args.weight_decay)
elif args.optim == 'sgd':
optimizer = torch.optim.SGD(model.parameters(),
lr=args.learning_rate,
momentum=args.momentum,
weight_decay=args.weight_decay)
for epoch in range(args.start_epoch, args.end_epoch + 1):
# train for one epoch
stats_epoch = train(train_loader, model, criterion, optimizer,
epoch)
model_name = args.arch + '_ep_' + str(epoch) + '.pth.tar'
# get current parameters of optimizer
for param_group in optimizer.param_groups:
cur_lr = param_group['lr']
cur_wd = param_group['weight_decay']
if param_group.has_key('momentum'):
cur_momentum = param_group['momentum']
else:
cur_momentum = 'n/a'
break
# constant parameters throughout the network
if epoch % args.save_interval == 0:
state = {
'epoch': epoch,
'arch': args.arch,
'state_dict': model.state_dict(),
'learning_rate': cur_lr,
'moemntum': cur_momentum,
'weight_decay': cur_wd,
'fg_weight': weights[1],
'bg_weight': weights[0],
}
torch.save(state, os.path.join(model_dir, model_name))
# write logs using logHandle
log_handle = get_file_handle(os.path.join(log_dir, log_name), 'ab')
log_handle.write(
str(epoch) + ',' + str(cur_lr) + ',' + str(cur_momentum) +
',' + str(cur_wd) + ',' + str(stats_epoch['loss']) + ',' +
str(stats_epoch['prec']) + ',' + str(stats_epoch['recall']) +
',' + str(stats_epoch['acc']) + ',' + str(weights[1]) + ',' +
str(weights[0]) + '\n')
log_handle.close()
# adjust_learning_rate(optimizer, epoch, 10); # adjust learning rate
elif args.train == 0: # test
testdir = args.data
outdir = args.out
stride = args.test_stride
test_batch_size = args.test_batch_size
test_transformer = transforms.Compose([
# transforms.RandomHorizontalFlip(),
# transforms.RandomVerticalFlip(),
transforms.ToTensor(),
transforms.Normalize(mean=mean, std=std),
])
# test(testdir, outdir, test_transformer, model, load_epoch, stride, SIZE_IMG);
test_batch_form(testdir, outdir, test_transformer, model, load_epoch,
stride, SIZE_IMG, test_batch_size)
def __init__(self, args, use_gpu):
super(DataManager, self).__init__()
self.args = args
self.use_gpu = use_gpu
print("Initializing dataset {}".format(args.dataset))
dataset = datasets.init_imgfewshot_dataset(name=args.dataset,
root=args.root)
if args.load:
transform_train = T.Compose([
T.RandomCrop(84, padding=8),
T.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4),
T.RandomHorizontalFlip(),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
T.RandomErasing(0.5)
])
transform_test = T.Compose([
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
elif args.cifar:
transform_train = T.Compose([
T.RandomCrop(32, padding=4),
T.RandomHorizontalFlip(),
T.ToTensor(),
T.Normalize(mean=[0.507, 0.487, 0.441],
std=[0.267, 0.256, 0.276]),
T.RandomErasing(0.5)
])
transform_test = T.Compose([
T.ToTensor(),
T.Normalize(mean=[0.507, 0.487, 0.441],
std=[0.267, 0.256, 0.276]),
])
else:
transform_train = T.Compose([
T.RandomResizedCrop((84, 84)),
T.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4),
T.RandomHorizontalFlip(),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
T.RandomErasing(0.5)
])
transform_test = T.Compose([
T.Resize((92, 92)),
T.CenterCrop((84, 84)),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
pin_memory = True if use_gpu else False
self.trainloader = DataLoader(
dataset_loader.init_loader(
name='train_loader',
dataset=dataset.train,
labels2inds=dataset.train_labels2inds,
labelIds=dataset.train_labelIds,
nKnovel=args.nKnovel,
nExemplars=args.nExemplars,
nTestNovel=args.train_nTestNovel,
epoch_size=args.train_epoch_size,
transform=transform_train,
load=args.load,
tiered=args.tiered,
),
batch_size=args.train_batch,
shuffle=True,
num_workers=args.workers,
pin_memory=pin_memory,
drop_last=True,
)
self.valloader = DataLoader(
dataset_loader.init_loader(
name='test_loader',
dataset=dataset.val,
labels2inds=dataset.val_labels2inds,
labelIds=dataset.val_labelIds,
nKnovel=args.nKnovel,
nExemplars=args.nExemplars,
nTestNovel=args.nTestNovel,
epoch_size=args.epoch_size,
transform=transform_test,
load=args.load,
tiered=args.tiered,
),
batch_size=args.test_batch,
shuffle=False,
num_workers=args.workers,
pin_memory=pin_memory,
drop_last=False,
)
self.testloader = DataLoader(
dataset_loader.init_loader(
name='test_loader',
dataset=dataset.test,
labels2inds=dataset.test_labels2inds,
labelIds=dataset.test_labelIds,
nKnovel=args.nKnovel,
nExemplars=args.nExemplars,
nTestNovel=args.nTestNovel,
epoch_size=args.epoch_size,
transform=transform_test,
load=args.load,
tiered=args.tiered,
),
batch_size=args.test_batch,
shuffle=False,
num_workers=args.workers,
pin_memory=pin_memory,
drop_last=False,
)
def train(self):
use_cuda = torch.cuda.is_available()
path = os.path.join('./out_models/' + self.model_name + '_' +
self.task_name + '_' + self.job_id)
## get logger
logger = self.get_logger(self.model_name, self.task_name, self.job_id,
path)
logger.info("Job_id : {}".format(self.job_id))
logger.info("gpus_device_ids : {}".format(self.device_ids))
logger.info("Task Name : {}".format(self.task_name))
logger.info("Backbone_name : {}".format(self.model_name))
logger.info("input_shape : ({},{}.{})".format(self.input_shape[0],
self.input_shape[1],
self.input_shape[2]))
logger.info("batch_size : {}".format(self.batch_size))
logger.info("num_epochs : {}".format(self.num_epochs))
logger.info("warmup_steps : {}".format(self.warmup_steps))
logger.info("resume_from : {}".format(self.resume_from))
logger.info("pretrained : {}".format(self.pretrained))
logger.info("mixup : {}".format(self.mixup))
logger.info("cutmix : {}".format(self.cutmix))
## tensorboard writer
log_dir = os.path.join(path, "{}".format("tensorboard_log"))
if not os.path.isdir(log_dir):
os.mkdir(log_dir)
writer = SummaryWriter(log_dir)
## get model of train
net = get_model(self.model_name)
net = torch.nn.DataParallel(net, device_ids=self.device_ids)
net = net.cuda(device=self.device_ids[0])
## loss
criterion = nn.CrossEntropyLoss()
## optimizer
if self.optimizers == 'SGD':
optimizer = optim.SGD(net.parameters(),
lr=self.init_lr,
momentum=0.9,
weight_decay=self.weight_decay)
elif self.optimizers == 'Adam':
optimizer = optim.Adam(net.parameters(),
lr=self.init_lr,
weight_decay=self.weight_decay)
milestones = [80, 150, 200, 300]
scheduler = optim.lr_scheduler.MultiStepLR(optimizer,
milestones=milestones,
gamma=0.1)
logger.info(("===========opti=========="))
logger.info("Optimizer:{}".format(self.optimizers))
logger.info("lr:{}".format(self.init_lr))
logger.info("weight_decay:{}".format(self.weight_decay))
logger.info("lr_scheduler: MultiStepLR")
logger.info("milestones:{}".format(milestones))
## augumation
normalize = transforms.Normalize(mean=[0.5, 0.5, 0.5],
std=[0.5, 0.5, 0.5])
## train aug
transform_train = transforms.Compose([
transforms.RandomCrop(int(self.input_shape[-1])),
transforms.RandomHorizontalFlip(),
transforms.RandomBrightness(brightness = self.brightness, brightness_ratio=self.brightness_ratio),
transforms.RandomBlur(blur_ratio = self.blur_ratio),
transforms.RandomRotation(degrees = self.degrees, rotation_ratio = 0.1),
transforms.ColorJitter(brightness = self.color_brightnesss, contrast = self.color_contrast,\
saturation = self.color_saturation, hue=0),
transforms.ToTensor(),
#normalize,
])
## test aug
transform_test = transforms.Compose([
transforms.CenterCrop(int(self.input_shape[-1])),
transforms.ToTensor(),
#normalize,
])
logger.info(("============aug==========="))
logger.info("crop: RandomCrop")
logger.info("RandomHorizontalFlip: True")
logger.info("brightness:{}".format(self.brightness))
logger.info("brightness_ratio:{}".format(self.brightness_ratio))
logger.info("blur_ratio:{}".format(self.blur_ratio))
logger.info("degrees:{}".format(self.degrees))
logger.info("color_brightnesss:{}".format(self.color_brightnesss))
logger.info("color_contrast:{}".format(self.color_contrast))
logger.info("color_saturation:{}".format(self.color_saturation))
## prepara data
print('==> Preparing data..')
logger.info(("==========Datasets========="))
logger.info("train_datasets:{}".format(self.train_datasets))
logger.info("val_datasets:{}".format(self.val_datasets))
logger.info("test_datasets:{}".format(self.test_datasets))
#trainset = DataLoader(split = 'Training', transform=transform_train)
trainset = DataLoader(self.train_datasets,
self.val_datasets,
self.test_datasets,
split='Training',
transform=transform_train)
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=self.batch_size *
len(self.device_ids),
shuffle=True)
Valset = DataLoader(self.train_datasets,
self.val_datasets,
self.test_datasets,
split='Valing',
transform=transform_test)
Valloader = torch.utils.data.DataLoader(Valset,
batch_size=64 *
len(self.device_ids),
shuffle=False)
Testset = DataLoader(self.train_datasets,
self.val_datasets,
self.test_datasets,
split='Testing',
transform=transform_test)
Testloader = torch.utils.data.DataLoader(Testset,
batch_size=64 *
len(self.device_ids),
shuffle=False)
## train
logger.info(("======Begain Training======"))
#self.train_model(net, criterion, optimizer, scheduler, trainloader, Valloader, Testloader, logger, writer, path)
self.train_model(net, criterion, optimizer, scheduler, trainloader,
Valloader, Testloader, logger, writer, path)
logger.info(("======Finsh Training !!!======"))
logger.info(("best_val_acc_epoch: %d, best_val_acc: %0.3f" %
(self.best_Val_acc_epoch, self.best_Val_acc)))
logger.info(("best_test_acc_epoch: %d, best_test_acc: %0.3f" %
(self.best_Test_acc_epoch, self.best_Test_acc)))
print('==> snapshot "{0}" loaded (epoch {1})'.format(
args.path, epoch))
else:
raise FileNotFoundError('no snapshot found at "{0}"'.format(
args.path))
else:
epoch = 0
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
preprocess = transforms.Compose([
transforms.Scale(256),
transforms.RandomCrop(224),
transforms.ColorJitter(brightness=0.1,
contrast=0.0,
saturation=0.3,
hue=0.05),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
affine_transforms.Affine(rotation_range=5.0,
zoom_range=(0.85, 1.0),
fill_mode='constant'), normalize
])
# testing the model
images = np.load('./preprocess/miniplaces_256_test.npz')['arr_0']
# print(images.files)
model.eval()
answers = []
inds = []
ls = []
def main(args):
init_distributed_mode(args)
print(args)
device = torch.device(args.device)
results_file = "results{}.txt".format(
datetime.datetime.now().strftime("%Y%m%d-%H%M%S"))
# Data loading code
print("Loading data")
data_transform = {
"train":
transforms.Compose([
transforms.SSDCropping(),
transforms.Resize(),
transforms.ColorJitter(),
transforms.ToTensor(),
transforms.RandomHorizontalFlip(),
transforms.Normalization(),
transforms.AssignGTtoDefaultBox()
]),
"val":
transforms.Compose([
transforms.Resize(),
transforms.ToTensor(),
transforms.Normalization()
])
}
VOC_root = args.data_path
# check voc root
if os.path.exists(os.path.join(VOC_root, "VOCdevkit")) is False:
raise FileNotFoundError(
"VOCdevkit dose not in path:'{}'.".format(VOC_root))
# load train data set
train_data_set = VOC2012DataSet(VOC_root,
data_transform["train"],
train_set='train.txt')
# load validation data set
val_data_set = VOC2012DataSet(VOC_root,
data_transform["val"],
train_set='val.txt')
print("Creating data loaders")
if args.distributed:
train_sampler = torch.utils.data.distributed.DistributedSampler(
train_data_set)
test_sampler = torch.utils.data.distributed.DistributedSampler(
val_data_set)
else:
train_sampler = torch.utils.data.RandomSampler(train_data_set)
test_sampler = torch.utils.data.SequentialSampler(val_data_set)
if args.aspect_ratio_group_factor >= 0:
# 统计所有图像比例在bins区间中的位置索引
group_ids = create_aspect_ratio_groups(
train_data_set, k=args.aspect_ratio_group_factor)
train_batch_sampler = GroupedBatchSampler(train_sampler, group_ids,
args.batch_size)
else:
train_batch_sampler = torch.utils.data.BatchSampler(train_sampler,
args.batch_size,
drop_last=True)
data_loader = torch.utils.data.DataLoader(
train_data_set,
batch_sampler=train_batch_sampler,
num_workers=args.workers,
collate_fn=train_data_set.collate_fn)
data_loader_test = torch.utils.data.DataLoader(
val_data_set,
batch_size=1,
sampler=test_sampler,
num_workers=args.workers,
collate_fn=train_data_set.collate_fn)
print("Creating model")
model = create_model(num_classes=args.num_classes + 1, device=device)
model_without_ddp = model
if args.distributed:
model = torch.nn.parallel.DistributedDataParallel(
model, device_ids=[args.gpu])
model_without_ddp = model.module
params = [p for p in model.parameters() if p.requires_grad]
optimizer = torch.optim.SGD(params,
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
step_size=args.lr_step_size,
gamma=args.lr_gamma)
# lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer, milestones=args.lr_steps, gamma=args.lr_gamma)
# 如果传入resume参数，即上次训练的权重地址，则接着上次的参数训练
if args.resume:
# If map_location is missing, torch.load will first load the module to CPU
# and then copy each parameter to where it was saved,
# which would result in all processes on the same machine using the same set of devices.
checkpoint = torch.load(
args.resume, map_location='cpu') # 读取之前保存的权重文件(包括优化器以及学习率策略)
model_without_ddp.load_state_dict(checkpoint['model'])
optimizer.load_state_dict(checkpoint['optimizer'])
lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])
args.start_epoch = checkpoint['epoch'] + 1
if args.test_only:
utils.evaluate(model, data_loader_test, device=device)
return
train_loss = []
learning_rate = []
val_map = []
print("Start training")
start_time = time.time()
for epoch in range(args.start_epoch, args.epochs):
if args.distributed:
train_sampler.set_epoch(epoch)
mean_loss, lr = utils.train_one_epoch(model,
optimizer,
data_loader,
device,
epoch,
args.print_freq,
warmup=True)
# only first process to save training info
if args.rank in [-1, 0]:
train_loss.append(mean_loss.item())
learning_rate.append(lr)
# update learning rate
lr_scheduler.step()
# evaluate after every epoch
coco_info = utils.evaluate(model, data_loader_test, device=device)
if args.rank in [-1, 0]:
# write into txt
with open(results_file, "a") as f:
# 写入的数据包括coco指标还有loss和learning rate
result_info = [
str(round(i, 4))
for i in coco_info + [mean_loss.item(), lr]
]
txt = "epoch:{} {}".format(epoch, ' '.join(result_info))
f.write(txt + "\n")
val_map.append(coco_info[1]) # pascal mAP
if args.output_dir:
# 只在主节点上执行保存权重操作
save_on_master(
{
'model': model_without_ddp.state_dict(),
'optimizer': optimizer.state_dict(),
'lr_scheduler': lr_scheduler.state_dict(),
'args': args,
'epoch': epoch
}, os.path.join(args.output_dir, 'model_{}.pth'.format(epoch)))
total_time = time.time() - start_time
total_time_str = str(datetime.timedelta(seconds=int(total_time)))
print('Training time {}'.format(total_time_str))
if args.rank in [-1, 0]:
# plot loss and lr curve
if len(train_loss) != 0 and len(learning_rate) != 0:
from plot_curve import plot_loss_and_lr
plot_loss_and_lr(train_loss, learning_rate)
# plot mAP curve
if len(val_map) != 0:
from plot_curve import plot_map
plot_map(val_map)
def main(argv):
epochs = 50
epochgroup = 10
testepochs = 2
save = False
load = False
train = True
test = True
home = expanduser("~")
traindata = home + '/Robotics/NeuralNetworks/DataSets/cone-square/train'
testdata = home + '/Robotics/NeuralNetworks/DataSets/cone-square/test'
transformlist = []
minimaltransformlist = []
verbose = 0
net = None
px = 64
parser = argparse.ArgumentParser()
parser.add_argument('--epochs', help='Epochs')
parser.add_argument('--epochgroup', help='Epochs between test set')
parser.add_argument('--testepochs', help='Test Epochs')
parser.add_argument('--net', help='Network')
parser.add_argument('--save', help='Save Network')
parser.add_argument('--load', help='Load Network')
parser.add_argument('--traindata', help='Training Data')
parser.add_argument('--testdata', help='Testing Data')
parser.add_argument('--notrain',
action='store_true',
help='Do not train network')
parser.add_argument('--notest',
action='store_true',
help='Do not test network')
parser.add_argument('--transforms', help='Transforms to use, all or none')
parser.add_argument('--verbose', help='Verbosity')
parser.add_argument('--px', help='x,y pixel number')
args = parser.parse_args()
if args.epochs:
epochs = int(args.epochs)
if args.epochgroup:
epochgroup = int(args.epochgroup)
if args.testepochs:
testepochs = int(args.testepochs)
if args.px:
px = int(args.px)
if args.net:
if args.net == "cnn":
net = CNN(px=px)
if args.net == "nn":
net = NN(px=px)
if args.net == "t1":
net = NNorCNN(px=px, clayers=[])
if args.net == "t2":
net = NNorCNN(px=px, clayers=[(5, 6, 2)])
if args.net == "t3":
net = NNorCNN(px=px, clayers=[(5, 6, 2), (5, 16, 2)])
if args.net == "t4":
net = NNorCNN(px=px, clayers=[(5, 6, 2), (5, 16, 2), (5, 7, 2)])
if args.net == "t5":
net = NNorCNN(px=px,
clayers=[(5, 6, 2), (5, 16, 2), (5, 7, 2)],
layers=[100, 2])
if args.net == "t6":
net = NNorCNN(px=px, layers=[128, 64, 32, 2])
if args.net == "d":
net = NNorCNN(px=px)
if args.net == "tf":
# the same as the TensorFlow cat dog example
net = NNorCNN(px=px,
clayers=[(3, 32, 2), (3, 32, 2), (3, 64, 2)],
layers=[128, 128, 2])
if args.net == "tfd":
# the same as the TensorFlow cat dog example, with dropout
net = NNorCNN(px=px,
clayers=[(3, 32, 2), (3, 32, 2), (3, 64, 2)],
layers=[128, 128, 2],
convolution_dropout=0.1,
linear_dropout=0.1)
if args.net == "tfd2":
# the same as the TensorFlow cat dog example, with dropout
net = NNorCNN(px=px,
clayers=[(3, 32, 2), (3, 32, 2), (3, 64, 2)],
layers=[128, 128, 2],
linear_dropout=0.1)
if args.save:
save = args.save
if args.load:
load = args.load
if args.traindata:
traindata = args.traindata
if args.testdata:
testdata = args.testdata
if args.notrain:
train = False
if args.notest:
test = False
if args.verbose:
verbose = int(args.verbose)
if load:
net = torch.load(load)
transformlist.append(newtransforms.Resize([px, px]))
minimaltransformlist.append(newtransforms.Resize([px, px]))
if args.transforms == "none":
pass
else:
transformlist.append(imageUtils.RandomRotate((-10, 10)))
# imageUtils.GaussianBlurring(0.6),
# needs shape fix
# imageUtils.AddGaussianNoise(0.0,0.1),
transformlist.append(
newtransforms.ColorJitter(brightness=0.2,
contrast=0.2,
saturation=0.2,
hue=0.1))
# newtransforms.ColorJitter(brightness=0.6,contrast=0.5,saturation=0.4,hue=0.3),
# transforms.Rotate(20),
transformlist.append(transforms.RandomHorizontalFlip())
transformlist.append(transforms.ToTensor())
transformlist.append(normalize)
selectedtransforms = transforms.Compose(transformlist)
minimaltransformlist.append(transforms.ToTensor())
minimaltransformlist.append(normalize)
minimaltransforms = transforms.Compose(minimaltransformlist)
if not net:
net = CNN(px=px)
traindata = ImageFolder(root=traindata, transform=selectedtransforms)
# testdata = ImageFolder(root=testdata, transform=selectedtransforms)
testdata = ImageFolder(root=testdata, transform=minimaltransforms)
num_epochs = 0
last_test_score = 0
num_no_progress_epochs = 0
while num_epochs < epochs:
if train:
if verbose > 1:
print("Train Images")
print(traindata.imgs)
print("Classes train:", traindata.classes)
trainloader = DataLoader(traindata, shuffle=True)
trainer = Trainer(net, trainloader)
tot, l = trainer.run(epochgroup)
num_epochs += epochgroup
if verbose > 0:
print('Trained samples:', tot, "loss: %.4f" % l)
if test:
if verbose > 1:
print("Test Images")
print(testdata.imgs)
print("Classes test:", testdata.classes)
testloader = DataLoader(testdata, shuffle=True)
if verbose > 0:
print("Testing: ", end='')
tester = Tester(net, testloader)
tot, c = tester.run(testepochs)
if c / tot <= last_test_score:
num_no_progress_epochs += epochgroup
else:
num_no_progress_epochs = 0
if verbose > 0:
print()
if verbose > 0:
print('Test:', c, "of", tot, ": %.4f" % (c / tot))
last_test_score = c / tot
print('Epoch:', num_epochs, "Training loss: %.4f" % l,
"Testing success: %.4f" % (c / tot), "No progress epochs",
num_no_progress_epochs)
if save:
torch.save(net, save)
'data',
image_set='train',
download=True
)
valid_dataset = CamVid(
'data',
image_set='val',
download=True
)
train_transforms = transforms.Compose([
transforms.Resize(settings.IMAGE_SIZE),
transforms.RandomRotation(15, fill=train_dataset.ignore_index),
transforms.RandomGaussianBlur(),
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(0.4, 0.4),
transforms.ToTensor(),
transforms.Normalize(settings.MEAN, settings.STD),
])
valid_transforms = transforms.Compose([
transforms.Resize(settings.IMAGE_SIZE),
transforms.ToTensor(),
transforms.Normalize(settings.MEAN, settings.STD),
])
train_dataset.transforms = train_transforms
valid_dataset.transforms = valid_transforms
train_loader = torch.utils.data.DataLoader(
train_dataset, batch_size=8, num_workers=4, shuffle=True)
def main(parser_data):
device = torch.device(
parser_data.device if torch.cuda.is_available() else "cpu")
print("Using {} device training.".format(device.type))
if not os.path.exists("save_weights"):
os.mkdir("save_weights")
results_file = "results{}.txt".format(
datetime.datetime.now().strftime("%Y%m%d-%H%M%S"))
data_transform = {
"train":
transforms.Compose([
transforms.SSDCropping(),
transforms.Resize(),
transforms.ColorJitter(),
transforms.ToTensor(),
transforms.RandomHorizontalFlip(),
transforms.Normalization(),
transforms.AssignGTtoDefaultBox()
]),
"val":
transforms.Compose([
transforms.Resize(),
transforms.ToTensor(),
transforms.Normalization()
])
}
VOC_root = parser_data.data_path
# check voc root
if os.path.exists(os.path.join(VOC_root, "VOCdevkit")) is False:
raise FileNotFoundError(
"VOCdevkit dose not in path:'{}'.".format(VOC_root))
# VOCdevkit -> VOC2012 -> ImageSets -> Main -> train.txt
train_dataset = VOCDataSet(VOC_root,
"2012",
data_transform['train'],
train_set='train.txt')
# 注意训练时，batch_size必须大于1
batch_size = parser_data.batch_size
assert batch_size > 1, "batch size must be greater than 1"
# 防止最后一个batch_size=1，如果最后一个batch_size=1就舍去
drop_last = True if len(train_dataset) % batch_size == 1 else False
nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0,
8]) # number of workers
print('Using %g dataloader workers' % nw)
train_data_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=batch_size,
shuffle=True,
num_workers=nw,
collate_fn=train_dataset.collate_fn,
drop_last=drop_last)
# VOCdevkit -> VOC2012 -> ImageSets -> Main -> val.txt
val_dataset = VOCDataSet(VOC_root,
"2012",
data_transform['val'],
train_set='val.txt')
val_data_loader = torch.utils.data.DataLoader(
val_dataset,
batch_size=batch_size,
shuffle=False,
num_workers=nw,
collate_fn=train_dataset.collate_fn)
model = create_model(num_classes=args.num_classes + 1)
model.to(device)
# define optimizer
params = [p for p in model.parameters() if p.requires_grad]
optimizer = torch.optim.SGD(params,
lr=0.0005,
momentum=0.9,
weight_decay=0.0005)
# learning rate scheduler
lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
step_size=5,
gamma=0.3)
# 如果指定了上次训练保存的权重文件地址，则接着上次结果接着训练
if parser_data.resume != "":
checkpoint = torch.load(parser_data.resume, map_location='cpu')
model.load_state_dict(checkpoint['model'])
optimizer.load_state_dict(checkpoint['optimizer'])
lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])
parser_data.start_epoch = checkpoint['epoch'] + 1
print("the training process from epoch{}...".format(
parser_data.start_epoch))
train_loss = []
learning_rate = []
val_map = []
# 提前加载验证集数据，以免每次验证时都要重新加载一次数据，节省时间
val_data = get_coco_api_from_dataset(val_data_loader.dataset)
for epoch in range(parser_data.start_epoch, parser_data.epochs):
mean_loss, lr = utils.train_one_epoch(model=model,
optimizer=optimizer,
data_loader=train_data_loader,
device=device,
epoch=epoch,
print_freq=50)
train_loss.append(mean_loss.item())
learning_rate.append(lr)
# update learning rate
lr_scheduler.step()
coco_info = utils.evaluate(model=model,
data_loader=val_data_loader,
device=device,
data_set=val_data)
# write into txt
with open(results_file, "a") as f:
# 写入的数据包括coco指标还有loss和learning rate
result_info = [
str(round(i, 4)) for i in coco_info + [mean_loss.item()]
] + [str(round(lr, 6))]
txt = "epoch:{} {}".format(epoch, ' '.join(result_info))
f.write(txt + "\n")
val_map.append(coco_info[1]) # pascal mAP
# save weights
save_files = {
'model': model.state_dict(),
'optimizer': optimizer.state_dict(),
'lr_scheduler': lr_scheduler.state_dict(),
'epoch': epoch
}
torch.save(save_files, "./save_weights/ssd300-{}.pth".format(epoch))
# plot loss and lr curve
if len(train_loss) != 0 and len(learning_rate) != 0:
from plot_curve import plot_loss_and_lr
plot_loss_and_lr(train_loss, learning_rate)
# plot mAP curve
if len(val_map) != 0:
from plot_curve import plot_map
plot_map(val_map)
faster_rcnn = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=True)
# get number of input features for the classifier
in_features = faster_rcnn.roi_heads.box_predictor.cls_score.in_features
# replace the pre-trained head with a new one
faster_rcnn.roi_heads.box_predictor = FastRCNNPredictor(in_features, classes)
return faster_rcnn
# %%
# use our dataset and defined transformations
transformations = T.Compose(
[
T.RandomHorizontalFlip(),
T.RandomGrayscale(),
T.ColorJitter(),
T.RandomResizedCrop(size=(256, 256)),
T.ToTensor(),
]
)
test_transformations = T.Compose([T.ToTensor(),])
dataset_train = dataset.FRCNNFrameDataset(
"data/images",
"data/annotations/instances_default.json",
transforms=transformations,
)
dataset_test = dataset.FRCNNFrameDataset(
"data/images",
best_top_5 = 0
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
transform = [
transforms.Scale(256),
transforms.RandomCrop(224),
# transforms.RandomResizedCrop(224)
]
# transform.extend([transforms.RandomResizedCrop(224)])
transform.extend([
# for inception 1
# transforms.ColorJitter(brightness=0.05, contrast=0.05, saturation=0.1, hue=0.0),
transforms.ColorJitter(brightness=0.05,
contrast=0.05,
saturation=0.35,
hue=0.1),
# transforms.ColorJitter(brightness=0.05, contrast=0.05, saturation=0.3, hue=0.1),
transforms.RandomHorizontalFlip(),
])
transform += [transforms.ToTensor()]
# transform.append(
# affine_transforms.Affine(rotation_range=20.0, translation_range=0.02, fill_mode='constant')
# )
transform += [normalize]
preprocess = transforms.Compose(transform)
