def __init__(self, image_size, train=True):
args = get_args()
assert args.fp16 or args.bf16
self.data_type = torch.half if args.fp16 else torch.bfloat16
if train:
self.transform = T.Compose([
T.RandomResizedCrop(image_size),
T.RandomHorizontalFlip(),
T.ColorJitter(0.4, 0.4, 0.4, 0.1),
ImageNetPolicy(),
T.ToTensor(),
T.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
T.ConvertImageDtype(self.data_type)
])
else:
self.transform = T.Compose([
T.Resize(image_size),
T.CenterCrop(image_size),
T.ToTensor(),
T.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
T.ConvertImageDtype(self.data_type)
])
def get_transform_imagenet(mode: str,
use_tuple: bool = False,
auto_augment: bool = False) -> transforms.Compose:
if mode == 'train':
transform_list = [
transforms.RandomResizedCrop((224, 224) if use_tuple else 224),
transforms.RandomHorizontalFlip(),
# transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4), # noqa
]
if auto_augment:
transform_list.append(
transforms.AutoAugment(transforms.AutoAugmentPolicy.IMAGENET))
transform_list.append(transforms.PILToTensor())
transform_list.append(transforms.ConvertImageDtype(torch.float))
transform = transforms.Compose(transform_list)
else:
# TODO: torchvision.prototypes.transforms._presets.ImageClassificationEval
transform = transforms.Compose([
transforms.Resize((256, 256) if use_tuple else 256),
transforms.CenterCrop((224, 224) if use_tuple else 224),
transforms.PILToTensor(),
transforms.ConvertImageDtype(torch.float)
])
return transform
def get_transform_cifar(
mode: str,
auto_augment: bool = False,
cutout: bool = False,
cutout_length: int = None,
data_shape: list[int] = [3, 32, 32]) -> transforms.Compose:
if mode != 'train':
return transforms.Compose([
transforms.PILToTensor(),
transforms.ConvertImageDtype(torch.float)
])
cutout_length = cutout_length or data_shape[-1] // 2
transform_list = [
transforms.RandomCrop(data_shape[-2:], padding=data_shape[-1] // 8),
transforms.RandomHorizontalFlip(),
]
if auto_augment:
transform_list.append(
transforms.AutoAugment(transforms.AutoAugmentPolicy.CIFAR10))
transform_list.append(transforms.PILToTensor())
transform_list.append(transforms.ConvertImageDtype(torch.float))
if cutout:
transform_list.append(Cutout(cutout_length))
return transforms.Compose(transform_list)
def test_float_to_float(self):
input_dtype = torch.float32
output_dtype = torch.float64
input_image = torch.tensor((0.0, 1.0), dtype=input_dtype)
transform = transforms.ConvertImageDtype(output_dtype)
transform_script = torch.jit.script(F.convert_image_dtype)
output_image = transform(input_image)
output_image_script = transform_script(input_image, output_dtype)
# TODO(b/181966788) Uncomment after upgrade to pytorch 1.9.0 is done.
# torch.testing.assert_close(output_image_script, output_image, rtol=0.0, atol=1e-6)
actual_min, actual_max = output_image.tolist()
self.assertAlmostEqual(0, actual_min)
self.assertAlmostEqual(1, actual_max)
def __init__(self, imgs, latent_values, color_mode='rgb'):
self.imgs = imgs
self.latent_values = latent_values
image_transforms = [trans.ToTensor(),
trans.ConvertImageDtype(torch.float32),
trans.Lambda(lambda x: x.flatten())]
if color_mode == 'hsv':
image_transforms.insert(0, trans.Lambda(rgb2hsv))
latent_transforms = [trans.Lambda(lambda x: x * self.lat_sizes),
trans.Lambda(lambda x: torch.from_numpy(x).to(
dtype=torch.float32))]
self.transform = trans.Compose(image_transforms)
self.target_transform = trans.Compose(latent_transforms)
async def initialize_job(self, job_args):
return_type = job_args.get("return_type", "serialize")
if return_type == "save":
job_args["return_type"] = BGSplittingMapper.ReturnType.SAVE
elif return_type == "serialize":
job_args["return_type"] = BGSplittingMapper.ReturnType.SERIALIZE
else:
raise ValueError(f"Unknown return type: {return_type}")
# Get checkpoint data
if job_args["checkpoint_path"] == 'TEST':
model = Model(num_main_classes=2, num_aux_classes=1)
else:
map_location = torch.device(
'cuda') if self.use_cuda else torch.device('cpu')
checkpoint_state = torch.load(job_args["checkpoint_path"],
map_location=map_location)
from collections import OrderedDict
new_state_dict = OrderedDict()
for k, v in checkpoint_state['state_dict'].items():
name = k[7:] # remove `module.`
new_state_dict[name] = v
if 'model_kwargs' in checkpoint_state:
kwargs = checkpoint_state['model_kwargs']
num_aux_classes = kwargs['num_aux_classes']
else:
num_aux_classes = 1
# Create model
model = Model(num_main_classes=2, num_aux_classes=num_aux_classes)
# Load model weights
model.load_state_dict(new_state_dict)
model.eval()
if self.use_cuda:
model = model.cuda()
job_args["model"] = model
job_args["transform"] = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ConvertImageDtype(torch.float32),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
job_args["n_chunks_saved"] = 0
return job_args
def get_transform(self,
mode: str,
normalize: bool = None) -> transforms.Compose:
r"""Get dataset transform based on :attr:`self.transform`.
* ``None |'none'`` (:any:`torchvision.transforms.PILToTensor`
and :any:`torchvision.transforms.ConvertImageDtype`)
* ``'bit'`` (transform used in BiT network)
* ``'pytorch'`` (pytorch transform used in ImageNet training).
Args:
mode (str): The dataset mode (e.g., ``'train' | 'valid'``).
normalize (bool | None):
Whether to use :any:`torchvision.transforms.Normalize`
in dataset transform. Defaults to ``self.normalize``.
Returns:
torchvision.transforms.Compose: The transform sequence.
"""
normalize = normalize if normalize is not None else self.normalize
if self.transform == 'bit':
return get_transform_bit(mode, self.data_shape)
elif self.data_shape == [3, 224, 224]:
transform = get_transform_imagenet(
mode,
use_tuple=self.transform != 'pytorch',
auto_augment=self.auto_augment)
elif self.transform != 'none' and self.data_shape in ([3, 16, 16
], [3, 32, 32]):
transform = get_transform_cifar(mode,
auto_augment=self.auto_augment,
cutout=self.cutout,
cutout_length=self.cutout_length,
data_shape=self.data_shape)
else:
transform = transforms.Compose([
transforms.PILToTensor(),
transforms.ConvertImageDtype(torch.float)
])
if normalize and self.norm_par is not None:
transform.transforms.append(
transforms.Normalize(mean=self.norm_par['mean'],
std=self.norm_par['std']))
return transform
def test_convert_image_dtype(device, in_dtype, out_dtype):
tensor, _ = _create_data(26, 34, device=device)
batch_tensors = torch.rand(4, 3, 44, 56, device=device)
in_tensor = tensor.to(in_dtype)
in_batch_tensors = batch_tensors.to(in_dtype)
fn = T.ConvertImageDtype(dtype=out_dtype)
scripted_fn = torch.jit.script(fn)
if (in_dtype == torch.float32 and out_dtype in (torch.int32, torch.int64)) or \
(in_dtype == torch.float64 and out_dtype == torch.int64):
with pytest.raises(RuntimeError, match=r"cannot be performed safely"):
_test_transform_vs_scripted(fn, scripted_fn, in_tensor)
with pytest.raises(RuntimeError, match=r"cannot be performed safely"):
_test_transform_vs_scripted_on_batch(fn, scripted_fn, in_batch_tensors)
return
_test_transform_vs_scripted(fn, scripted_fn, in_tensor)
_test_transform_vs_scripted_on_batch(fn, scripted_fn, in_batch_tensors)
def test_sort():
# img = Image.open('/Users/shuqin/Downloads/2DMOT2015/train/ETH-Sunnyday/img1/000001.jpg')
# x = transform(img)[None]
model = SORT()
model.eval()
transform = T.Compose([
T.PILToTensor(),
T.ConvertImageDtype(torch.float)
])
img_list = ['000001.jpg', '000002.jpg', '000003.jpg']
dir_path = '/Users/shuqin/Downloads/2DMOT2015/train/ETH-Sunnyday/img1'
for img in img_list:
img = os.path.join(dir_path, img)
x = transform(Image.open(img))[None]
bbox = model(x)
img = x.cpu().numpy().squeeze().transpose(1, 2, 0)
plot_bbox(img, bbox)
def get_transform_npy(opt, params=None, grayscale=False, scale='A'):
transform_list = [
transforms.ToTensor(),
transforms.ConvertImageDtype(torch.float)
]
if not opt.no_flip:
if params is None:
transform_list.append(transforms.RandomHorizontalFlip())
elif params['flip']:
transform_list.append(
transforms.Lambda(lambda img: __flip_npy(img, params['flip'])))
if 'crop' in opt.preprocess:
if params is None:
transform_list.append(transforms.RandomCrop(opt.crop_size))
else:
transform_list.append(
transforms.Lambda(lambda img: __crop(img, params['crop_pos'],
opt.crop_size)))
if scale == 'A':
if grayscale:
transform_list += [transforms.Normalize((0.5, ), (0.5, ))]
else:
transform_list += [
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
]
elif scale == 'B':
if grayscale:
transform_list += [
transforms.Normalize((opt.B_bias, ), (opt.B_range, ))
]
else:
transform_list += [
transforms.Normalize((opt.B_bias, opt.B_bias, opt.B_bias),
(opt.B_range, opt.B_range, opt.B_range))
]
return transform_list
def build_train_valid_datasets(data_path, crop_size=224, color_jitter=True):
# training dataset
train_data_path = os.path.join(data_path[0], "train")
normalize = transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
process = [
transforms.RandomResizedCrop(crop_size),
transforms.RandomHorizontalFlip(),
]
if color_jitter:
process += [
transforms.ColorJitter(
brightness=0.4, contrast=0.4, saturation=0.4, hue=0.1
)
]
fp16_t = transforms.ConvertImageDtype(torch.half)
process += [ImageNetPolicy(), transforms.ToTensor(), normalize, fp16_t]
transform_train = transforms.Compose(process)
train_data = datasets.ImageFolder(
root=train_data_path, transform=transform_train
)
# validation dataset
val_data_path = os.path.join(data_path[0], "val")
transform_val = transforms.Compose(
[
transforms.Resize(crop_size),
transforms.CenterCrop(crop_size),
transforms.ToTensor(),
normalize,
fp16_t
]
)
val_data = datasets.ImageFolder(
root=val_data_path, transform=transform_val
)
return train_data, val_data
out_path = os.path.join(prepared_path, f"set_{index + 1}", "images")
if os.path.exists(out_path):
if input(f"set_{index + 1} exists. Delete? (y/N)") == "y":
shutil.rmtree(out_path)
else:
index += 1
cur_size = cur_size * 2
continue
os.makedirs(out_path)
transformation = transforms.Compose([
transforms.Resize((cur_size, cur_size)),
transforms.ToTensor(),
transforms.ConvertImageDtype(float),
])
images = datasets.ImageFolder(os.path.join(dest_fold, ".."),
transformation)
dataset = torch.utils.data.DataLoader(
images,
batch_size=16,
shuffle=True,
num_workers=3,
)
for batch, _ in tqdm(dataset):
for im in batch:
image_name = f"image-{image}.png"
def get_data(batch_size, test_batch_size):
# Transformations applied to both training and testing
transform = list()
transform.append(T.ConvertImageDtype(torch.float))
transform.append(
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), )
transform.append(T.Resize((256, 128)))
# Transformations applied to training only
training_transform = list()
training_transform.append(T.RandomRotation(5))
training_transform.append(T.RandomCrop((256, 128), 10))
training_transform.append(T.RandomHorizontalFlip())
# Get data from the dataset
full_training_data = Market1501Dataset(
os.path.join("dataset", "train"),
os.path.join("dataset", "annotations_train.csv"),
transform=T.Compose(transform + training_transform),
)
test_data = Market1501Dataset(
os.path.join("dataset", "test"),
transform=T.Compose(transform),
)
query_data = Market1501Dataset(
os.path.join("dataset", "queries"),
transform=T.Compose(transform),
)
# Create train and validation splits
num_samples = len(full_training_data)
training_samples = int(num_samples * 0.7 + 1)
# Find the last person in the training set so to not cut data
person_id = full_training_data.dict[training_samples][1]
while (person_id == full_training_data.dict[training_samples][1]):
training_samples += 1
person_id = full_training_data.dict[training_samples][1]
# Create training and validation subset
training_data = torch.utils.data.Subset(
full_training_data,
list(range(0, training_samples)),
)
validation_data = torch.utils.data.Subset(
full_training_data,
list(range(training_samples, num_samples)),
)
# Initialize dataloaders
train_loader = torch.utils.data.DataLoader(
training_data,
batch_size,
shuffle=True,
num_workers=0,
)
val_loader = torch.utils.data.DataLoader(
validation_data,
test_batch_size,
shuffle=False,
num_workers=0,
)
test_loader = torch.utils.data.DataLoader(
test_data,
test_batch_size,
shuffle=False,
num_workers=0,
)
query_loader = torch.utils.data.DataLoader(
query_data,
test_batch_size,
shuffle=False,
num_workers=0,
)
return train_loader, val_loader, test_loader, query_loader, person_id
def __init__(self,
directory: str,
fname: str = 'index.csv',
labels: str = 'label.csv',
reverse_index: str = 'reverse_index.json',
mean: List[float] = [0.48898, 0.46544, 0.42956],
std: List[float] = [1, 1, 1],
skip_image: bool = False,
skip_masks: bool = False,
target_concept: Union[BrodenConcept,
List[BrodenConcept]] = None,
categories: List[str] = ['object', 'part', 'material'],
return_index: bool = False):
# Compose index file path
self.directory = directory
# Read index from file
index = os.path.join(directory, fname)
with open(index, 'r') as fp:
csv_reader = DictReader(fp)
self.index = [row for row in csv_reader]
# Read labels from file
labels_path = os.path.join(directory, labels)
with open(labels_path, 'r') as fp:
csv_reader = DictReader(fp)
self.labels = {int(row['number']): {**row} for row in csv_reader}
# Reverse index
if reverse_index:
reverse_index_path = os.path.join(directory, reverse_index)
with open(reverse_index_path, 'r') as fp:
self.reverse_index = json.load(fp)
# Convert string IDs to int IDs
self.reverse_index = {
int(k): v
for k, v in self.reverse_index.items()
}
# Store preferences
self.skip_image = skip_image
self.skip_masks = skip_masks
self.categories = categories
self.target_concept = target_concept
self.return_index = return_index
# Adjust path
for row in self.index:
row['path'] = os.path.join(self.directory, 'images', row['image'])
# Parse integers
for row in self.index:
for key in row:
if key in ['ih', 'iw', 'sh', 'sw']:
row[key] = int(row[key])
# Split lists
for row in self.index:
for key in row:
if key in self.categories:
if row[key]:
row[key] = row[key].split(';')
# Normalize
self.mean = mean
self.std = std
self.normalizer = transforms.Compose([
transforms.ConvertImageDtype(torch.float32),
transforms.Normalize(mean=self.mean, std=self.std)
])
def main():
import argparse
from tqdm import tqdm
import matplotlib.pyplot as plt
from pprint import pprint
import random
from torch.utils.data import DataLoader
from distutils.util import strtobool
from pathlib import Path
import shutil
parser = argparse.ArgumentParser(description='datasetクラス単体テスト', formatter_class=argparse.ArgumentDefaultsHelpFormatter, fromfile_prefix_chars='@')
parser.add_argument('-d','--dataset_dir', default="dataset/train", help='')
parser.add_argument('-bs', '--batch_size', type=int, default=2, help='バッチサイズ')
parser.add_argument('--workers', type=int, default=4,
metavar='N', help='dataloader threads')
parser.add_argument('--no-cuda', action='store_true', default=
False, help='disables CUDA training')
parser.add_argument('-s','--split', type=str, default='train', help='')
parser.add_argument('-hf', '--horizontal_flip', type=str, default='True', help='')
parser.add_argument('-hsr', '--horizontal_shift_ratio', type=float, default=0.125, help='')
parser.add_argument('-vsr', '--vertical_shift_ratio', type=float, default=0.125, help='')
parser.add_argument('-re', '--random_erasing', type=str, default='True', help='')
parser.add_argument('-mu', '--random_mix_up', type=str, default='True', help='')
args = parser.parse_args()
pprint(args.__dict__)
# 再現性を上げるためrandomを使用している場合はrandom.seed()でseedを設定する
random.seed(0)
# numpyで再現性を上げるためのの設定
np.random.seed(0)
# pytorchで再現性を上げるための設定
torch.manual_seed(0)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
pipeline = [
tr.ConvertImageDtype(torch.float32),
tr.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
]
if strtobool(args.horizontal_flip) == 1:
pipeline.append(tr.RandomHorizontalFlip(p=0.5))
pipeline.append(tr.RandomAffine(0,translate=(args.horizontal_shift_ratio,args.vertical_shift_ratio)))
if strtobool(args.random_erasing) == 1:
pipeline.append(tr.RandomErasing())
if args.no_cuda is strtobool(args.random_mix_up):
pipeline.append(K.RandomMixUp())
transform = nn.Sequential(*pipeline)
if args.no_cuda is False:
transform.to(torch.device('cuda:0'))
dataset=PlantPathologyDataset(args, split=args.split, transform=transform)
kwargs = {'num_workers': args.workers, 'pin_memory': True}
train_loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True, drop_last=True, **kwargs)
# mean,std=(0.485, 0.456, 0.406), (0.229, 0.224, 0.225)
mean,std=(0.5, 0.5, 0.5), (0.5, 0.5, 0.5)
output_dir=Path('augumented_images')
if output_dir.exists():
shutil.rmtree(str(output_dir))
output_dir.mkdir(parents=True, exist_ok=True)
tbar = tqdm(train_loader)
num_img_tr = len(train_loader)
for index, sample in enumerate(tbar):
images, targets = sample['image'],sample['label']
if args.no_cuda is False:
images, targets = images.cpu().detach().numpy(), targets.cpu().detach().numpy()
else:
images, targets = images.detach().numpy(), targets.detach().numpy()
print(targets)
for image_num, image in enumerate(images):
img=image.transpose(1,2,0)
img*=std
img+=mean
img*=255.
img=img.astype(np.uint8)
plt.imshow(img)
plt.savefig(str(output_dir)+os.sep+str(index)+"_"+str(image_num)+".jpg")
# plt.show()
"""
return out, self.loss(out, labels)
return out
model = CustomResNet18(10)
# Casting a model's parameters
model = model.half()
# Prepare the data
transform = transforms.Compose([
transforms.Grayscale(num_output_channels=3),
transforms.Resize(224),
transforms.ToTensor(),
transforms.Normalize((0.5, ), (0.5, )),
transforms.ConvertImageDtype(torch.half)
])
train_dataset = torchvision.datasets.FashionMNIST("./datasets/",
transform=transform,
download=True,
train=True)
test_dataset = torchvision.datasets.FashionMNIST("./datasets/",
transform=transform,
download=True,
train=False)
# Optimizer and loss scaling
optimizer = poptorch.optim.SGD(model.parameters(), lr=0.001, loss_scaling=1000)
# Set PopTorch's options
opts = poptorch.Options()
def train(config, checkpoint=None):
# Load constants.
c_lambda = int(config.get("gradient_lambda", 10))
noise_size = int(config.get("noise_length", 512))
device = config.get("device", "cuda")
beta_1 = float(config.get("beta_1", 0.00))
beta_2 = float(config.get("beta_2", 0.99))
learning_rate = float(config.get("lr", 0.001))
critic_repeats = int(config.get("critic_repeats", 1))
use_r1_loss = str(config.get("use_r1", "True")) == "True"
num_workers = int(config.get("dataloader_threads", 2))
display_step = int(config.get("display_step", 250))
checkpoint_step = int(config.get("checkpoint_step", 2000))
refresh_stat_step = int(config.get("refresh_stat_step", 5))
# The batch size in each image size progression.
batch_progression = config.get("batch_progression").split(",")
batch_progression = list(map(int, batch_progression))
# The number of epochs in each image size progression.
epoch_progresson = config.get("epoch_progression").split(",")
epoch_progresson = list(map(int, epoch_progresson))
# Percentage of each step that will be a fade in.
fade_in_percentage = float(config.get("fade_percentage", 0.5))
transformation = transforms.Compose([
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5), inplace=True),
transforms.ConvertImageDtype(float),
])
# Path to dataset.
data_path = config.get("data", None)
if not os.path.exists(os.path.join(data_path, "prepared")):
raise OSError("Did not detect prepared dataset!")
# Initialize Generator
gen = Generator().to(device)
gen_opt = torch.optim.Adam(
[
{
"params": gen.to_w_noise.parameters(),
"lr": (learning_rate * 0.01),
},
{
"params": gen.gen_blocks.parameters()
},
{
"params": gen.to_rgbs.parameters()
},
],
lr=learning_rate,
betas=(beta_1, beta_2),
)
gen = nn.DataParallel(gen)
gen.train()
# Initialize Critic
critic = Critic().to(device)
critic_opt = torch.optim.Adam(critic.parameters(),
lr=learning_rate,
betas=(beta_1, beta_2))
critic = nn.DataParallel(critic)
critic.train()
# Create a constant set of noise vectors to show image progression.
show_noise = get_truncated_noise(25, 512, 0.75).to(device)
# Some other variables to track.
iters = 0
c_loss_history = []
g_loss_history = []
if checkpoint is not None:
save = torch.load(checkpoint)
gen.load_state_dict(save["gen"])
critic.load_state_dict(save["critic"])
iters = save["iter"]
im_count = save["im_count"]
last_step = save["step"]
last_epoch = save["epoch"]
else:
last_step = None
last_epoch = None
for index, step_epochs in enumerate(epoch_progresson):
if last_step is not None and index + 1 < last_step:
continue
steps = int(index + 1)
im_count = 0
images = datasets.ImageFolder(
os.path.join(data_path, "prepared", f"set_{steps}"),
transformation)
dataset = torch.utils.data.DataLoader(
images,
batch_size=batch_progression[index],
shuffle=True,
num_workers=num_workers,
)
fade_in = fade_in_percentage * step_epochs * len(dataset)
print(f"STARTING STEP #{steps}")
for epoch in range(step_epochs):
if last_epoch is not None and epoch < last_epoch:
continue
else:
last_epoch = None
pbar = tqdm(dataset)
for real_im, _ in pbar:
cur_batch_size = len(real_im)
set_requires_grad(critic, True)
set_requires_grad(gen, False)
for i in range(critic_repeats):
z_noise = get_truncated_noise(cur_batch_size, noise_size,
0.75).to(device)
alpha = im_count / fade_in
if alpha > 1.0:
alpha = None
fake_im = gen(z_noise, steps=steps, alpha=alpha)
real_im = (torch.nn.functional.interpolate(
real_im,
size=(fake_im.shape[2], fake_im.shape[3]),
mode="bilinear",
).to(device, dtype=torch.float).requires_grad_())
critic_fake_pred = critic(fake_im.detach(), steps, alpha)
critic_real_pred = critic(real_im, steps, alpha)
critic.zero_grad()
if use_r1_loss:
c_loss = critic.module.get_r1_loss(
critic_fake_pred,
critic_real_pred,
real_im,
fake_im,
steps,
alpha,
c_lambda,
)
else:
c_loss = critic.module.get_wgan_loss(
critic_fake_pred,
critic_real_pred,
real_im,
steps,
alpha,
c_lambda,
)
critic_opt.step()
im_count += cur_batch_size
c_loss_history.append(c_loss.item())
set_requires_grad(critic, False)
set_requires_grad(gen, True)
noise = get_truncated_noise(cur_batch_size, noise_size,
0.75).to(device)
alpha = im_count / fade_in
if alpha > 1.0:
alpha = None
fake_images = gen(noise, steps=steps, alpha=alpha)
critic_fake_pred = critic(fake_images, steps, alpha)
if use_r1_loss:
g_loss = gen.module.get_r1_loss(critic_fake_pred)
else:
g_loss = gen.module.get_wgan_loss(critic_fake_pred)
gen.zero_grad()
g_loss.backward()
gen_opt.step()
g_loss_history.append(g_loss.item())
iters += 1
if iters > 0 and iters % refresh_stat_step == 0:
avg_c_loss = (sum(c_loss_history[-refresh_stat_step:]) /
refresh_stat_step)
avg_g_loss = (sum(g_loss_history[-refresh_stat_step:]) /
refresh_stat_step)
pbar.set_description(
f"g_loss: {avg_g_loss:.3} c_loss: {avg_c_loss:.3} epoch: {epoch + 1}",
refresh=True,
)
with torch.no_grad():
examples = gen(show_noise, alpha=alpha, steps=steps)
if iters > 0 and iters % display_step == 0:
display_image(
torch.clamp(examples, 0, 1),
save_to_disk=True,
filename="s-{}".format(iters),
title="Iteration {}".format(iters),
num_display=25,
)
if iters > 0 and iters % checkpoint_step == 0:
torch.save(
{
"gen": gen.state_dict(),
"critic": critic.state_dict(),
"iter": iters,
"im_count": im_count,
"step": steps,
"epoch": epoch,
"alpha": alpha,
},
f"./checkpoints/chk-{iters}.pth",
)
# TRAINING FINISHED - save final set of samples and save model.
examples = gen(show_noise, alpha=alpha, steps=steps)
torch.save(
{
"gen": gen.state_dict(),
"critic": critic.state_dict(),
"iter": iters,
"im_count": im_count,
"step": steps,
"epoch": epoch,
"alpha": None,
},
"./checkpoints/FINAL.pth",
)
print("TRAINING IS FINISHED - MODEL SAVED!")
def get_transform(name, args):
#
# GENERIC
#
if name == "Lambda":
t = T.Lambda(**args)
#
# TRANSFORM MULTI ON IMGS ONLY
#
elif name == "RandomChoice":
tt = config_transform(args["transforms"])
t = T.RandomChoice(tt)
elif name == "RandomOrder":
tt = config_transform(args["transforms"])
t = T.RandomOrder(tt)
#
# TRANSFORM MULTI ON TENSOR + PIL IMAGE
#
elif name == "RandomApply":
tt = config_transform(args["transforms"])
t = T.RandomApply(tt, p=args['p'])
#
# TRANSFORM ON TENSOR + PIL IMAGE
#
elif name == "ColorJitter":
t = T.ColorJitter(**args)
elif name == "Grayscale":
t = T.Grayscale(**args)
elif name == "Pad":
t = T.Pad(**args)
elif name == "RandomAffine":
t = T.RandomAffine(**args)
elif name == "RandomGrayscale":
t = T.RandomGrayscale(**args)
elif name == "RandomHorizontalFlip":
t = T.RandomHorizontalFlip(**args)
elif name == "RandomPerspective":
t = T.RandomPerspective(**args)
elif name == 'RandomResizedCrop':
t = T.RandomResizedCrop(**args)
elif name == "RandomRotation":
t = T.RandomRotation(**args)
elif name == "RandomVerticalFlip":
t = T.RandomVerticalFlip(**args)
elif name == "Resize":
t = T.Resize(**args)
elif name == "GaussianBlur":
t = T.GaussianBlur(**args)
#
# TRANSFORM ON TENSOR ONLY
#
elif name == "Normalize":
t = T.Normalize(**args)
elif name == "RandomErasing":
t = T.RandomErasing(**args)
elif name == "ConvertImageDtype":
t = T.ConvertImageDtype(**args)
elif name == "ToPILImage":
t = T.ToPILImage(**args)
elif name == "ToTensor":
t = T.ToTensor()
else:
raise NotImplementedError(transform_name)
return t
def test_convert_image_dtype_save_load(tmpdir):
fn = T.ConvertImageDtype(dtype=torch.uint8)
_test_fn_save_load(fn, tmpdir)
def test_convert_image_dtype_save():
fn = T.ConvertImageDtype(dtype=torch.uint8)
scripted_fn = torch.jit.script(fn)
with get_tmp_dir() as tmp_dir:
scripted_fn.save(os.path.join(tmp_dir, "t_convert_dtype.pt"))
import torchvision.transforms as transforms
import torchvision.models as models
from torch.utils.data import Dataset
sys.path.append(os.getcwd())
from dataset import FlickrDataLoader
from cunet import Conditional_UNet
if __name__ == '__main__':
# os.makedirs(os.path.join(save_path, 'out'), exist_ok=True)
cols = ['tempC', 'uvIndex', 'visibility', 'windspeedKmph', 'cloudcover', 'humidity', 'pressure', 'DewPointC']
transform = nn.Sequential(
# transforms.Resize((args.input_size,) * 2),
transforms.ConvertImageDtype(torch.float32),
transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
)
temp = pd.read_pickle('/mnt/fs2/2019/Takamuro/m2_research/flicker_data/wwo/2016_17/lambda_0/outdoor_all_dbdate_wwo_weather_2016_17_delnoise_WoPerson_sky-10_L-05.pkl')
df_ = temp.loc[:, cols].fillna(0)
df_mean = df_.mean()
df_std = df_.std()
df_max = df_.max()
df_min = df_.min()
df = pd.read_pickle(args.pkl_path)
df.loc[:, cols] = (df.loc[:, cols].fillna(0) - df_mean) / df_std
df_sep = df[df['mode'] == 'test']
def main(args):
if args.apex and amp is None:
raise RuntimeError(
"Failed to import apex. Please install apex from https://www.github.com/nvidia/apex "
"to enable mixed-precision training.")
if args.output_dir:
utils.mkdir(args.output_dir)
utils.init_distributed_mode(args)
print(args)
print("torch version: ", torch.__version__)
print("torchvision version: ", torchvision.__version__)
device = torch.device(args.device)
torch.backends.cudnn.benchmark = True
# Data loading code
print("Loading data")
traindir = os.path.join(args.data_path, args.train_dir)
valdir = os.path.join(args.data_path, args.val_dir)
normalize = T.Normalize(mean=[0.43216, 0.394666, 0.37645],
std=[0.22803, 0.22145, 0.216989])
print("Loading training data")
st = time.time()
cache_path = _get_cache_path(traindir)
transform_train = torchvision.transforms.Compose([
ConvertBHWCtoBCHW(),
T.ConvertImageDtype(torch.float32),
T.Resize((128, 171)),
T.RandomHorizontalFlip(), normalize,
T.RandomCrop((112, 112)),
ConvertBCHWtoCBHW()
])
if args.cache_dataset and os.path.exists(cache_path):
print("Loading dataset_train from {}".format(cache_path))
dataset, _ = torch.load(cache_path)
dataset.transform = transform_train
else:
if args.distributed:
print("It is recommended to pre-compute the dataset cache "
"on a single-gpu first, as it will be faster")
dataset = torchvision.datasets.Kinetics400(
traindir,
frames_per_clip=args.clip_len,
step_between_clips=1,
transform=transform_train,
frame_rate=15,
extensions=(
'avi',
'mp4',
))
if args.cache_dataset:
print("Saving dataset_train to {}".format(cache_path))
utils.mkdir(os.path.dirname(cache_path))
utils.save_on_master((dataset, traindir), cache_path)
print("Took", time.time() - st)
print("Loading validation data")
cache_path = _get_cache_path(valdir)
transform_test = torchvision.transforms.Compose([
ConvertBHWCtoBCHW(),
T.ConvertImageDtype(torch.float32),
T.Resize((128, 171)), normalize,
T.CenterCrop((112, 112)),
ConvertBCHWtoCBHW()
])
if args.cache_dataset and os.path.exists(cache_path):
print("Loading dataset_test from {}".format(cache_path))
dataset_test, _ = torch.load(cache_path)
dataset_test.transform = transform_test
else:
if args.distributed:
print("It is recommended to pre-compute the dataset cache "
"on a single-gpu first, as it will be faster")
dataset_test = torchvision.datasets.Kinetics400(
valdir,
frames_per_clip=args.clip_len,
step_between_clips=1,
transform=transform_test,
frame_rate=15,
extensions=(
'avi',
'mp4',
))
if args.cache_dataset:
print("Saving dataset_test to {}".format(cache_path))
utils.mkdir(os.path.dirname(cache_path))
utils.save_on_master((dataset_test, valdir), cache_path)
print("Creating data loaders")
train_sampler = RandomClipSampler(dataset.video_clips,
args.clips_per_video)
test_sampler = UniformClipSampler(dataset_test.video_clips,
args.clips_per_video)
if args.distributed:
train_sampler = DistributedSampler(train_sampler)
test_sampler = DistributedSampler(test_sampler)
data_loader = torch.utils.data.DataLoader(dataset,
batch_size=args.batch_size,
sampler=train_sampler,
num_workers=args.workers,
pin_memory=True,
collate_fn=collate_fn)
data_loader_test = torch.utils.data.DataLoader(dataset_test,
batch_size=args.batch_size,
sampler=test_sampler,
num_workers=args.workers,
pin_memory=True,
collate_fn=collate_fn)
print("Creating model")
model = torchvision.models.video.__dict__[args.model](
pretrained=args.pretrained)
model.to(device)
if args.distributed and args.sync_bn:
model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(model)
criterion = nn.CrossEntropyLoss()
lr = args.lr * args.world_size
optimizer = torch.optim.SGD(model.parameters(),
lr=lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
if args.apex:
model, optimizer = amp.initialize(model,
optimizer,
opt_level=args.apex_opt_level)
# convert scheduler to be per iteration, not per epoch, for warmup that lasts
# between different epochs
warmup_iters = args.lr_warmup_epochs * len(data_loader)
lr_milestones = [len(data_loader) * m for m in args.lr_milestones]
lr_scheduler = WarmupMultiStepLR(optimizer,
milestones=lr_milestones,
gamma=args.lr_gamma,
warmup_iters=warmup_iters,
warmup_factor=1e-5)
model_without_ddp = model
if args.distributed:
model = torch.nn.parallel.DistributedDataParallel(
model, device_ids=[args.gpu])
model_without_ddp = model.module
if args.resume:
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:
evaluate(model, criterion, data_loader_test, device=device)
return
print("Start training")
start_time = time.time()
for epoch in range(args.start_epoch, args.epochs):
if args.distributed:
train_sampler.set_epoch(epoch)
train_one_epoch(model, criterion, optimizer, lr_scheduler, data_loader,
device, epoch, args.print_freq, args.apex)
evaluate(model, criterion, data_loader_test, device=device)
if args.output_dir:
checkpoint = {
'model': model_without_ddp.state_dict(),
'optimizer': optimizer.state_dict(),
'lr_scheduler': lr_scheduler.state_dict(),
'epoch': epoch,
'args': args
}
utils.save_on_master(
checkpoint,
os.path.join(args.output_dir, 'model_{}.pth'.format(epoch)))
utils.save_on_master(
checkpoint, os.path.join(args.output_dir, 'checkpoint.pth'))
total_time = time.time() - start_time
total_time_str = str(datetime.timedelta(seconds=int(total_time)))
print('Training time {}'.format(total_time_str))
def main(args):
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
if args.use_deterministic_algorithms:
torch.backends.cudnn.benchmark = False
torch.use_deterministic_algorithms(True)
else:
torch.backends.cudnn.benchmark = True
p = args.labels_per_batch
k = args.samples_per_label
batch_size = p * k
model = EmbeddingNet()
if args.resume:
model.load_state_dict(torch.load(args.resume))
model.to(device)
criterion = TripletMarginLoss(margin=args.margin)
optimizer = Adam(model.parameters(), lr=args.lr)
transform = transforms.Compose([
transforms.Lambda(lambda image: image.convert("RGB")),
transforms.Resize((224, 224)),
transforms.PILToTensor(),
transforms.ConvertImageDtype(torch.float),
])
# Using FMNIST to demonstrate embedding learning using triplet loss. This dataset can
# be replaced with any classification dataset.
train_dataset = FashionMNIST(args.dataset_dir,
train=True,
transform=transform,
download=True)
test_dataset = FashionMNIST(args.dataset_dir,
train=False,
transform=transform,
download=True)
# targets is a list where the i_th element corresponds to the label of i_th dataset element.
# This is required for PKSampler to randomly sample from exactly p classes. You will need to
# construct targets while building your dataset. Some datasets (such as ImageFolder) have a
# targets attribute with the same format.
targets = train_dataset.targets.tolist()
train_loader = DataLoader(train_dataset,
batch_size=batch_size,
sampler=PKSampler(targets, p, k),
num_workers=args.workers)
test_loader = DataLoader(test_dataset,
batch_size=args.eval_batch_size,
shuffle=False,
num_workers=args.workers)
if args.test_only:
# We disable the cudnn benchmarking because it can noticeably affect the accuracy
torch.backends.cudnn.benchmark = False
torch.backends.cudnn.deterministic = True
evaluate(model, test_loader, device)
return
for epoch in range(1, args.epochs + 1):
print("Training...")
train_epoch(model, optimizer, criterion, train_loader, device, epoch,
args.print_freq)
print("Evaluating...")
evaluate(model, test_loader, device)
print("Saving...")
save(model, epoch, args.save_dir, "ckpt.pth")
def test_convert_image_dtype_save(tmpdir):
fn = T.ConvertImageDtype(dtype=torch.uint8)
scripted_fn = torch.jit.script(fn)
scripted_fn.save(os.path.join(tmpdir, "t_convert_dtype.pt"))
from torch.utils.data import DataLoader
from torchvision import transforms as T
from tqdm import tqdm
import dataset
import config_baseline as config
import engine
from utils import seed_everything, set_debug_apis
import timm
if __name__ == "__main__":
seed_everything(42)
set_debug_apis(False)
train_trasforms = T.Compose([
T.ConvertImageDtype(torch.float32),
T.Resize((config.IMG_WIDTH, config.IMG_HEIGHT)),
T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
full_dataset = dataset.RetinopathyDataset(config.TRAIN_DIR,
config.CSV_PATH,
transforms=train_trasforms)
train_size = int(config.TRAIN_SPLIT * len(full_dataset))
test_size = len(full_dataset) - train_size
train_dataset, val_dataset = torch.utils.data.random_split(
full_dataset, [train_size, test_size])
train_loader = DataLoader(full_dataset,
# ---------------------------------------------------- #
# -------------- Training (Fine-tuning) -------------- #
# ---------------------------------------------------- #
num_epochs = 200 # total number of epochs to train
bsize_train = 4 # training data batch sizes
bsize_val = 4 # validation data batch sizes
lr = 0.001 # learning rate
# More hyperparam-s below: "optimizer_ft": optimizer, "exp_lr_scheduler": lr policy
# Pre-processing settings (defaults for ImageNet dataset)
img_size = 512
transform = T.Compose([T.ToPILImage(),
T.RandomRotation((-3,3)),
T.RandomResizedCrop(img_size, scale=(0.8, 1.0)),
T.RandomHorizontalFlip(),
T.ToTensor(),
T.ConvertImageDtype(dtype),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])
val_transform = T.Compose([T.ToPILImage(),
T.Resize(img_size),
T.ToTensor(),
T.ConvertImageDtype(dtype),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])
test_transform = val_transform
# ----------- Initialize and split datasets ------------ #
np.random.seed(42) #seed np RNG for consistency
# Split the original training data into 85% / 15% train/val datasets
datasets = LoadTrainingData(train_csv, train_data_path, transform=transform,
split=True, train_percent=80, val_transform=val_transform)
print(f"Training dataset: {len(datasets['train'])} samples.",
def trial_process(self, trial, optimizer, learning_rate, horizontal_flip,
horizontal_shift_ratio, vertical_shift_ratio,
random_erasing):
self.best_pred = 0.0
self.start_run(trial)
# mlflowにtrialごとの情報をロギング
self.log_trial(trial)
self.model = EfficientNet.from_pretrained(self.args.backbone)
# Unfreeze model weights
for param in self.model.parameters():
param.requires_grad = True
num_ftrs = self.model._fc.in_features
self.model._fc = nn.Linear(num_ftrs, self.args.nclass)
if self.args.smry_viz:
from torchinfo import summary
from torchviz import make_dot
dummy_image = torch.zeros((2, 3, 32, 32))
dummy_output = self.model(dummy_image)
make_dot(dummy_output, params=dict(
self.model.named_parameters())).render("torchviz",
format="png")
summary(self.model, (1, 3, 32, 32))
import sys
sys.exit()
if self.args.cuda:
self.model = self.model.to('cuda')
if optimizer == 'SGD':
self.optimizer = optim.SGD(self.model.parameters(),
lr=learning_rate)
elif optimizer == 'Adam':
self.optimizer = optim.Adam(self.model.parameters(),
lr=learning_rate)
# DataLoaderのセットアップ
kwargs = {'num_workers': self.args.workers, 'pin_memory': True}
"""
composed_transforms = nn.Sequential(
tr.RandomHorizontalFlip(),
# tr.RandomScaleCrop(base_size=self.args.base_size, crop_size=self.args.crop_size),
# tr.RandomGaussianBlur(),
tr.ConvertImageDtype(torch.float32),
tr.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
# tr.ToTensor()
)#.to(torch.device('cuda:0'))
"""
pipeline = [
# tr.ToTensor(),
tr.ConvertImageDtype(torch.float32),
tr.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
]
if strtobool(horizontal_flip) == 1:
pipeline.append(tr.RandomHorizontalFlip(p=0.5))
pipeline.append(
tr.RandomAffine(0,
translate=(horizontal_shift_ratio,
vertical_shift_ratio)))
if strtobool(random_erasing) == 1:
pipeline.append(tr.RandomErasing())
# transform = tr.Compose(pipeline)
transform = nn.Sequential(*pipeline)
if self.args.no_cuda is False:
transform.to(torch.device('cuda:0'))
# train
train_set = PlantPathologyDataset(self.args,
self.args.dataset_dir + os.sep +
"train",
split='train',
transform=transform)
self.train_loader = DataLoader(train_set,
batch_size=self.args.batch_size,
shuffle=True,
drop_last=True,
**kwargs)
# val
val_set = PlantPathologyDataset(self.args,
self.args.dataset_dir + os.sep + "val",
split='val',
transform=transform)
self.val_loader = DataLoader(val_set,
batch_size=self.args.batch_size,
shuffle=True,
drop_last=True,
**kwargs)
self.criterion = nn.BCELoss()
for epoch in range(self.args.start_epoch, self.args.epochs):
self.training(epoch)
if not self.args.no_val and epoch % self.args.eval_interval == (
self.args.eval_interval - 1):
best_score = self.validating(epoch)
self.end_run()
# scoring by best
return 1.0 - best_score
