def main():
# augmentation
transform_aug = Compose([
aug.HueSaturationValue(),
aug.RandomBrightnessContrast(),
aug.CLAHE(),
aug.JpegCompression(),
aug.GaussNoise(),
aug.MedianBlur(),
aug.ElasticTransform(),
aug.HorizontalFlip(),
aug.Rotate(),
aug.CoarseDropout(),
aug.RandomSizedCrop()
],
p=1)
# transform for output
transform = Compose([
Resize(cons.IMAGE_SIZE, cons.IMAGE_SIZE),
Normalize(
mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5), max_pixel_value=255.0)
],
p=1)
# Dataset
'''
dataset = UkiyoeTrainDataset(
train_images_path='data',
train_labels_path='data',
valid=False,
confidence_boader=0.87,
result_path='result/model_effi_b3/efficientnet_b3_980/inference_with_c.csv',
test_images_path='data',
over_sampling=False,
transform_aug=None,
augmix=False,
mixup=False,
transform=transform)
img, label = dataset[0]
#print(img.shape)
#plt.imshow(img)
#plt.show()
'''
# train data loader
loader = load_train_data(train_images_path='data',
train_labels_path='data',
batch_size=2,
valid=False,
nfold=0,
transform_aug=None,
augmix=True,
mixup=False,
transform=transform,
as_numpy=True)
image_batch, label_batch = next(loader.__iter__())
print(image_batch[0].shape)
print(label_batch[0].shape)
'''
def val_transfrom(self, image, image_size):
transform = Compose([
Resize(image_size, image_size, interpolation=cv2.INTER_AREA),
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
ToTensorV2()
])
image_transform = transform(image=image)['image']
return image_transform
def __init__(self,
df=None,
size=150,
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
augment=True,
frames=30,
stochastic=True):
""" Dataset initialization
Parameters
----------
df : pd.DataFrame
Dataframe with preprocessed data
transform : torchvision.transforms
Transformation operations for loaded images
path : str
Path to folder with the data
frames : int
Frames to load per video
"""
assert df is not None, 'Missing dataframe for data'
self.frames = frames
self.df = df[df['nframes'] >= frames]
self.stochastic = stochastic
addtl_img = {}
for idx in range(frames):
addtl_img['image{}'.format(idx)] = 'image'
if augment:
self.transform = albumentations.Compose(
[
ShiftScaleRotate(p=0.3,
scale_limit=0.25,
border_mode=1,
rotate_limit=15),
HorizontalFlip(p=0.2),
RandomBrightnessContrast(
p=0.3, brightness_limit=0.25, contrast_limit=0.5),
MotionBlur(p=.2),
GaussNoise(p=.2),
JpegCompression(p=.2, quality_lower=50),
Normalize(mean, std)
],
additional_targets=addtl_img)
else:
self.transform = albumentations.Compose([Normalize(mean, std)])
self.resize = transforms.Resize((size, size))
def __init__(
self,
system_config: configuration.SystemConfig = configuration.SystemConfig(),
dataset_config: configuration.DatasetConfig = configuration.DatasetConfig(), # pylint: disable=redefined-outer-name
dataloader_config: configuration.DataloaderConfig = configuration.DataloaderConfig(), # pylint: disable=redefined-outer-name
optimizer_config: configuration.OptimizerConfig = configuration.OptimizerConfig(), # pylint: disable=redefined-outer-name
):
self.system_config = system_config
setup_system(system_config)
self.dataset_train = ListDataset(
root_dir=dataset_config.root_dir,
list_file='../train_anno.txt',
classes=["__background__", "person"],
mode='train',
transform=Compose(dataset_config.train_transforms),
input_size=300
)
self.loader_train = DataLoader(
dataset=self.dataset_train,
batch_size=dataloader_config.batch_size,
shuffle=True,
collate_fn=self.dataset_train.collate_fn,
num_workers=dataloader_config.num_workers,
pin_memory=True
)
self.dataset_test = ListDataset(
root_dir=dataset_config.root_dir,
list_file='../test_anno.txt',
classes=["__background__", "person"],
mode='val',
transform=Compose([Normalize(), ToTensorV2()]),
input_size=300
)
self.loader_test = DataLoader(
dataset=self.dataset_test,
batch_size=dataloader_config.batch_size,
shuffle=False,
collate_fn=self.dataset_test.collate_fn,
num_workers=dataloader_config.num_workers,
pin_memory=True
)
self.model = Detector(len(self.dataset_train.classes))
self.loss_fn = DetectionLoss(len(self.dataset_train.classes))
self.metric_fn = APEstimator(classes=self.dataset_test.classes)
self.optimizer = optim.SGD(
self.model.parameters(),
lr=optimizer_config.learning_rate,
weight_decay=optimizer_config.weight_decay,
momentum=optimizer_config.momentum
)
self.lr_scheduler = MultiStepLR(
self.optimizer, milestones=optimizer_config.lr_step_milestones, gamma=optimizer_config.lr_gamma
)
self.visualizer = MatplotlibVisualizer()
def _define_augment(self, input_shape, do_augmentation):
# mean, std, max_pixel_valueは適宜変更してください
mean = (0.485 * 255, 0.456 * 255, 0.406 * 255)
std = (0.229 * 255, 0.224 * 255, 0.225 * 255)
normalize = Normalize(mean=mean, std=std, max_pixel_value=1)
# データ拡張内容は適宜変更してください
if do_augmentation:
return Compose([normalize, HorizontalFlip(p=0.5)])
else:
return Compose([normalize])
def test_transfrom(
image,
size=256
): # note that test image size is same as crop_size in get_transfrom
transform = Compose([
Resize(size, size, interpolation=cv2.INTER_AREA),
Normalize(mean=[0.3835, 0.3737, 0.3698], std=[1.0265, 1.0440, 1.0499]),
ToTensorV2()
])
image_transform = transform(image=image)['image']
return image_transform
def __init__(self):
self.transforms = Compose([
HueSaturationValue(p=0.5),
RandomBrightnessContrast(),
GaussianBlur(),
HorizontalFlip(p=.5),
Normalize(mean=(0.4914, 0.4822, 0.4465),
std=(0.2023, 0.1994, 0.2010),
max_pixel_value=255.0,
always_apply=True,
p=1.0)
])
def _transform(self, img, mean, std):
img = np.moveaxis(img, 0, 2)
if self.mode == 'train':
img = self.transform_train(image=img)['image']
elif self.mode == 'val':
img = self.transform_val(image=img)['image']
normalize = Compose(
[Normalize(mean=mean, std=std, max_pixel_value=255.0, p=1.0)],
p=1.0)
img = normalize(image=img)['image']
img = np.moveaxis(img, 2, 0)
return img
def train_transfrom(image, size=256):
transform = Compose([
Resize(size, size, interpolation=cv2.INTER_AREA),
Flip(),
RandomBrightnessContrast(),
HueSaturationValue(),
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
ToTensorV2()
])
image_transform = transform(image=image)['image']
return image_transform
def __init__(self):
self.transforms = Compose([
PadIfNeeded(40, 40),
RandomCrop(32, 32),
HorizontalFlip(p=.5),
Cutout(8, 8),
Normalize(mean=(0.4914, 0.4822, 0.4465),
std=(0.2023, 0.1994, 0.2010),
max_pixel_value=255.0,
always_apply=True,
p=1.0),
ToTensor()
])
def rand_aug():
return Compose([
RandomRotate90(p=0.2),
GaussNoise(p=0.2),
HorizontalFlip(p=0.2),
RandomCrop(p=0.2),
HueSaturationValue(p=0.2),
RandomBrightness(p=0.2),
RandomContrast(p=0.2),
RandomGamma(p=0.2),
GaussianBlur(p=0.2),
]),
Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225), p=1.0)
def preprocess_image(img_path):
# transformations for the input data
transforms = Compose([
Resize(224, 224, interpolation=cv2.INTER_NEAREST),
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
ToTensor(),
])
# read input image
input_img = cv2.imread(img_path)
# do transformations
input_data = transforms(image=input_img)["image"]
batch_data = torch.unsqueeze(input_data, 0)
return batch_data
def main(argv=None):
loader = load_test_data(
data_path=FLAGS.test_images_path,
batch_size=1,
transform=Compose([
Resize(cons.IMAGE_SIZE,cons.IMAGE_SIZE),
Normalize(mean=(0.5,0.5,0.5),std=(0.5,0.5,0.5),max_pixel_value=255.0)]))
data_len = UkiyoeTestDataset(data_path=FLAGS.test_images_path).__len__()
confidence_sum = np.zeros((data_len,cons.NUM_CLASSES))
ratio_sum = 0
for e in range(len(PARAM_LIST)):
ratio_sum = ratio_sum + PARAM_LIST[e]['ratio']
PARAM_PATH = FLAGS.params_path + PARAM_LIST[e]['model']
model = models.get_model(model_name=PARAM_LIST[e]['model'].split('/')[2],num_classes=cons.NUM_CLASSES)
if PARAM_LIST[e]['fix']:
model.load_state_dict(fix_model_state_dict(torch.load(PARAM_PATH)))
else:
model.load_state_dict(torch.load(PARAM_PATH))
confidence_sum = confidence_sum + inference_loop(model,loader,data_len)*PARAM_LIST[e]['ratio']
pred = np.argmax(confidence_sum, axis=1)
confidence = confidence_sum/ratio_sum
if FLAGS.adjust_inference:
pred = adjust_inference(pred,confidence,data_len)
result = pd.DataFrame(columns=['id','y'])
if FLAGS.output_confidence:
result_with_c = pd.DataFrame(columns=['id','y','confidence'])
for idx,feed in enumerate(loader):
id,_ = feed
result = result.append(
pd.Series(
[id.data.numpy()[0], pred[idx]],
index=result.columns),
ignore_index=True)
if FLAGS.output_confidence:
result_with_c = result_with_c.append(
pd.Series(
[id.data.numpy()[0], pred[idx], confidence[idx,pred[idx]]],
index=result_with_c.columns),
ignore_index=True)
RESULT_DIR = FLAGS.result_path +'/'+ FLAGS.case
os.makedirs(RESULT_DIR,exist_ok=True)
result.to_csv(RESULT_DIR +'/inference.csv', index=False)
if FLAGS.output_confidence:
result_with_c[['id','y']] = result_with_c[['id','y']].astype(int)
result_with_c.to_csv(RESULT_DIR +'/inference_with_c.csv', index=False)
def ensemble_prediction(self):
ds = self.train_loader.dataset
transforms = Compose([Normalize(), ToTensorV2()])
for idx, images in tqdm(ds.images.items(), total=len(ds)):
augmented = transforms(image=images['image'])
img = augmented['image'].unsqueeze(0).to(self.config.device)
with torch.no_grad():
pred = torch.nn.functional.softmax(self.model(img), dim=1)
weight = torch.tensor(images['weight'])
pred = pred.squeeze(0).cpu()
x = pred[1]
weight[..., 0] = self.config.alpha * x + (
1 - self.config.alpha) * weight[..., 0]
self.train_loader.dataset.images[idx]['weight'] = weight.numpy()
self.n_ensemble += 1
def get_transfrom(image, size=512, crop_size=256):
transform = Compose([
Resize(size, size, interpolation=cv2.INTER_AREA),
RandomCrop(crop_size, crop_size),
Cutout(num_holes=4),
HueSaturationValue(hue_shift_limit=0.2,
sat_shift_limit=0.2,
val_shift_limit=0.2),
RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2),
Flip(),
Normalize(mean=[0.3835, 0.3737, 0.3698], std=[1.0265, 1.0440, 1.0499]),
ToTensorV2()
])
image_transform = transform(image=image)['image']
return image_transform
def test_dataloader(self):
augmentations = Compose([
Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
ToTensorV2(),
])
test_ds = MelanomaDataset(
df=self.test_df,
images_path=self.test_images_path,
augmentations=augmentations, # TODO: add TTA
train_or_valid=False,
)
return DataLoader(
test_ds,
batch_size=self.hparams.bs,
shuffle=False,
num_workers=os.cpu_count(),
pin_memory=False,
)
def main(argv=None):
PARAM_PATH = FLAGS.params_path + '/' + FLAGS.case + '/' + FLAGS.model_name + '/fold' + str(
FLAGS.nfold)
RESULT_DIR = FLAGS.result_path + '/' + FLAGS.case + '/' + FLAGS.model_name
if FLAGS.pseudo_labeling:
PARAM_PATH = PARAM_PATH + '/with_pseudo_labeling'
RESULT_DIR = RESULT_DIR + '/with_pseudo_labeling'
PARAM_PATH = PARAM_PATH + '/' + FLAGS.case
RESULT_DIR = RESULT_DIR + '/' + FLAGS.case
if FLAGS.is_best_param:
PARAM_PATH = PARAM_PATH + '_best'
RESULT_DIR = RESULT_DIR + '_best'
else:
PARAM_PATH = PARAM_PATH + '_' + str(FLAGS.executed_epoch)
RESULT_DIR = RESULT_DIR + '_' + str(FLAGS.executed_epoch)
if FLAGS.is_final_epoch:
PARAM_PATH = PARAM_PATH + '_final'
RESULT_DIR = RESULT_DIR + '_final'
PARAM_PATH = PARAM_PATH + '.pth'
loader = load_test_data(data_path=FLAGS.test_images_path,
batch_size=1,
transform=Compose([
Resize(cons.IMAGE_SIZE, cons.IMAGE_SIZE),
Normalize(mean=(0.5, 0.5, 0.5),
std=(0.5, 0.5, 0.5),
max_pixel_value=255.0)
]))
model = models.get_model(model_name=FLAGS.model_name,
num_classes=cons.NUM_CLASSES)
if FLAGS.fix_state_dict:
model.load_state_dict(fix_model_state_dict(torch.load(PARAM_PATH)))
else:
model.load_state_dict(torch.load(PARAM_PATH))
result = inference_loop(model, loader, FLAGS.output_confidence)
os.makedirs(RESULT_DIR, exist_ok=True)
result.to_csv(RESULT_DIR + '/inference.csv', index=False)
if FLAGS.output_confidence:
result.to_csv(RESULT_DIR + '/inference_with_c.csv', index=False)
def transform(self, img: t.Any) -> t.Any:
max_hw = max(img.shape[0:2])
img = PadIfNeeded(max_hw, max_hw, border_mode=cv2.BORDER_REPLICATE)(image=img)[
"image"
]
img = Resize(self.resolution, self.resolution)(image=img)["image"]
img = Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225],)(
image=img
)["image"]
if self.mode == "Train":
img = RandomResizedCrop(self.resolution, self.resolution)(image=img)[
"image"
]
img = Cutout(p=0.2)(image=img)["image"]
img = HorizontalFlip(p=0.5)(image=img)["image"]
img = ShiftScaleRotate(
shift_limit=0.1, scale_limit=0.0, rotate_limit=10, p=0.3
)(image=img)["image"]
img = ToTensorV2()(image=img)["image"]
return img
def train_dataloader(self):
augmentations = Compose([
RandomResizedCrop(
height=self.hparams.sz,
width=self.hparams.sz,
scale=(0.7, 1.0),
),
# ToGray(),
GridDistortion(),
RandomBrightnessContrast(),
ShiftScaleRotate(),
Flip(p=0.5),
CoarseDropout(
max_height=int(self.hparams.sz / 10),
max_width=int(self.hparams.sz / 10),
),
Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
max_pixel_value=255,
),
ToTensorV2(),
])
train_ds = MelanomaDataset(
df=self.train_df,
images_path=self.train_images_path,
augmentations=augmentations,
train_or_valid=True,
)
return DataLoader(
train_ds,
# sampler=sampler,
batch_size=self.hparams.bs,
shuffle=True,
num_workers=os.cpu_count(),
pin_memory=False,
)
from albumentations import (
HorizontalFlip, IAAPerspective, ShiftScaleRotate, CLAHE, RandomRotate90,
Transpose, Blur, OpticalDistortion, GridDistortion, HueSaturationValue,
IAAAdditiveGaussianNoise, GaussNoise, MotionBlur, MedianBlur, IAAPiecewiseAffine,
IAASharpen, IAAEmboss, RandomContrast, RandomBrightness, Flip, OneOf, Compose, RandomGamma,
ElasticTransform, ChannelShuffle,RGBShift, Rotate, Cutout
)
# YOUR PATH
path = f'/mnt/c/Users/bokhy/Desktop/Python/github/kaggle/bengaliai-cv19/input/'
HEIGHT = 137
WIDTH = 236
# Augmentation
train_augmentation = Compose([
Resize(HEIGHT,WIDTH, always_apply= True),
Normalize(mean, std, always_apply = True),
Rotate(),
Flip(),
OneOf([
IAAAdditiveGaussianNoise(),
GaussNoise(),
], p=0.2),
OneOf([
MotionBlur(p=0.2),
MedianBlur(blur_limit=3, p=0.1),
Blur(blur_limit=3, p=0.1),
], p=0.2),
ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=45, p=.2),
OneOf([
OpticalDistortion(p=0.3),
GridDistortion(p=.1),
print('There are ' + str(y.count(1)) + ' fake train samples')
print('There are ' + str(y.count(0)) + ' real train samples')
print('There are ' + str(val_y.count(1)) + ' fake val samples')
print('There are ' + str(val_y.count(0)) + ' real val samples')
import albumentations
from albumentations.augmentations.transforms import ShiftScaleRotate, HorizontalFlip, Normalize, RandomBrightnessContrast, MotionBlur, Blur, GaussNoise, JpegCompression
train_transform = albumentations.Compose([
ShiftScaleRotate(p=0.3, scale_limit=0.25, border_mode=1, rotate_limit=25),
HorizontalFlip(p=0.2),
RandomBrightnessContrast(p=0.3, brightness_limit=0.25, contrast_limit=0.5),
MotionBlur(p=.2),
GaussNoise(p=.2),
JpegCompression(p=.2, quality_lower=50),
Normalize()
])
val_transform = albumentations.Compose([
Normalize()
])
train_dataset = ImageDataset(X, y, transform=train_transform)
val_dataset = ImageDataset(val_X, val_y, transform=val_transform)
### Train
import gc
history = pd.DataFrame()
history2 = pd.DataFrame()
import cv2
##导入albumentations来做图像增强
input_size = 224
import albumentations
from albumentations.augmentations.transforms import Resize, RandomSizedCrop, ShiftScaleRotate, HorizontalFlip, Normalize, RandomBrightnessContrast, MotionBlur, Blur, GaussNoise, JpegCompression
train_transform = albumentations.Compose([
RandomSizedCrop(min_max_height=(input_size//3,input_size//3),height=input_size,width=input_size),
ShiftScaleRotate(p=0.3, scale_limit=0.25, border_mode=1, rotate_limit=25),
HorizontalFlip(p=0.2),
RandomBrightnessContrast(p=0.3, brightness_limit=0.25, contrast_limit=0.5),
MotionBlur(p=.2),
GaussNoise(p=.2),
JpegCompression(p=.2, quality_lower=50),
Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
val_transform = albumentations.Compose([
Resize(input_size,input_size),
Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
class MyDataset(data.Dataset):
def __init__(self,root,transforms = None,is_train=True):
"""
主要目标获取所有图片的地址
"""
fake_path = os.path.join(root,"fake")
real_path = os.path.join(root,"real")
def main():
global args, config, best_loss
args = parser.parse_args()
with open(args.config) as f:
config = yaml.load(f)
for k, v in config['common'].items():
setattr(args, k, v)
config = EasyDict(config['common'])
rank, world_size, device_id = dist_init(
os.path.join(args.distributed_path, config.distributed_file))
args.save_path_dated = args.save_path + '/' + args.datetime
if args.run_tag != '':
args.save_path_dated += '-' + args.run_tag
# create model
model = model_entry(config.model)
model.cuda()
model = nn.parallel.DistributedDataParallel(model, device_ids=[device_id])
# create optimizer
opt_config = config.optimizer
opt_config.kwargs.lr = config.lr_scheduler.base_lr
opt_config.kwargs.params = model.parameters()
optimizer = optim_entry(opt_config)
# optionally resume from a checkpoint
last_iter = -1
best_loss = 1e9
if args.load_path:
if args.recover:
best_loss, last_iter = load_state(args.load_path,
model,
optimizer=optimizer)
else:
load_state(args.load_path, model)
cudnn.benchmark = True
# train augmentation
if config.augmentation.get('imgnet_mean', False):
model_mean = (0.485, 0.456, 0.406)
model_std = (0.229, 0.224, 0.225)
else:
model_mean = (0.5, 0.5, 0.5)
model_std = (0.5, 0.5, 0.5)
trans = albumentations.Compose([
RandomResizedCrop(config.augmentation.input_size,
config.augmentation.input_size,
scale=(config.augmentation.min_scale**2., 1.),
ratio=(1., 1.)),
HorizontalFlip(p=0.5),
RandomBrightnessContrast(brightness_limit=0.25,
contrast_limit=0.1,
p=0.5),
JpegCompression(p=.2, quality_lower=50),
MotionBlur(p=0.5),
Normalize(mean=model_mean, std=model_std),
ToTensorV2()
])
train_dataset = FaceDataset(config.train_root,
config.train_source,
transform=trans,
resize=config.augmentation.input_size,
image_format=config.get('image_format', None),
random_frame=config.get(
'train_random_frame', False),
bgr=config.augmentation.get('bgr', False))
train_sampler = DistributedGivenIterationSampler(
train_dataset,
config.lr_scheduler.max_iter,
config.batch_size,
last_iter=last_iter)
train_loader = DataLoader(train_dataset,
batch_size=config.batch_size,
shuffle=False,
num_workers=config.workers,
pin_memory=True,
sampler=train_sampler)
# validation augmentation
trans = albumentations.Compose([
Resize(config.augmentation.input_size, config.augmentation.input_size),
Normalize(mean=model_mean, std=model_std),
ToTensorV2()
])
val_multi_loader = []
if args.val_source != '':
for dataset_idx in range(len(args.val_source)):
val_dataset = FaceDataset(
args.val_root[dataset_idx],
args.val_source[dataset_idx],
transform=trans,
output_index=True,
resize=config.augmentation.input_size,
image_format=config.get('image_format', None),
bgr=config.augmentation.get('bgr', False))
val_sampler = DistributedSampler(val_dataset, round_up=False)
val_loader = DataLoader(val_dataset,
batch_size=config.batch_size,
shuffle=False,
num_workers=config.workers,
pin_memory=True,
sampler=val_sampler)
val_multi_loader.append(val_loader)
config.lr_scheduler['optimizer'] = optimizer
config.lr_scheduler['last_iter'] = last_iter
lr_scheduler = get_scheduler(config.lr_scheduler)
if rank == 0:
mkdir(args.save_path)
mkdir(args.save_path_dated)
tb_logger = SummaryWriter(args.save_path_dated)
logger = create_logger('global_logger',
args.save_path_dated + '-log.txt')
logger.info('{}'.format(args))
logger.info(model)
logger.info(parameters_string(model))
logger.info('len(train dataset) = %d' % len(train_loader.dataset))
for dataset_idx in range(len(val_multi_loader)):
logger.info(
'len(val%d dataset) = %d' %
(dataset_idx, len(val_multi_loader[dataset_idx].dataset)))
mkdir(args.save_path_dated + '/saves')
else:
tb_logger = None
positive_weight = config.get('positive_weight', 0.5)
weight = torch.tensor([1. - positive_weight, positive_weight]) * 2.
if rank == 0:
logger.info('using class weights: {}'.format(weight.tolist()))
criterion = nn.CrossEntropyLoss(weight=weight).cuda()
if args.evaluate:
if args.evaluate_path:
all_ckpt = get_all_checkpoint(args.evaluate_path, args.range_list,
rank)
for ckpt in all_ckpt:
if rank == 0:
logger.info('Testing ckpt: ' + ckpt)
last_iter = -1
_, last_iter = load_state(ckpt, model, optimizer=optimizer)
for dataset_idx in range(len(val_multi_loader)):
validate(dataset_idx,
val_multi_loader[dataset_idx],
model,
criterion,
tb_logger,
curr_step=last_iter,
save_softmax=True)
else:
for dataset_idx in range(len(val_multi_loader)):
validate(dataset_idx,
val_multi_loader[dataset_idx],
model,
criterion,
tb_logger,
curr_step=last_iter,
save_softmax=True)
return
train(train_loader, val_multi_loader, model, criterion, optimizer,
lr_scheduler, last_iter + 1, tb_logger)
return
print('There are ' + str(y.count(1)) + ' fake train samples')
print('There are ' + str(y.count(0)) + ' real train samples')
print('There are ' + str(val_y.count(1)) + ' fake val samples')
print('There are ' + str(val_y.count(0)) + ' real val samples')
import albumentations
from albumentations.augmentations.transforms import ShiftScaleRotate, HorizontalFlip, Normalize, RandomBrightnessContrast, MotionBlur, Blur, GaussNoise, JpegCompression
train_transform = albumentations.Compose([
ShiftScaleRotate(p=0.3, scale_limit=0.25, border_mode=1, rotate_limit=25),
HorizontalFlip(p=0.2),
RandomBrightnessContrast(p=0.3, brightness_limit=0.25, contrast_limit=0.5),
MotionBlur(p=.2),
GaussNoise(p=.2),
JpegCompression(p=.2, quality_lower=50),
Normalize()
])
val_transform = albumentations.Compose([Normalize()])
train_dataset = ImageDataset(X, y, transform=train_transform)
val_dataset = ImageDataset(val_X, val_y, transform=val_transform)
nrow, ncol = 5, 6
fig, axes = plt.subplots(nrow, ncol, figsize=(20, 8))
axes = axes.flatten()
for i, ax in enumerate(axes):
image, label = train_dataset[i]
image = np.rollaxis(image, 0, 3)
image = image * std + mean
image = np.clip(image, 0., 1.)
ax.imshow(image)
# Downloading dataset
DataSetDownloader(root_dir='data', dataset_title='PennFudanPed', download=True)
dataset_config = configuration.DatasetConfig(
root_dir="data/PennFudanPed/",
train_transforms=[
RandomBrightness(p=0.5),
RandomContrast(p=0.5),
OneOf([
RandomGamma(),
HueSaturationValue(hue_shift_limit=20, sat_shift_limit=50, val_shift_limit=50),
RGBShift()
],
p=1),
OneOf([Blur(always_apply=True), GaussNoise(always_apply=True)], p=1),
CLAHE(),
Normalize(),
ToTensorV2()
]
)
optimizer_config = configuration.OptimizerConfig(
learning_rate=5e-3,
lr_step_milestones=[50],
lr_gamma=0.1,
momentum=0.9,
weight_decay=1e-5
)
experiment = Experiment(
dataset_config=dataset_config,
dataloader_config=dataloader_config,
def main(argv=None):
transform = Compose([
Resize(cons.IMAGE_SIZE, cons.IMAGE_SIZE),
Normalize(mean=(0.5, 0.5, 0.5),
std=(0.5, 0.5, 0.5),
max_pixel_value=255.0)
])
valid_loader = load_train_data(train_images_path=FLAGS.train_images_path,
train_labels_path=FLAGS.train_labels_path,
batch_size=FLAGS.batch_size,
num_worker=FLAGS.num_worker,
valid=True,
nfold=FLAGS.nfold,
transform=transform)
model = models.get_model(model_name=FLAGS.model_name,
num_classes=cons.NUM_CLASSES)
model.cuda()
#model = torch.nn.DataParallel(model)
DIR = '/' + FLAGS.case + '/' + FLAGS.model_name + '/fold' + str(
FLAGS.nfold)
RESULT_PATH = ''
if FLAGS.confidence_border is not None:
DIR = DIR + '/with_pseudo_labeling'
RESULT_PATH = RESULT_PATH + FLAGS.result_path
if FLAGS.result_case is not None:
RESULT_PATH = RESULT_PATH + '/' + FLAGS.result_case
RESULT_PATH = RESULT_PATH + '/inference_with_c.csv'
PARAM_DIR = FLAGS.params_path + DIR
os.makedirs(PARAM_DIR, exist_ok=True)
PARAM_NAME = PARAM_DIR + '/' + FLAGS.case
if FLAGS.executed_epoch > 0:
TRAINED_PARAM_PATH = FLAGS.restart_param_path + '/' + FLAGS.case + str(
FLAGS.executed_epoch)
restart_epoch = FLAGS.executed_epoch + 1
if FLAGS.restart_from_final:
TRAINED_PARAM_PATH = TRAINED_PARAM_PATH + '_final'
TRAINED_PARAM_PATH = TRAINED_PARAM_PATH + '.pth'
model.load_state_dict(torch.load(TRAINED_PARAM_PATH))
else:
restart_epoch = 0
optimizer = optim.Adam(model.parameters(), lr=cons.start_lr)
model, optimizer = amp.initialize(model,
optimizer,
opt_level=FLAGS.opt_level)
if FLAGS.add_class_weight:
loader = load_train_data(train_images_path=FLAGS.train_images_path,
train_labels_path=FLAGS.train_labels_path,
batch_size=FLAGS.batch_size,
num_worker=FLAGS.num_worker,
nfold=FLAGS.nfold)
count_label = np.zeros(10, dtype=np.int64)
for feed in loader:
_, labels = feed
count_label += np.sum(labels.numpy().astype(np.int64), axis=0)
weight = torch.from_numpy(count_label).cuda()
else:
weight = None
criterion = nn.BCEWithLogitsLoss(weight=weight)
writer = SummaryWriter(log_dir=FLAGS.logs_path + DIR + '/tensorboardX/')
best_acc = 0
if FLAGS.augmentation and FLAGS.aug_decrease:
p = 0.5
for e in range(restart_epoch, FLAGS.final_epoch):
p_partical = p * (FLAGS.final_epoch - e) / FLAGS.final_epoch
lr = set_lr.cosine_annealing(optimizer, cons.start_lr, e, 100)
writer.add_scalar('LearningRate', lr, e)
train_loader = load_train_data(
train_images_path=FLAGS.train_images_path,
train_labels_path=FLAGS.train_labels_path,
batch_size=FLAGS.batch_size,
num_worker=FLAGS.num_worker,
nfold=FLAGS.nfold,
confidence_border=FLAGS.confidence_border,
result_path=RESULT_PATH,
test_images_path=FLAGS.test_images_path,
over_sampling=FLAGS.over_sampling,
transform_aug=Compose([
aug.HueSaturationValue(p=p_partical),
aug.RandomBrightnessContrast(p=p_partical),
aug.CLAHE(p=p_partical),
aug.JpegCompression(p=p_partical),
aug.GaussNoise(p=p),
aug.MedianBlur(p=p),
aug.ElasticTransform(p=p_partical),
aug.HorizontalFlip(p=p),
aug.Rotate(p=p),
aug.CoarseDropout(p=p_partical),
aug.RandomSizedCrop(p=p)
]),
mixup=FLAGS.mixup,
transform=transform)
train_loss = train_loop(model, train_loader, criterion, optimizer)
writer.add_scalar('train_loss', train_loss, e)
valid_loss, valid_acc = valid_loop(model, valid_loader, criterion)
writer.add_scalar('valid_loss', valid_loss, e)
writer.add_scalar('valid_acc', valid_acc, e)
print(
'Epoch: {}, Train Loss: {:.4f}, Valid Loss: {:.4f}, Valid Accuracy:{:.2f}'
.format(e + 1, train_loss, valid_loss, valid_acc))
if e % 10 == 0:
torch.save(model.state_dict(),
PARAM_NAME + '_' + str(e) + '.pth')
if valid_acc > best_acc:
best_acc = valid_acc
torch.save(model.state_dict(), PARAM_NAME + '_best.pth')
else:
if FLAGS.augmentation and not FLAGS.augmix:
transform_aug = Compose([
aug.HueSaturationValue(),
aug.RandomBrightnessContrast(),
aug.CLAHE(),
aug.JpegCompression(),
aug.GaussNoise(),
aug.MedianBlur(),
aug.ElasticTransform(),
aug.HorizontalFlip(),
aug.Rotate(),
aug.CoarseDropout(),
aug.RandomSizedCrop()
])
else:
transform_aug = None
train_loader = load_train_data(
train_images_path=FLAGS.train_images_path,
train_labels_path=FLAGS.train_labels_path,
batch_size=FLAGS.batch_size,
num_worker=FLAGS.num_worker,
valid=False,
nfold=FLAGS.nfold,
over_sampling=FLAGS.over_sampling,
transform_aug=transform_aug,
augmix=FLAGS.augmix,
mixup=FLAGS.mixup,
transform=transform)
total_time = 0
for e in range(restart_epoch, FLAGS.final_epoch):
start = time.time()
lr = set_lr.cosine_annealing(optimizer, cons.start_lr, e, 100)
writer.add_scalar('LearningRate', lr, e)
train_loss = train_loop(model, train_loader, criterion, optimizer)
writer.add_scalar('train_loss', train_loss, e)
valid_loss, valid_acc = valid_loop(model, valid_loader, criterion)
writer.add_scalar('valid_loss', valid_loss, e)
writer.add_scalar('valid_acc', valid_acc, e)
print(
'Epoch: {}, Train Loss: {:.4f}, Valid Loss: {:.4f}, Valid Accuracy:{:.2f}'
.format(e + 1, train_loss, valid_loss, valid_acc))
if e % 10 == 0:
torch.save(model.state_dict(),
PARAM_NAME + '_' + str(e) + '.pth')
if valid_acc > best_acc:
best_acc = valid_acc
torch.save(model.state_dict(), PARAM_NAME + '_best.pth')
total_time = total_time + (time.time() - start)
print('average time: {}[sec]'.format(total_time / (e + 1)))
torch.save(model.state_dict(),
PARAM_NAME + '_' + str(FLAGS.final_epoch - 1) + '_final.pth')
print('\n[Phase 1] : Data Preparation')
transform_train =
Compose([
Compose([
RandomRotate90(p=0.2),
GaussNoise(p=0.2),
HorizontalFlip(p=0.2),
RandomCrop(p=0.2),
HueSaturationValue(p=0.2),
RandomBrightness(p=0.2),
RandomContrast(p=0.2),
RandomGamma(p=0.2),
GaussianBlur(p=0.2)
], p=1.0),
ToTensor(),
Normalize(mean=mean[dataset], std=std[dataset], p=1.0)
], p=1.0)
])
transform_test = Compose([
ToTensor(),
Normalize(mean=mean[dataset], std=std[dataset], p=1.0),
])
if(dataset == 'cifar10'):
print("| Preparing CIFAR-10 dataset...")
sys.stdout.write("| ")
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train)
testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=False, transform=transform_test)
num_classes = 10
elif(dataset == 'cifar100'):
