def get_dataloaders(dataset,
batch,
dataroot,
split=0.15,
split_idx=0,
horovod=False,
target_lb=-1):
if 'cifar' in dataset or 'svhn' in dataset:
transform_train = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(_CIFAR_MEAN, _CIFAR_STD),
])
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(_CIFAR_MEAN, _CIFAR_STD),
])
elif 'imagenet' in dataset:
transform_train = transforms.Compose([
transforms.RandomResizedCrop(224,
scale=(0.08, 1.0),
interpolation=Image.BICUBIC),
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(
brightness=0.4,
contrast=0.4,
saturation=0.4,
),
transforms.ToTensor(),
Lighting(0.1, _IMAGENET_PCA['eigval'], _IMAGENET_PCA['eigvec']),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
transform_test = transforms.Compose([
transforms.Resize(256, interpolation=Image.BICUBIC),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
else:
raise ValueError('dataset=%s' % dataset)
total_aug = augs = None
if isinstance(C.get()['aug'], list):
logger.debug('augmentation provided.')
transform_train.transforms.insert(0, Augmentation(C.get()['aug']))
else:
logger.debug('augmentation: %s' % C.get()['aug'])
if C.get()['aug'] == 'fa_reduced_cifar10':
transform_train.transforms.insert(
0, Augmentation(fa_reduced_cifar10()))
elif C.get()['aug'] == 'fa_reduced_imagenet':
transform_train.transforms.insert(
0, Augmentation(fa_resnet50_rimagenet()))
elif C.get()['aug'] == 'fa_reduced_svhn':
transform_train.transforms.insert(0,
Augmentation(fa_reduced_svhn()))
elif C.get()['aug'] == 'arsaug':
transform_train.transforms.insert(0, Augmentation(arsaug_policy()))
elif C.get()['aug'] == 'autoaug_cifar10':
transform_train.transforms.insert(
0, Augmentation(autoaug_paper_cifar10()))
elif C.get()['aug'] == 'autoaug_extend':
transform_train.transforms.insert(0,
Augmentation(autoaug_policy()))
elif C.get()['aug'] in ['default', 'inception', 'inception320']:
pass
else:
raise ValueError('not found augmentations. %s' % C.get()['aug'])
if C.get()['cutout'] > 0:
transform_train.transforms.append(CutoutDefault(C.get()['cutout']))
if dataset == 'cifar10':
total_trainset = torchvision.datasets.CIFAR10(
root=dataroot,
train=True,
download=False,
transform=transform_train)
testset = torchvision.datasets.CIFAR10(root=dataroot,
train=False,
download=False,
transform=transform_test)
elif dataset == 'reduced_cifar10':
total_trainset = torchvision.datasets.CIFAR10(
root=dataroot,
train=True,
download=False,
transform=transform_train)
sss = StratifiedShuffleSplit(n_splits=1,
test_size=46000,
random_state=0) # 4000 trainset
sss = sss.split(list(range(len(total_trainset))),
total_trainset.targets)
train_idx, valid_idx = next(sss)
targets = [total_trainset.targets[idx] for idx in train_idx]
total_trainset = Subset(total_trainset, train_idx)
total_trainset.targets = targets
testset = torchvision.datasets.CIFAR10(root=dataroot,
train=False,
download=True,
transform=transform_test)
elif dataset == 'cifar100':
total_trainset = torchvision.datasets.CIFAR100(
root=dataroot,
train=True,
download=True,
transform=transform_train)
testset = torchvision.datasets.CIFAR100(root=dataroot,
train=False,
download=True,
transform=transform_test)
elif dataset == 'svhn':
trainset = torchvision.datasets.SVHN(root=dataroot,
split='train',
download=True,
transform=transform_train)
extraset = torchvision.datasets.SVHN(root=dataroot,
split='extra',
download=True,
transform=transform_train)
total_trainset = ConcatDataset([trainset, extraset])
testset = torchvision.datasets.SVHN(root=dataroot,
split='test',
download=True,
transform=transform_test)
elif dataset == 'reduced_svhn':
total_trainset = torchvision.datasets.SVHN(root=dataroot,
split='train',
download=True,
transform=transform_train)
sss = StratifiedShuffleSplit(n_splits=1,
test_size=73257 - 1000,
random_state=0) # 1000 trainset
sss = sss.split(list(range(len(total_trainset))),
total_trainset.targets)
train_idx, valid_idx = next(sss)
targets = [total_trainset.targets[idx] for idx in train_idx]
total_trainset = Subset(total_trainset, train_idx)
total_trainset.targets = targets
testset = torchvision.datasets.SVHN(root=dataroot,
split='test',
download=True,
transform=transform_test)
elif dataset == 'imagenet':
total_trainset = ImageNet(root=os.path.join(dataroot,
'imagenet-pytorch'),
transform=transform_train)
testset = ImageNet(root=os.path.join(dataroot, 'imagenet-pytorch'),
split='val',
transform=transform_test)
# compatibility
total_trainset.targets = [lb for _, lb in total_trainset.samples]
elif dataset == 'reduced_imagenet':
# randomly chosen indices
idx120 = [
904, 385, 759, 884, 784, 844, 132, 214, 990, 786, 979, 582, 104,
288, 697, 480, 66, 943, 308, 282, 118, 926, 882, 478, 133, 884,
570, 964, 825, 656, 661, 289, 385, 448, 705, 609, 955, 5, 703, 713,
695, 811, 958, 147, 6, 3, 59, 354, 315, 514, 741, 525, 685, 673,
657, 267, 575, 501, 30, 455, 905, 860, 355, 911, 24, 708, 346, 195,
660, 528, 330, 511, 439, 150, 988, 940, 236, 803, 741, 295, 111,
520, 856, 248, 203, 147, 625, 589, 708, 201, 712, 630, 630, 367,
273, 931, 960, 274, 112, 239, 463, 355, 955, 525, 404, 59, 981,
725, 90, 782, 604, 323, 418, 35, 95, 97, 193, 690, 869, 172
]
total_trainset = ImageNet(root=os.path.join(dataroot,
'imagenet-pytorch'),
transform=transform_train)
testset = ImageNet(root=os.path.join(dataroot, 'imagenet-pytorch'),
split='val',
transform=transform_test)
# compatibility
total_trainset.targets = [lb for _, lb in total_trainset.samples]
sss = StratifiedShuffleSplit(n_splits=1,
test_size=len(total_trainset) - 500000,
random_state=0) # 4000 trainset
sss = sss.split(list(range(len(total_trainset))),
total_trainset.targets)
train_idx, valid_idx = next(sss)
# filter out
train_idx = list(
filter(lambda x: total_trainset.labels[x] in idx120, train_idx))
valid_idx = list(
filter(lambda x: total_trainset.labels[x] in idx120, valid_idx))
test_idx = list(
filter(lambda x: testset.samples[x][1] in idx120,
range(len(testset))))
targets = [
idx120.index(total_trainset.targets[idx]) for idx in train_idx
]
for idx in range(len(total_trainset.samples)):
if total_trainset.samples[idx][1] not in idx120:
continue
total_trainset.samples[idx] = (total_trainset.samples[idx][0],
idx120.index(
total_trainset.samples[idx][1]))
total_trainset = Subset(total_trainset, train_idx)
total_trainset.targets = targets
for idx in range(len(testset.samples)):
if testset.samples[idx][1] not in idx120:
continue
testset.samples[idx] = (testset.samples[idx][0],
idx120.index(testset.samples[idx][1]))
testset = Subset(testset, test_idx)
print('reduced_imagenet train=', len(total_trainset))
else:
raise ValueError('invalid dataset name=%s' % dataset)
if total_aug is not None and augs is not None:
total_trainset.set_preaug(augs, total_aug)
print('set_preaug-')
train_sampler = None
if split > 0.0:
sss = StratifiedShuffleSplit(n_splits=5,
test_size=split,
random_state=0)
sss = sss.split(list(range(len(total_trainset))),
total_trainset.targets)
for _ in range(split_idx + 1):
train_idx, valid_idx = next(sss)
if target_lb >= 0:
train_idx = [
i for i in train_idx if total_trainset.targets[i] == target_lb
]
valid_idx = [
i for i in valid_idx if total_trainset.targets[i] == target_lb
]
train_sampler = SubsetRandomSampler(train_idx)
valid_sampler = SubsetSampler(valid_idx)
if horovod:
import horovod.torch as hvd
train_sampler = torch.utils.data.distributed.DistributedSampler(
train_sampler, num_replicas=hvd.size(), rank=hvd.rank())
else:
valid_sampler = SubsetSampler([])
if horovod:
import horovod.torch as hvd
train_sampler = torch.utils.data.distributed.DistributedSampler(
valid_sampler, num_replicas=hvd.size(), rank=hvd.rank())
trainloader = torch.utils.data.DataLoader(
total_trainset,
batch_size=batch,
shuffle=True if train_sampler is None else False,
num_workers=32,
pin_memory=True,
sampler=train_sampler,
drop_last=True)
validloader = torch.utils.data.DataLoader(total_trainset,
batch_size=batch,
shuffle=False,
num_workers=16,
pin_memory=True,
sampler=valid_sampler,
drop_last=False)
testloader = torch.utils.data.DataLoader(testset,
batch_size=batch,
shuffle=False,
num_workers=32,
pin_memory=True,
drop_last=False)
return train_sampler, trainloader, validloader, testloader
max_stage=6,
final_tanh=False,
)
# ConfigBase.parse()
# use MNIST for test
data_loader = DataLoader(
datasets.MNIST(
root='../../tutorials/data/mnist',
train=True,
download=False,
transform=transforms.Compose([
transforms.Resize(net_config.im_res),
transforms.ToTensor(),
transforms.Normalize([0.5], [0.5])
]),
),
batch_size=train_config.batch_size,
shuffle=True,
)
Generator, Discriminator = network.interface(net_config)
intlog = lambda x: int(round(np.log2(x)))
stage = intlog(net_config.im_res) - 2
generator = Generator().to(train_config.device)
generator.alpha = net_config.start_alpha
sumx.summary(
generator,
def load_dataset(args):
if args.dataset == 'mnist':
if args.augmentation == 'none':
train_transform = transforms.ToTensor()
elif args.augmentation == 'crop':
train_transform = transforms.Compose([
transforms.RandomCrop(28, padding=4),
transforms.ToTensor(),
])
test_transform = transforms.ToTensor()
train_data = datasets.MNIST('data/mnist',
download=True,
train=True,
transform=train_transform)
test_data = datasets.MNIST('data/mnist',
download=True,
train=False,
transform=test_transform)
in_ch = 1
out = 10
elif args.dataset == 'cifar10':
if args.augmentation == 'none':
train_transform = test_transform = transforms.ToTensor()
elif args.augmentation == 'crop+flip+norm':
train_transform = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465),
(0.2023, 0.1994, 0.2010)),
])
test_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465),
(0.2023, 0.1994, 0.2010)),
])
elif args.augmentation == 'crop+jitter+flip+norm':
train_transform = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.ColorJitter(hue=.05, saturation=.05),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465),
(0.2023, 0.1994, 0.2010)),
])
test_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465),
(0.2023, 0.1994, 0.2010)),
])
train_data = datasets.CIFAR10('data/cifar10',
download=True,
train=True,
transform=train_transform)
test_data = datasets.CIFAR10('data/cifar10',
download=True,
train=False,
transform=test_transform)
in_ch = 3
out = 10
elif args.dataset == 'tiny-imagenet-200':
if args.augmentation == 'none':
train_transform = test_transform = transforms.ToTensor()
elif args.augmentation == 'crop+flip+norm':
train_transform = transforms.Compose([
transforms.RandomCrop(64, padding=8),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.4802, 0.4481, 0.3975),
(0.2770, 0.2691, 0.2821)),
])
test_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4802, 0.4481, 0.3975),
(0.2770, 0.2691, 0.2821)),
])
elif args.augmentation == 'crop+jitter+flip+norm':
train_transform = transforms.Compose([
transforms.RandomCrop(64, padding=8),
transforms.ColorJitter(hue=.05, saturation=.05),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.4802, 0.4481, 0.3975),
(0.2770, 0.2691, 0.2821)),
])
test_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4802, 0.4481, 0.3975),
(0.2770, 0.2691, 0.2821)),
])
train_data = TinyImageNet200('data/tiny-imagenet-200',
download=True,
split='train',
transform=train_transform)
test_data = TinyImageNet200('data/tiny-imagenet-200',
download=True,
split='val',
transform=test_transform)
in_ch = 3
out = 200
return train_data, test_data, in_ch, out
def __init__(
self,
c,
nof_joints,
checkpoint_path,
resolution=(384, 288),
interpolation=cv2.INTER_CUBIC,
multiperson=True,
max_batch_size=32,
yolo_model_def="./models/detectors/yolo/config/yolov3.cfg",
yolo_class_path="./models/detectors/yolo/data/coco.names",
yolo_weights_path="./models/detectors/yolo/weights/yolov3.weights",
device=torch.device("cpu")):
"""
Initializes a new SimpleHRNet object.
HRNet (and YOLOv3) are initialized on the torch.device("device") and
its (their) pre-trained weights will be loaded from disk.
Arguments:
c (int): number of channels.
nof_joints (int): number of joints.
checkpoint_path (str): hrnet checkpoint path.
resolution (tuple): hrnet input resolution - format: (height, width).
Default: (384, 288)
interpolation (int): opencv interpolation algorithm.
Default: cv2.INTER_CUBIC
multiperson (bool): if True, multiperson detection will be enabled.
This requires the use of a people detector (like YOLOv3).
Default: True
max_batch_size (int): maximum batch size used in hrnet inference.
Useless without multiperson=True.
Default: 16
yolo_model_def (str): path to yolo model definition file.
Default: "./models/detectors/yolo/config/yolov3.cfg"
yolo_class_path (str): path to yolo class definition file.
Default: "./models/detectors/yolo/data/coco.names"
yolo_weights_path (str): path to yolo pretrained weights file.
Default: "./models/detectors/yolo/weights/yolov3.weights.cfg"
device (:class:`torch.device`): the hrnet (and yolo) inference will be run on this device.
Default: torch.device("cpu")
"""
self.c = c
self.nof_joints = nof_joints
self.checkpoint_path = checkpoint_path
self.resolution = resolution # in the form (height, width) as in the original implementation
self.interpolation = interpolation
self.multiperson = multiperson
self.max_batch_size = max_batch_size
self.yolo_model_def = yolo_model_def
self.yolo_class_path = yolo_class_path
self.yolo_weights_path = yolo_weights_path
self.device = device
self.model = HRNet(c=c, nof_joints=nof_joints).to(device)
self.model.load_state_dict(
torch.load(checkpoint_path, map_location=self.device))
self.model.eval()
if not self.multiperson:
self.transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
else:
self.detector = YOLOv3(model_def=yolo_model_def,
class_path=yolo_class_path,
weights_path=yolo_weights_path,
classes=('person', ),
max_batch_size=self.max_batch_size,
device=device)
self.transform = transforms.Compose([
transforms.ToPILImage(),
transforms.Resize((self.resolution[0],
self.resolution[1])), # (height, width)
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
pass
from torchvision.transforms import transforms
from RandAugment import RandAugment
from RandAugment.augmentations import CutoutDefault
# Parameters for data
cifar10_mean = (0.4914, 0.4822, 0.4465
) # equals np.mean(train_set.train_data, axis=(0,1,2))/255
cifar10_std = (0.2471, 0.2435, 0.2616
) # equals np.std(train_set.train_data, axis=(0,1,2))/255
# Augmentations.
transform_train = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(cifar10_mean, cifar10_std)
])
transform_strong = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(cifar10_mean, cifar10_std)
])
transform_strong.transforms.insert(0, RandAugment(3, 4))
transform_strong.transforms.append(CutoutDefault(16))
transform_val = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize(cifar10_mean, cifar10_std)])
])
data_config = OrderedDict([
('dataset', 'SplitFashionMNIST'),
('valid', 0.0),
('num_workers', 4),
(
'train_transform',
transforms.Compose([
lambda x: np.array(x).reshape((1, 28, 28)),
lambda x: np.pad(x, (
(0, 0), (2, 2),
(2, 2)), mode='minimum'), # Padding is only required by LeNet
lambda x: torch.FloatTensor(x),
lambda x: x / 255.0,
transforms.Normalize(np.array([0.1307]), np.array([0.3081]))
])),
(
'test_transform',
transforms.Compose([
lambda x: np.array(x).reshape((1, 28, 28)),
lambda x: np.pad(x, (
(0, 0), (2, 2),
(2, 2)), mode='minimum'), # Padding is only required by LeNet
lambda x: torch.FloatTensor(x),
lambda x: x / 255.0,
transforms.Normalize(np.array([0.1307]), np.array([0.3081]))
])),
])
run_config = OrderedDict([
def preprocess(img):
# Convert image from numpy to tensor
to_tensor = torchvision.transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize(mean, std)])
return to_tensor(img).unsqueeze(0)
def main():
# img_folders = ["../coco_img/bg2_0/", "../coco_img/bg2_127/", "../coco_img/bg2_255/",
# "../coco_img/obj2_0/", "../coco_img/obj2_127/", "../coco_img/obj2_255/"]
img_folders = [
"../coco_img/merged_bg2_0/", "../coco_img/merged_bg2_127/",
"../coco_img/merged_bg2_255/", "../coco_img/merged_obj2_0/",
"../coco_img/merged_obj2_127/", "../coco_img/merged_obj2_255/"
]
img_folders = ["../coco_img/org/"]
model_name = "MLCCOCO"
model = MultilabelObject(None, 80).cuda()
log_dir = "./"
checkpoint = torch.load(os.path.join(log_dir, 'model_best.pth.tar'),
encoding='bytes')
new_checkpoint = OrderedDict()
for k in checkpoint[b'state_dict']:
new_checkpoint[k.decode('utf-8')] = checkpoint[b'state_dict'][k]
model.load_state_dict(new_checkpoint)
model.eval()
with open("classes_list.pickle", "rb") as f:
classes_list = pickle.load(f)
for img_folder in img_folders:
crop_size = 224
image_size = 256
batch_size = 64
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
val_transform = transforms.Compose([
transforms.Scale(image_size),
transforms.CenterCrop(crop_size),
transforms.ToTensor(), normalize
])
cocomlc = COCO_MLC(img_folder, val_transform)
test_loader = torch.utils.data.DataLoader(cocomlc,
batch_size=batch_size,
shuffle=False,
num_workers=8,
pin_memory=True)
t = tqdm(test_loader, desc='testing {}'.format(img_folder))
result = {}
for batch_idx, (imgs, paths) in enumerate(t):
images = imgs.cuda()
# print(images.shape)
probs, labels, labels_probs = infer_batch(model,
classes_list,
inputs=images,
threshold=0.5)
for i in range(0, len(paths)):
path = paths[i]
result[path] = {
"prob": probs[i],
"labels": labels[i],
"labels_probs": labels_probs[i]
}
pickle_file_name = "{}_{}.pickle".format(
model_name, os.path.basename(os.path.normpath(img_folder)))
pickle_path = os.path.join(".", "result_pickle", pickle_file_name)
with open(pickle_path, 'wb') as handle:
pickle.dump(result, handle)
print("Done, Saved to {}".format(pickle_path))
def create_dataloader(data_manager,
batch_size=128,
validation_split=None,
validation_source=None):
"""
Args:
data_manager: Current version of the train data and the pool to sample from
batch_size: batch_size
validation_source : Whether to use train or test dataset for creating validation dataset, Defauts to None
validation_split : Specify the ratio of samples to use in validation, defaults to 20% of source size
Returns:
PyTorch's train, test and pool loader. (Validation loader is also returned if source is not None)
"""
train_X, train_y = data_manager.get_train_data()
test_X, test_y = data_manager.get_test_data()
pool_X, pool_y = data_manager.get_unlabelled_pool_data()
train_X, train_y = train_X.astype(np.float32), train_y.astype(np.float32)
test_X, test_y = test_X.astype(np.float32), test_y.astype(np.float32)
pool_X, pool_y = pool_X.astype(np.float32), pool_y.astype(np.float32)
train_X, train_y = torch.from_numpy(train_X), torch.from_numpy(train_y)
test_X, test_y = torch.from_numpy(test_X), torch.from_numpy(test_y)
pool_X, pool_y = torch.from_numpy(pool_X), torch.from_numpy(pool_y)
transform_train = transforms.Compose([
transforms.RandomHorizontalFlip(),
transforms.RandomCrop(32, 4),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
pool_dataset = DataHandler_For_Arrays(pool_X, pool_y)
train_dataset = DataHandler_For_Arrays(train_X,
train_y,
transform=transform_train)
test_dataset = DataHandler_For_Arrays(test_X,
test_y,
transform=transform_test)
if validation_source is None:
print(
"INFO ------ Validation source not specified in config, experiment would run without validation set"
)
else:
if validation_source == "test":
if validation_split is None:
validation_size = int(len(test_dataset) * 0.2)
else:
assert (
0 < validation_split < 1
), f"Validation size must be >0 and <1, found {validation_split}"
validation_size = int(len(test_dataset) * validation_split)
print(
f"Using Testing data to create validation dataset, size : {validation_size}"
)
test_dataset, validation_dataset = random_split(
test_dataset,
lengths=[len(test_dataset) - validation_size, validation_size],
)
elif validation_source == "train":
if validation_split is None:
validation_size = int(len(train_dataset) * 0.2)
else:
assert (
0 < validation_split < 1
), f"Validation size must be >0 and <1, found {validation_split}"
validation_size = int(len(train_dataset) * validation_split)
print(
f"Using Training data to create validation dataset, size : {validation_size}"
)
train_dataset, validation_dataset = random_split(
train_dataset,
lengths=[
len(train_dataset) - validation_size, validation_size
],
)
train_loader = DataLoader(
train_dataset,
sampler=RandomSampler(train_dataset),
batch_size=batch_size,
num_workers=2,
pin_memory=pin_memory,
)
test_loader = DataLoader(
test_dataset,
sampler=SequentialSampler(test_dataset),
batch_size=batch_size,
num_workers=2,
pin_memory=pin_memory,
)
pool_loader = DataLoader(pool_dataset,
batch_size=batch_size,
num_workers=2,
pin_memory=pin_memory)
if validation_source is not None:
val_loader = DataLoader(
validation_dataset,
sampler=SequentialSampler(validation_dataset),
batch_size=batch_size,
num_workers=2,
pin_memory=pin_memory,
)
return (train_loader, test_loader, pool_loader, val_loader)
else:
return (train_loader, test_loader, pool_loader)
return sample, path
def __len__(self):
return len(self.samples)
def __repr__(self):
fmt_str = '>> PATH : {}\n'.format(self.dir)
fmt_str += '>> LEN : {}\n'.format(self.__len__())
return fmt_str
def get_vidname(self):
return os.path.dirname(self.dir).split('/')[-1]
if __name__ == '__main__':
base = '/DB/VCDB/frame_1_per_sec/frames'
db = CC_WEB_VIDEO()
db.get_VideoList()
videos = os.listdir(base)
videos.sort(key=lambda x: int(x))
normalize = trn.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
video_trn = trn.Compose([trn.Resize(224), trn.ToTensor(), normalize])
for vid in videos:
dt = DirDataset(os.path.join(base, vid), video_trn)
dl = DataLoader(dt, batch_size=4, num_workers=2)
for i, (im, path) in enumerate(dl):
print(i, path)
def __len__(self):
return self.data.shape[0]
def __getitem__(self, idx):
row = self.data.iloc[idx]
img = Image.open(row['path'])
if self.transform:
img = self.transform(img)
target = row['label_id'] - 1 if 'label_id' in row else -1
return img, target
'''
设置全局变量的方差和标准差
'''
normalize_torch = transforms.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]
)
normalize_05 = transforms.Normalize(
mean=[0.5, 0.5, 0.5],
std=[0.5, 0.5, 0.5]
)
'''
图像预处理，修改尺寸的操作。
'''
def preprocess(normalize, image_size):
return transforms.Compose([
transforms.Resize((image_size, image_size)),
transforms.ToTensor(),
normalize
])
def get_dataloaders(dataset,
batch,
dataroot,
split=0.15,
split_idx=0,
multinode=False,
target_lb=-1):
if 'cifar' in dataset or 'svhn' in dataset:
transform_train = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(_CIFAR_MEAN, _CIFAR_STD),
])
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(_CIFAR_MEAN, _CIFAR_STD),
])
elif 'imagenet' in dataset:
input_size = 224
sized_size = 256
if 'efficientnet' in C.get()['model']['type']:
input_size = EfficientNet.get_image_size(C.get()['model']['type'])
sized_size = input_size + 32 # TODO
# sized_size = int(round(input_size / 224. * 256))
# sized_size = input_size
logger.info('size changed to %d/%d.' % (input_size, sized_size))
transform_train = transforms.Compose([
EfficientNetRandomCrop(input_size),
transforms.Resize((input_size, input_size),
interpolation=Image.BICUBIC),
# transforms.RandomResizedCrop(input_size, scale=(0.1, 1.0), interpolation=Image.BICUBIC),
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(
brightness=0.4,
contrast=0.4,
saturation=0.4,
),
transforms.ToTensor(),
Lighting(0.1, _IMAGENET_PCA['eigval'], _IMAGENET_PCA['eigvec']),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
transform_test = transforms.Compose([
EfficientNetCenterCrop(input_size),
transforms.Resize((input_size, input_size),
interpolation=Image.BICUBIC),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
else:
raise ValueError('dataset=%s' % dataset)
total_aug = augs = None
if isinstance(C.get()['aug'], list):
logger.debug('augmentation provided.')
transform_train.transforms.insert(0, Augmentation(C.get()['aug']))
else:
logger.debug('augmentation: %s' % C.get()['aug'])
if C.get()['aug'] == 'fa_reduced_cifar10':
transform_train.transforms.insert(
0, Augmentation(fa_reduced_cifar10()))
elif C.get()['aug'] == 'fa_reduced_imagenet':
transform_train.transforms.insert(
0, Augmentation(fa_resnet50_rimagenet()))
elif C.get()['aug'] == 'fa_reduced_svhn':
transform_train.transforms.insert(0,
Augmentation(fa_reduced_svhn()))
elif C.get()['aug'] == 'arsaug':
transform_train.transforms.insert(0, Augmentation(arsaug_policy()))
elif C.get()['aug'] == 'autoaug_cifar10':
transform_train.transforms.insert(
0, Augmentation(autoaug_paper_cifar10()))
elif C.get()['aug'] == 'autoaug_extend':
transform_train.transforms.insert(0,
Augmentation(autoaug_policy()))
elif C.get()['aug'] in ['default']:
pass
else:
raise ValueError('not found augmentations. %s' % C.get()['aug'])
if C.get()['cutout'] > 0:
transform_train.transforms.append(CutoutDefault(C.get()['cutout']))
if dataset == 'cifar10':
total_trainset = torchvision.datasets.CIFAR10(
root=dataroot,
train=True,
download=True,
transform=transform_train)
testset = torchvision.datasets.CIFAR10(root=dataroot,
train=False,
download=True,
transform=transform_test)
elif dataset == 'reduced_cifar10':
total_trainset = torchvision.datasets.CIFAR10(
root=dataroot,
train=True,
download=True,
transform=transform_train)
sss = StratifiedShuffleSplit(n_splits=1,
test_size=46000,
random_state=0) # 4000 trainset
sss = sss.split(list(range(len(total_trainset))),
total_trainset.targets)
train_idx, valid_idx = next(sss)
targets = [total_trainset.targets[idx] for idx in train_idx]
total_trainset = Subset(total_trainset, train_idx)
total_trainset.targets = targets
testset = torchvision.datasets.CIFAR10(root=dataroot,
train=False,
download=True,
transform=transform_test)
elif dataset == 'cifar100':
total_trainset = torchvision.datasets.CIFAR100(
root=dataroot,
train=True,
download=True,
transform=transform_train)
testset = torchvision.datasets.CIFAR100(root=dataroot,
train=False,
download=True,
transform=transform_test)
elif dataset == 'svhn':
trainset = torchvision.datasets.SVHN(root=dataroot,
split='train',
download=True,
transform=transform_train)
extraset = torchvision.datasets.SVHN(root=dataroot,
split='extra',
download=True,
transform=transform_train)
total_trainset = ConcatDataset([trainset, extraset])
testset = torchvision.datasets.SVHN(root=dataroot,
split='test',
download=True,
transform=transform_test)
elif dataset == 'reduced_svhn':
total_trainset = torchvision.datasets.SVHN(root=dataroot,
split='train',
download=True,
transform=transform_train)
sss = StratifiedShuffleSplit(n_splits=1,
test_size=73257 - 1000,
random_state=0) # 1000 trainset
sss = sss.split(list(range(len(total_trainset))),
total_trainset.targets)
train_idx, valid_idx = next(sss)
targets = [total_trainset.targets[idx] for idx in train_idx]
total_trainset = Subset(total_trainset, train_idx)
total_trainset.targets = targets
testset = torchvision.datasets.SVHN(root=dataroot,
split='test',
download=True,
transform=transform_test)
elif dataset == 'imagenet':
total_trainset = ImageNet(root=os.path.join(dataroot,
'imagenet-pytorch'),
transform=transform_train,
download=True)
testset = ImageNet(root=os.path.join(dataroot, 'imagenet-pytorch'),
split='val',
transform=transform_test)
# compatibility
total_trainset.targets = [lb for _, lb in total_trainset.samples]
elif dataset == 'reduced_imagenet':
# randomly chosen indices
# idx120 = sorted(random.sample(list(range(1000)), k=120))
idx120 = [
16, 23, 52, 57, 76, 93, 95, 96, 99, 121, 122, 128, 148, 172, 181,
189, 202, 210, 232, 238, 257, 258, 259, 277, 283, 289, 295, 304,
307, 318, 322, 331, 337, 338, 345, 350, 361, 375, 376, 381, 388,
399, 401, 408, 424, 431, 432, 440, 447, 462, 464, 472, 483, 497,
506, 512, 530, 541, 553, 554, 557, 564, 570, 584, 612, 614, 619,
626, 631, 632, 650, 657, 658, 660, 674, 675, 680, 682, 691, 695,
699, 711, 734, 736, 741, 754, 757, 764, 769, 770, 780, 781, 787,
797, 799, 811, 822, 829, 830, 835, 837, 842, 843, 845, 873, 883,
897, 900, 902, 905, 913, 920, 925, 937, 938, 940, 941, 944, 949,
959
]
total_trainset = ImageNet(root=os.path.join(dataroot,
'imagenet-pytorch'),
transform=transform_train)
testset = ImageNet(root=os.path.join(dataroot, 'imagenet-pytorch'),
split='val',
transform=transform_test)
# compatibility
total_trainset.targets = [lb for _, lb in total_trainset.samples]
sss = StratifiedShuffleSplit(n_splits=1,
test_size=len(total_trainset) - 50000,
random_state=0) # 4000 trainset
sss = sss.split(list(range(len(total_trainset))),
total_trainset.targets)
train_idx, valid_idx = next(sss)
# filter out
train_idx = list(
filter(lambda x: total_trainset.labels[x] in idx120, train_idx))
valid_idx = list(
filter(lambda x: total_trainset.labels[x] in idx120, valid_idx))
test_idx = list(
filter(lambda x: testset.samples[x][1] in idx120,
range(len(testset))))
targets = [
idx120.index(total_trainset.targets[idx]) for idx in train_idx
]
for idx in range(len(total_trainset.samples)):
if total_trainset.samples[idx][1] not in idx120:
continue
total_trainset.samples[idx] = (total_trainset.samples[idx][0],
idx120.index(
total_trainset.samples[idx][1]))
total_trainset = Subset(total_trainset, train_idx)
total_trainset.targets = targets
for idx in range(len(testset.samples)):
if testset.samples[idx][1] not in idx120:
continue
testset.samples[idx] = (testset.samples[idx][0],
idx120.index(testset.samples[idx][1]))
testset = Subset(testset, test_idx)
print('reduced_imagenet train=', len(total_trainset))
else:
raise ValueError('invalid dataset name=%s' % dataset)
if total_aug is not None and augs is not None:
total_trainset.set_preaug(augs, total_aug)
print('set_preaug-')
train_sampler = None
if split > 0.0:
sss = StratifiedShuffleSplit(n_splits=5,
test_size=split,
random_state=0)
sss = sss.split(list(range(len(total_trainset))),
total_trainset.targets)
for _ in range(split_idx + 1):
train_idx, valid_idx = next(sss)
if target_lb >= 0:
train_idx = [
i for i in train_idx if total_trainset.targets[i] == target_lb
]
valid_idx = [
i for i in valid_idx if total_trainset.targets[i] == target_lb
]
train_sampler = SubsetRandomSampler(train_idx)
valid_sampler = SubsetSampler(valid_idx)
if multinode:
train_sampler = torch.utils.data.distributed.DistributedSampler(
Subset(total_trainset, train_idx),
num_replicas=dist.get_world_size(),
rank=dist.get_rank())
else:
valid_sampler = SubsetSampler([])
if multinode:
train_sampler = torch.utils.data.distributed.DistributedSampler(
total_trainset,
num_replicas=dist.get_world_size(),
rank=dist.get_rank())
logger.info(
f'----- dataset with DistributedSampler {dist.get_rank()}/{dist.get_world_size()}'
)
trainloader = torch.utils.data.DataLoader(
total_trainset,
batch_size=batch,
shuffle=True if train_sampler is None else False,
num_workers=8,
pin_memory=True,
sampler=train_sampler,
drop_last=True)
validloader = torch.utils.data.DataLoader(total_trainset,
batch_size=batch,
shuffle=False,
num_workers=4,
pin_memory=True,
sampler=valid_sampler,
drop_last=False)
testloader = torch.utils.data.DataLoader(testset,
batch_size=batch,
shuffle=False,
num_workers=8,
pin_memory=True,
drop_last=False)
return train_sampler, trainloader, validloader, testloader
valid_dir = os.path.join(split_dir, 'valid')
print('train_dir:\n', train_dir)
print('valid_dir:\n', valid_dir)
# 规定图像数据的处理方式
# 参数：列表---列表中放置的是各种图片数据处理方式
# 返回一个数据处理对象
transform = transforms.Compose([
# 图片尺寸固定
transforms.Resize((32, 32)), # 将图片固定为32*32的大小
# 将数据转化为tensor
transforms.ToTensor(), # 转化为 tensor
# 图片数据的归一化
# data - mean / std
transforms.Normalize(mean=norm_mean, std=norm_std),
])
# 实例化DataSet
train_data = RMBDataSet(data_dir=train_dir, transform=transform)
valid_data = RMBDataSet(data_dir=valid_dir, transform=transform)
# 实例化DataLoader
train_loader = DataLoader(
dataset=train_data, # 规定的是数据的读取规则
batch_size=BATCH_SIZE, # 每批次读取多少个样本
shuffle=True, # 打乱顺序
)
valid_loader = DataLoader(
dataset=valid_data, # 规定的是数据的读取规则
batch_size=BATCH_SIZE, # 每批次读取多少个样本
def __init__(self, root):
self.root = root
self.imgs = os.listdir(root)
self.transforms = T.Compose(
[T.ToTensor(), T.Normalize(mean=[0.3], std=[0.5])])
def __init__(self, root, mode, batchsz, resize, startidx=0):
"""
:param root: root path of mini-imagenet
:param mode: train, val or test
:param batchsz: batch size of sets, not batch of imgs
:param n_way:
:param k_shot:
:param k_query: num of qeruy imgs per class
:param resize: resize to
:param startidx: start to index label from startidx
"""
self.batchsz = batchsz #batch of imgs
self.resize = resize # resize to
self.startidx = startidx # index label not from 0, but from startidx
print('shuffle DB :%s, b:%d, resize:%d' % (mode, batchsz, resize))
if mode == 'train':
# self.transform = transforms.Compose([lambda x: Image.open(x).convert('RGB'),
# transforms.Resize((self.resize, self.resize)),
# # transforms.RandomHorizontalFlip(),
# # transforms.RandomRotation(5),
# transforms.ToTensor(),
# transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
# ])
self.transform = transforms.Compose([
lambda x: Image.open(x).convert('RGB'),
transforms.Resize((self.resize, self.resize)),
# transforms.RandomHorizontalFlip(),
# transforms.RandomRotation(5),
transforms.ToTensor(),
transforms.Normalize((0, 0, 0), (1, 1, 1))
])
else:
# self.transform = transforms.Compose([lambda x: Image.open(x).convert('RGB'),
# transforms.Resize((self.resize, self.resize)),
# transforms.ToTensor(),
# transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
# ])
self.transform = transforms.Compose([
lambda x: Image.open(x).convert('RGB'),
transforms.Resize((self.resize, self.resize)),
transforms.ToTensor(),
transforms.Normalize((0, 0, 0), (1, 1, 1))
])
self.path = os.path.join(root, 'images') # image path
csvdata = self.loadCSV(os.path.join(root, mode + '.csv')) # csv path
self.data = []
self.img2label = {}
for i, (k, v) in enumerate(csvdata.items()):
self.data.extend(v) # [[img1, img2, ...], [img111, ...]]
self.img2label[k] = i + self.startidx # {"img_name[:9]":label}
self.cls_num = len(self.data)
# self.create_batch(self.batchsz)
support_x = torch.FloatTensor(self.cls_num, 3, self.resize,
self.resize)
support_x_temp = np.array(self.data) #.tolist()
#support_y = np.zeros((self.cls_num), dtype=np.int)
flatten_x = [os.path.join(self.path, item) for item in support_x_temp]
temp = [self.img2label[item[:9]] for item in support_x_temp]
support_y = np.array(temp).astype(np.int32)
for i, path in enumerate(flatten_x):
support_x[i] = self.transform(path)
self.loading_data = DataSubset(support_x, torch.LongTensor(support_y))
# Hyper-parameters
latent_size = 64
hidden_size = 256
image_size = 784
num_epochs = 200
batch_size = 100
sample_dir = 'sample'
# Create a directory if not exists
if not os.path.exists(sample_dir):
os.makedirs(sample_dir)
# Image processing
transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5, ), (0.5, ))])
# MNIST dataset
mnist = torchvision.datasets.MNIST(root='../data/',
train=True,
transform=transform,
download=True)
# Data loader
data_loader = torch.utils.data.DataLoader(dataset=mnist,
batch_size=batch_size,
shuffle=True)
# Discriminator
D = nn.Sequential(nn.Linear(image_size, hidden_size), nn.LeakyReLU(0.2),
nn.Linear(hidden_size, hidden_size), nn.LeakyReLU(0.2),
def __getitem__(self, idx):
fileLocation = self.data[idx]['image']
inputI = Image.open(open(fileLocation, 'rb')).convert('RGB')
imageShow = inputI
imagelabel = self.data[idx]['label']
#output = self.data[idx]['label']
#inputI = rescale(inputI, OUTPUT_SIZE)
#inputI = torch.from_numpy(inputI)
#inputI = inputI.view(1, 64, 64)
#if self.normalize:
composed = transforms.Compose([transforms.Resize((128,128)), transforms.ToTensor(),transforms.Normalize((0.5,), (0.5,))])
inputI = composed(inputI)
output = self.onehot[self.data[idx]['label']]
#imageShow.show()
return inputI, output
from geomstats.learning.preprocessing import ToTangentSpace
from geomstats.visualization import Sphere
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
from sklearn.preprocessing import StandardScaler
from torch.nn import CrossEntropyLoss
from torchvision.datasets import CIFAR10
from torchvision.models import resnet18
from torchvision.transforms import transforms
import numpy as np
from tqdm import tqdm
from matplotlib import pyplot as plt
if __name__ == '__main__':
transform = transforms.Compose((transforms.ToTensor(), transforms.Normalize(0.5, 0.5, 0.5)))
test_dataset = CIFAR10('data', train=True, transform=transform, download=False)
net = resnet18(pretrained=False, num_classes=10).eval()
net.load_state_dict(torch.load('saves/resnet18_cifar10.sv'))
image_size = 32 * 32 * 3
num_images = 3000
features = np.zeros((0, image_size))
labels = []
for idx, data in enumerate(tqdm(test_dataset)):
if idx == num_images:
break
features = np.concatenate((features, data[0].reshape((1, image_size)).numpy()))
labels.append(data[1])
def main():
BATCH_SIZE = 100
LR = 1e-3
EPOCHS = 15
print('Number of epochs: ', EPOCHS)
print('Learning Rate: ', LR)
print('Batch size: ', BATCH_SIZE)
transforms_ = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0, ), (1, ))])
mnist_train = datasets.FashionMNIST('../data',
train=True,
download=True,
transform=transforms_)
dataset_train = SiameseDataset(mnist_train)
sTrainDataLoader = DataLoader(dataset_train,
batch_size=BATCH_SIZE,
shuffle=True,
num_workers=6)
mnist_test = datasets.FashionMNIST('../data',
train=False,
download=True,
transform=transforms_)
dataset_test = SiameseDataset(mnist_test)
sTestDataLoader = DataLoader(dataset_test,
batch_size=BATCH_SIZE,
shuffle=False,
num_workers=6)
pairwise_loss = ParwiseLoss()
net = Net()
net.cuda()
optimizer = optim.Adam(net.parameters(), lr=LR)
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer,
mode='min',
factor=0.1,
patience=1,
verbose=True)
train_losses = []
test_losses = []
for epoch in range(EPOCHS):
print('Epoch:{} '.format(epoch))
train_loss = train(net, optimizer, sTrainDataLoader, pairwise_loss)
test_loss = test(net, sTestDataLoader, pairwise_loss)
scheduler.step(test_loss)
train_losses.append(train_loss)
test_losses.append(test_loss)
sTestDataLoader2 = DataLoader(dataset_test,
batch_size=10000,
shuffle=False,
num_workers=6)
emb = getembeddings(net, sTestDataLoader2)
plotLoss(EPOCHS, train_losses, test_losses)
plot2D(emb)
plt.title(cvt_title)
plt.pause(3) # edit showing time
df = pd.read_excel('./sample_data/KFace_data_information_Folder1_400.xlsx'
) # change xlsx file directory
train_transforms = transforms.Compose([
transforms.Resize((224, 224)),
transforms.RandomHorizontalFlip(),
transforms.RandomChoice([
transforms.ColorJitter(0.2, 0.2, 0.2, 0.2),
]),
transforms.ToTensor(),
transforms.Normalize((0.4452, 0.4457, 0.4464), (0.2592, 0.2596, 0.2600)),
])
if __name__ == '__main__':
train_dataset = ImageFolder(
root='./sample_data/image',
transform=train_transforms) # change image directory
train_loader = DataLoader(train_dataset,
batch_size=4,
shuffle=True,
num_workers=4)
for batch, (input, targets) in enumerate(train_loader):
out = make_grid(input)
imshow(out, title=targets, df=df)
cudnn.benchmark = True
else:
device = torch.device("cpu")
if not os.path.exists(args.output_folder):
os.mkdir(args.output_folder)
nlabel = 6
transform = {}
transform['train'] = transforms.Compose([
transforms.RandomVerticalFlip(),
transforms.RandomHorizontalFlip(),
transforms.RandomHorizontalFlip(),
transforms.RandomRotation(10),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224,
0.225]),
])
transform['val'] = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224,
0.225]),
])
transform['test'] = transform['val']
'''
extract_images("001c62abd11fa4b57bf7a6c603a11bb9",
"/kaggle/input/prostate-cancer-grade-assessment/train_images",
256,
False)
'''
def main(args):
transform = transforms.Compose([
transforms.Resize((args.img_size, args.img_size)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.224])
])
dset_train = ArgoDataset(args, transform)
train_loader = DataLoader(dset_train,
batch_size=args.batch_size,
shuffle=False,
collate_fn=collate_video)
# dataloader_iterator = iter(train_loader)
# X= next(dataloader_iterator)
args.device = None
if not args.disable_cuda and torch.cuda.is_available():
args.device = torch.device('cuda')
else:
args.device = torch.device('cpu')
if args.model_type == 'resnet152':
model = models.resnet152(pretrained=True)
for par in model.parameters():
par.requires_grad = False
# model.layer4.register_forward_hook(hook)
model.fc = Identity()
if args.model_type == 'resnet101':
resnet = models.resnet101(pretrained=True)
model = nn.Sequential(
resnet.conv1,
resnet.bn1,
resnet.relu,
resnet.maxpool,
resnet.layer1,
resnet.layer2,
resnet.layer3,
)
if args.model_type == 'vgg16':
vgg16 = models.vgg16(pretrained=True)
model = vgg16.features
# Enable multi-GPU execution if needed.
if torch.cuda.device_count() > 1:
print("Using ", torch.cuda.device_count(), "GPUs!")
model = nn.DataParallel(model)
model.to(device=args.device)
model.eval()
filename = os.path.join(
args.output_base, args.model_type + '_' + args.split + '_features.h5')
hf = h5py.File(filename, 'w')
with torch.no_grad():
for batch in tqdm(train_loader):
image_names, video_idxs, images = batch
images = images.to(device=args.device)
output = model(images)
output = output.detach().cpu()
print(output.shape)
for i in range(output.size(0) // 7):
start = i * args.num_frames
end = (i + 1) * args.num_frames
name = str(image_names[i]) + '@' + str(video_idxs[i])
hf.create_dataset(name=name, data=output[start:end])
hf.close()
if sum_loss < best_loss:
best_loss = sum_loss
state = {
'net': net.state_dict(),
'loss': best_loss,
'epoch': epoch,
}
if not os.path.isdir('checkpoint'):
os.mkdir('checkpoint')
torch.save(state, './checkpoint/ckpt.pth')
if __name__ == '__main__':
img_trans = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
])
train_set = VocDataset(root=r"H:\drone_image_and_annotation_mixed\train",
train=True,
transform=img_trans,
input_size=1080)
train_loader = DataLoader(dataset=train_set,
batch_size=12,
shuffle=True,
sampler=None,
batch_sampler=None,
num_workers=12,
pin_memory=True,
drop_last=True,
collate_fn=collate_fn,
timeout=0,
ActiveLearningDataModule,
ActiveLearningLoop,
)
from baal.active import get_heuristic
log = structlog.get_logger()
IMG_SIZE = 128
train_transforms = transforms.Compose([
transforms.Resize((IMG_SIZE, IMG_SIZE)),
transforms.RandomHorizontalFlip(),
transforms.RandomRotation(30),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
test_transforms = transforms.Compose([
transforms.Resize((IMG_SIZE, IMG_SIZE)),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
class DataModule_(ImageClassificationData):
@property
def num_classes(self):
return 10
def get_data_module(heuristic, data_path):
def ext_face_feats(sphere_face,
img_path,
pretrained_model=os.path.join(cfg['model_zoo_base'],
'sphere20a.pth')):
"""
extract face features
:param sphere_face:
:param img_path:
:param pretrained_model:
:return:
"""
assert os.path.exists(pretrained_model)
if sphere_face is None:
sphere_face = SphereFaceNet()
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
sphere_face.load_state_dict(torch.load(pretrained_model))
sphere_face = sphere_face.to(device)
img = cv2.imread(img_path)
mtcnn_result = detect_face(img_path)
print(mtcnn_result)
if len(mtcnn_result) > 0:
bbox = mtcnn_result[0]['box']
margin_pixel = 10
face_region = img[bbox[0] - margin_pixel:bbox[0] + bbox[2] +
margin_pixel, bbox[1] - margin_pixel:bbox[1] +
bbox[3] + margin_pixel]
ratio = max(face_region.shape[0], face_region.shape[1]) / min(
face_region.shape[0], face_region.shape[1])
if face_region.shape[0] < face_region.shape[1]:
face_region = cv2.resize(face_region, (int(ratio * 64), 64))
face_region = face_region[:,
int((face_region.shape[0] - 64) /
2):int((face_region.shape[0] - 64) /
2) + 64]
else:
face_region = cv2.resize(face_region, (64, int(ratio * 64)))
face_region = face_region[int((face_region.shape[1] - 64) /
2):int((face_region.shape[1] - 64) /
2) + 64, :]
face_region = Image.fromarray(face_region.astype(np.uint8))
preprocess = transforms.Compose([
transforms.Resize((96, 112)),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
face_region = preprocess(face_region)
face_region.unsqueeze_(0)
face_region = face_region.to(device)
x = face_region.to(device)
x = sphere_face.forward(x)
x = x.to("cpu").detach().numpy().flatten()
return {
'status': 0,
'message': 'extracted feature',
'feature': x / np.linalg.norm(x)
}
else:
return {'status': 0, 'message': 'No face detected!', 'feature': None}
from torchvision.transforms import transforms
from Resnet import ResNet, BasicBlock
from SwatsVanillaGlobal import SwatsVanillaGlobal
import numpy as np
import math
import matplotlib.pyplot as plt
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
print(device)
batch_is = 128
transform_train = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(mean=[0.4914, 0.4822, 0.4465],
std=[0.247, 0.243, 0.261])
])
transform_test = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.4914, 0.4822, 0.4465],
std=[0.247, 0.243, 0.261])
])
trainset = torchvision.datasets.CIFAR10(root='./data',
train=True,
download=True,
transform=transform_train)
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=batch_is,
shuffle=True,
num_workers=1,
NUM_EPOCHS = 25
degree = 45
def binary(c):
for index in range(len(c)):
if c[index] > 0.5:
c[index] = 1
else:
c[index] = 0
return c
normMean = [0.4948052, 0.48568845, 0.44682974]
normStd = [0.24580306, 0.24236229, 0.2603115]
normTransform = transforms.Normalize(normMean, normStd)
transform = transforms.Compose([
transforms.RandomHorizontalFlip(p=0.5),
torchvision.transforms.RandomVerticalFlip(p=0.5),
transforms.RandomRotation(degrees=degree,
resample=False,
expand=False,
center=None),
transforms.ToTensor(), normTransform
])
test_dataset = MyDataset(root_dir='./archive',
root_dir1='/test/',
names_file='/sampleSubmission.csv',
transform=transform)
def main():
'''Main entrypoint function for training.'''
# Parse command-line arguments
args = parse_args()
fmt = {'disc_loss':'.5e', 'gen_loss':'.5e' }
logger_name = "wgan-train_"+args.optimizer
logger = Logger(logger_name, fmt=fmt)
logger_disc = Logger(logger_name+"_discriminator", fmt=fmt)
logger_gen = Logger(logger_name+"_generator", fmt=fmt)
# Create directory for saving outputs
os.makedirs('out', exist_ok=True)
# Initialise CIFAR-10 data loader
# train_loader = DataLoader(torchvision.datasets.CIFAR10('./data/cifar-10'),
# args.batch_size, num_workers = 4, pin_memory = True, drop_last = True)
transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
trainset = torchvision.datasets.CIFAR10(root='./data/cifar-10', train=True,
download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(trainset, batch_size=args.batch_size,
shuffle=True, num_workers=2)
inf_train_data = loop_data_loader(train_loader)
# Build neural network models and copy them onto the GPU
generator = Generator().cuda()
discriminator = Discriminator().cuda()
# Select which Lipschitz constraint to use
if args.unimproved:
lipschitz_constraint = lipschitz.WeightClipping(discriminator)
else:
lipschitz_constraint = lipschitz.GradientPenalty(discriminator)
# Initialise the parameter optimisers
optim_gen = optim.Adam(generator.parameters(), lr=2e-4, betas=(0, 0.999))
if args.optimizer == "adashift":
optim_disc = AdaShift(discriminator.parameters(), lr=2e-4, betas=(0, 0.999))
elif args.optimizer == "amsgrad":
optim_disc = optim.Adam(discriminator.parameters(), lr=2e-4, betas=(0, 0.999), amsgrad=True)
else:
assert args.optimizer == "adam"
optim_disc = optim.Adam(discriminator.parameters(), lr=2e-4, betas=(0, 0.999))
i,j = 0, 0
# Run the main training loop
for epoch in range(args.epochs):
avg_disc_loss = 0
avg_gen_loss = 0
for gen_iter in range(args.gen_iters):
# Train the discriminator (aka critic)
for _ in range(args.disc_iters):
inputs, labels = next(inf_train_data)
inputs.requires_grad = True
real_var = inputs.cuda()
disc_loss = calculate_disc_gradients(
discriminator, generator, real_var, lipschitz_constraint)
avg_disc_loss += disc_loss.item()
optim_disc.step()
if i % args.log_interval == 0:
logger_disc.add_scalar(i, 'disc_loss', disc_loss.item())
i += 1
# Train the generator
gen_loss = calculate_gen_gradients(discriminator, generator, args.batch_size)
avg_gen_loss += gen_loss.item()
optim_gen.step()
if j % args.log_interval == 0:
logger_gen.add_scalar(j, 'gen_loss', gen_loss.item())
j += 1
# # Save generated images
# torchvision.utils.save_image((generator.last_output.data.cpu() + 1) / 2,
# 'out/samples.png', nrow=8, range=(-1, 1))
# Advance the progress bar
progress.bar(gen_iter + 1, args.gen_iters,
prefix='Epoch {:4d}'.format(epoch), length=30)
# Calculate mean losses
avg_disc_loss /= args.gen_iters * args.disc_iters
avg_gen_loss /= args.gen_iters
logger.add_scalar(epoch, 'gen_loss', avg_gen_loss)
logger.add_scalar(epoch, 'disc_loss', avg_disc_loss)
inception_score = compute_inception_score(generator, generator_batch_size=args.batch_size)
logger.add_scalar(epoch, "inception_score_mean", inception_score[0])
logger.add_scalar(epoch, "inception_score_std", inception_score[1])
logger_disc.save()
logger_gen.save()
logger.save()
# Print loss metrics for the last batch of the epoch
print(f"\nepoch {epoch}:"
f" disc_loss={disc_loss:8.4f}"
f" gen_loss={gen_loss:8.4f}"
f" inception_score={inception_score[0]:8.4f}")
# Save the discriminator weights and optimiser state
torch.save({
'epoch': epoch + 1,
'model_state': discriminator.state_dict(),
'optim_state': optim_disc.state_dict(),
}, os.path.join('out',args.optimizer + '_discriminator.pth'))
# Save the generator weights and optimiser state
torch.save({
'epoch': epoch + 1,
'model_state': generator.state_dict(),
'optim_state': optim_gen.state_dict(),
}, os.path.join('out', args.optimizer+'_generator.pth'))
import os
import argparse
import numpy as np
import cv2
import torch
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import transforms
from torchvision.models.resnet import resnet18
transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
parser = argparse.ArgumentParser()
parser.add_argument('--dataset-dir',
type=str,
default='PKUMMDv1',
help='dataset directory')
parser.add_argument('--gpu',
default=False,
action='store_true',
help='whether to use gpus for training')
parser.add_argument('--batch-size', type=int, default=1, help='batch size')
parser.add_argument('--num-workers',
type=int,
default=4,
help='number of workers for multiprocessing')
parser.add_argument('--model-path',
from torchvision.transforms import transforms
from tqdm import tqdm
from matplotlib import pyplot as plt
import numpy as np
# If you get 503 while downloading MNIST then download it manually
# wget www.di.ens.fr/~lelarge/MNIST.tar.gz
# tar -zxvf MNIST.tar.gz
BATCH_SIZE = 32
DEVICE = torch.device('cuda:0') if torch.cuda.is_available() else torch.device(
'cpu')
transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))])
trainset = tv.datasets.MNIST(root='.',
train=True,
download=True,
transform=transform)
dataloader = DataLoader(trainset,
batch_size=BATCH_SIZE,
shuffle=True,
num_workers=0)
def imshow(axs, inp):
inp = inp.cpu().detach().numpy()
mean = 0.1307
std = 0.3081
inp = ((mean * inp) + std)
