def get_datasets(initial_pool, path):
IM_SIZE = 224
# TODO add better data augmentation scheme.
transform = transforms.Compose([
transforms.Resize(512),
transforms.CenterCrop(IM_SIZE),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
])
test_transform = transforms.Compose([
transforms.Resize(512),
transforms.CenterCrop(IM_SIZE),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
])
target_transform = transforms.Compose([
transforms.Resize(512, interpolation=Image.NEAREST),
transforms.CenterCrop(IM_SIZE),
PILToLongTensor(pascal_voc_ids),
])
active_set, test_set = active_pascal(
path=path,
transform=transform,
test_transform=test_transform,
target_transform=target_transform,
)
active_set.label_randomly(initial_pool)
return active_set, test_set
def _handle_STL(self,
Dataset,
data_path,
transform=None,
labeled_only=False,
stl_center_crop=False,
stl_resize_only=False,
stl_no_resize=False):
normalize = transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
if stl_no_resize:
train_transform = transforms.Compose([
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])
test_transform = transforms.Compose([
transforms.ToTensor(),
normalize,
])
else:
if stl_center_crop:
tr_trans = transforms.CenterCrop(64)
te_trans = transforms.CenterCrop(64)
elif stl_resize_only:
tr_trans = transforms.Resize(64)
te_trans = transforms.Resize(64)
elif stl_no_resize:
pass
else:
tr_trans = transforms.RandomResizedCrop(64)
te_trans = transforms.Resize(64)
train_transform = transforms.Compose([
tr_trans,
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])
test_transform = transforms.Compose([
te_trans,
transforms.ToTensor(),
normalize,
])
if labeled_only:
split = 'train'
else:
split = 'train+unlabeled'
train_set = Dataset(data_path,
split=split,
transform=train_transform,
download=True)
test_set = Dataset(data_path,
split='test',
transform=test_transform,
download=True)
return train_set, test_set
def build_file_list(self, csv_path_1, csv_path_2):
if self.dataset_type == 'train':
with open(csv_path_1) as csv_train:
csv_reader = csv.reader(csv_train)
for index, row_item in enumerate(csv_reader):
if index == 0:
continue
self.image_name_list_base.append(row_item[0])
self.index_list_base.append(index - 1)
last_index = self.index_list_base[-1]
with open(csv_path_2) as csv_val:
csv_reader = csv.reader(csv_val)
for index, row_item in enumerate(csv_reader):
if index == 0:
continue
self.image_name_list_base.append(row_item[0])
self.index_list_base.append(last_index + index - 1)
else:
with open(csv_path_1) as csv_test:
csv_reader = csv.reader(csv_test)
for index, row_item in enumerate(csv_reader):
if index == 0:
continue
self.image_name_list_base.append(row_item[0])
self.index_list_base.append(index - 1)
self.label_list_base = [
i for i in range(self.num_classes) for _ in range(600)
]
random.shuffle(self.index_list_base)
self.image_name_list = [
self.image_name_list_base[i] for i in self.index_list_base
]
self.label_list = [
self.label_list_base[i] for i in self.index_list_base
]
self.mean = np.array([x / 255.0 for x in [125.3, 123.0, 113.9]])
self.std = np.array([x / 255.0 for x in [63.0, 62.1, 66.7]])
if self.data_aug is True:
self.transform = transforms.Compose([
transforms.Resize(92),
transforms.RandomResizedCrop(88),
transforms.CenterCrop(self.img_size),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(self.mean, self.std)
])
else:
self.transform = transforms.Compose([
transforms.Resize(92),
transforms.CenterCrop(self.img_size),
transforms.ToTensor(),
transforms.Normalize(self.mean, self.std)
])
def __load_the_data(train_dir, test_dir, batch_size, data_augmentation):
# Assign transform values with respect to the data augmentation strategy
if data_augmentation:
# Set normalization metrics for the data loaders
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_transform_list = [
transforms.RandomHorizontalFlip(),
transforms.RandomResizedCrop(224),
transforms.ToTensor(),
normalize,
]
test_transform_list = [
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
]
else:
# Set normalization metrics for the data loaders
normalize = transforms.Normalize(mean=[0.5, 0.5, 0.5],
std=[0.5, 0.5, 0.5])
train_transform_list = [
transforms.RandomResizedCrop(224),
transforms.ToTensor(),
normalize,
]
test_transform_list = [
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
]
# Load the train directory and shuffle the images
train_loader = torch.utils.data.DataLoader(
datasets.ImageFolder(train_dir,
transforms.Compose(train_transform_list)),
batch_size=batch_size,
shuffle=True,
)
# Load the test directory
test_loader = torch.utils.data.DataLoader(
datasets.ImageFolder(test_dir,
transforms.Compose(test_transform_list)),
batch_size=batch_size,
)
return train_loader, test_loader
def return_transform(model_name):
if model_name == 'madry':
preprocessFn = transforms.Compose([transforms.Resize((256, 256)),
transforms.CenterCrop(224),
transforms.ToTensor(),
])
elif model_name in ['pytorch', 'googlenet']:
preprocessFn = transforms.Compose([transforms.Resize((256, 256)),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
return preprocessFn
def load_data(traindir, valdir, img_size=224, crop_pct=0.875):
# Data loading code
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
scale_size = min(int(math.floor(img_size / crop_pct)), 320)
print("Loading training data")
st = time.time()
train_set = ImageFolder(
traindir,
transforms.Compose([
transforms.RandomResizedCrop(img_size, scale=(0.3, 1.0)),
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(brightness=0.3,
contrast=0.3,
saturation=0.1,
hue=0.02),
transforms.ToTensor(), normalize,
transforms.RandomErasing(p=0.9, value='random')
]))
print("Took", time.time() - st)
print("Loading validation data")
eval_tf = []
if scale_size < 320:
eval_tf.append(transforms.Resize(scale_size))
eval_tf.extend(
[transforms.CenterCrop(img_size),
transforms.ToTensor(), normalize])
val_set = ImageFolder(valdir, transforms.Compose(eval_tf))
return train_set, val_set
def compute_mean_std(path):
dataset = datasets.ImageFolder(os.path.join(path, 'train'),
transform=transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor()
]))
loader = DataLoader(dataset, batch_size=10, num_workers=0, shuffle=False)
mean = 0.0
for images, _ in loader:
batch_samples = images.size(0)
images = images.view(batch_samples, images.size(1), -1)
mean += images.mean(2).sum(0)
mean = mean / len(loader.dataset)
var = 0.0
for images, _ in loader:
batch_samples = images.size(0)
images = images.view(batch_samples, images.size(1), -1)
var += ((images - mean.unsqueeze(1))**2).sum([0, 2])
std = torch.sqrt(var / (len(loader.dataset) * 224 * 224))
return mean, std
def create_testing_data_transform(input_size):
return transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(input_size),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
def __init__(self, split: str = "train", resize_s=256, size=10e9):
"""
:type resize_s: int or tuple(w,h)
:param dataset_path: dataset directory
:param split: train, valid, test"""
t = []
if split == "train":
t.extend([
transforms.RandomResizedCrop(resize_s),
transforms.RandomHorizontalFlip(),
])
else:
t.extend(
[transforms.Resize(resize_s),
transforms.CenterCrop(resize_s)])
t.extend([
transforms.ToTensor()
# transforms.Normalize(self.mean, self.std)
])
self.trans = transforms.Compose(t)
self.env = connect_dict()
self.env_iter = iter(connect_dict())
self.size = size
def __init__(self):
## these are the potential labels for objects
self.labels = ['1','2','3','A','B', 'C']
## This try/except statement is if you are running the file itself to run the test method or importing it. The model.pt will be different location based on the context of who calls it.
try:
## Loading model
self.model = torch.hub.load('pytorch/vision:v0.5.0', 'alexnet', pretrained=True)
self.model.load_state_dict(torch.load('model_handler/model.pt'))
self.model.eval()
except Exception:
try:
## Loading model
self.model = torch.hub.load('pytorch/vision:v0.5.0', 'alexnet', pretrained=True)
self.model.load_state_dict(torch.load('model.pt'))
self.model.eval()
except:
print('System model not detected, please assure that "model.pt" is downloaded..')
sys.exit(1)
## Creates a transformer object.
## This transformer does the following, resizes the image and crops to the resize. Grayscales it. transforms it to a tensor object and normalizes the pixel values
self.trans = transforms.Compose([
transforms.Resize(224),
transforms.Grayscale(num_output_channels=3),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([.5, 0.5, 0.5], [0.5, 0.5, 0.5])
])
def main():
model = MURA_Net()
model = model.to(device)
model.load_state_dict(torch.load('./models/model.pth'))
preprocess = transforms.Compose([
transforms.Resize((320, 320)),
transforms.CenterCrop(224),
# transforms.Resize((224,224)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
paths = [
'./MURA-v1.0/valid/XR_WRIST/patient11323/study1_positive/image1.png',
'./MURA-v1.0/valid/XR_FOREARM/patient11470/study1_positive/image2.png',
'./MURA-v1.0/valid/XR_FOREARM/patient11470/study1_positive/image3.png'
]
img_pils = map(pil_loader, paths)
img_tensors = list(map(preprocess, img_pils))
img_variable = torch.stack(img_tensors).to(device)
print(img_tensors[0])
x = grad_cam(model, img_variable[2].unsqueeze(0))
print(x)
def predict_image(image_path):
print("Prediction in progress")
image = Image.open(image_path)
# Define transformations for the image, should (note that imagenet models are trained with image size 224)
transformation = transforms.Compose([
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
# Preprocess the image
image_tensor = transformation(image).float()
# Add an extra batch dimension since pytorch treats all images as batches
image_tensor = image_tensor.unsqueeze_(0)
if torch.cuda.is_available():
image_tensor.cuda()
# Turn the input into a Variable
input = Variable(image_tensor)
# Predict the class of the image
output = model(input)
index = output.data.numpy().argmax()
return index
def __init__(self, mode='test'):
"""
:param mode:
"""
csv_path = osp.join(ROOT, mode + '.csv')
lines = [x.strip() for x in open(csv_path, 'r').readlines()][1:]
self.data_file = []
self.label = []
lb = -1
cls = []
for l in lines:
name, cid = l.split(',')
path = osp.join(ROOT, 'images', name)
if cid not in cls:
cls.append(cid)
lb += 1
self.data_file.append(path)
self.label.append(lb)
self.transform = transforms.Compose([
lambda x: Image.open(x).convert('RGB'),
transforms.Resize(84),
transforms.CenterCrop(84),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
def make_data(options):
data_prefix = os.path.join(DATA, 'data')
# 可能需要进行处理, 默认图像大小为 32, 原文中没有对图像进行 disort(random flip)
crop_size = options['cifar100_image_size']
# tff 中使用的 per_image_standard
CIFAR100_MEAN = (0.5070751592371323, 0.48654887331495095,
0.4409178433670343)
CIFAR100_STD = (0.2673342858792401, 0.2564384629170883,
0.27615047132568404)
train_transform = transforms.Compose([
transforms.ToPILImage(),
# TODO 目标大小24, 应该不会调用 padding
transforms.RandomCrop(crop_size, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(CIFAR100_MEAN, CIFAR100_STD),
])
valid_transform = transforms.Compose([
transforms.ToPILImage(),
# 根据 tff 给出的实验设置
transforms.CenterCrop(crop_size),
transforms.ToTensor(),
transforms.Normalize(CIFAR100_MEAN, CIFAR100_STD),
])
train_client_data = _CIFAR100TFFVersion(data_prefix=data_prefix,
is_train=True)
test_client_data = _CIFAR100TFFVersion(data_prefix=data_prefix,
is_train=False)
train_clients, train_data = create_dataset(train_client_data,
trans=train_transform)
test_clients, test_data = create_dataset(test_client_data,
trans=valid_transform)
return train_clients, train_data, test_clients, test_data
def predict_image_class(image_path):
image = Image.open(image_path)
image = image.convert('RGB') # Model expects RGB.
transformation = transforms.Compose([
transforms.CenterCrop(200), # Image size defined here.
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
# Preprocess the image.
image_tensor = transformation(image).float()
# Add an extra batch dimension since pytorch treats all images as batches.
image_tensor = image_tensor.unsqueeze_(0)
if torch.cuda.is_available():
image_tensor.cuda()
# Turn the input into a Variable
input = Variable(image_tensor)
# Predict the class of the image.
output = model(input)
index = output.data.numpy().argmax()
return index
def prepare_data_loaders(data_path):
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
dataset = torchvision.datasets.ImageNet(
data_path,
split="train",
transform=transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(), normalize
]))
dataset_test = torchvision.datasets.ImageNet(
data_path,
split="val",
transform=transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(), normalize
]))
train_sampler = torch.utils.data.RandomSampler(dataset)
test_sampler = torch.utils.data.SequentialSampler(dataset_test)
data_loader = torch.utils.data.DataLoader(dataset,
batch_size=train_batch_size,
sampler=train_sampler)
data_loader_test = torch.utils.data.DataLoader(dataset_test,
batch_size=eval_batch_size,
sampler=test_sampler)
return data_loader, data_loader_test
def asijda():
""" """
a_transform = transforms.Compose([
transforms.ToPILImage("RGB"),
transforms.Resize(224),
transforms.CenterCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
])
channels_in = 3
# channels_out = 3
# samples = 10
device = "cuda"
batches = 3
batch_size = 32
data_shape = (batches * batch_size, 256, 256, channels_in)
generator = to_tensor_generator(
inner_map(
a_transform,
batched_recycle(numpy.random.sample(data_shape), batch_size),
),
device=device,
)
for i, a in enumerate(generator):
print(a)
break
def infer(self, img_file):
img = Image.open(img_file)
preprocess = transforms.Compose([
transforms.Resize(224),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
img = preprocess(img)
img.unsqueeze_(0)
img = img.to(self.device)
outputs = self.model(img)
outputs = F.softmax(outputs, dim=1)
topK_prob, topK_label = torch.topk(outputs, self.topK)
prob = topK_prob.to("cpu").detach().numpy().tolist()
_, predicted = torch.max(outputs.data, 1)
return [{
"prob": round(prob[0][i], 4),
"type": self.mapping[int(topK_label[0][i].to("cpu"))],
} for i in range(self.topK)]
def get_val_data():
root = '/home/ziran/文档/ILSVRC2012_img_val/'
meta = '/home/ziran/文档/meta/val.txt'
from torchvision.transforms import transforms
preprocess = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
from PIL import Image
with open(meta, 'r') as f:
content = f.readlines()
for i in range(0, len(content), batch_size):
batch = content[i:i + batch_size]
imgs = []
categories = []
for item in batch:
img_name, category = item.strip().split()
category = int(category)
with Image.open(root + img_name) as img:
img = img.convert('RGB')
img = preprocess(img)
imgs.append(img.detach().numpy())
categories.append(category)
yield {'data': np.stack(imgs), 'label': categories}
def create_test_dataloaders(config, dataset_dir):
input_info = create_input_infos(config)[0]
image_size = input_info.shape[-1]
batch_size = input_info.shape[0]
normalize = transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
train_transforms = transforms.Compose([
transforms.CenterCrop(image_size),
transforms.ToTensor(),
normalize,
])
dummy_config = type('dummy', (object, ), {'dataset_dir': dataset_dir})()
train_dataset = create_cifar(dummy_config,
dataset_config='cifar10',
is_train=True,
transform=train_transforms)
# Do not set num_workers > 0 here - random hangs occur during pytest runs of this files
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=batch_size,
shuffle=False,
pin_memory=True,
drop_last=True)
return train_loader, train_dataset
def __init__(self, mode='test'):
"""
:param mode:
:return:
"""
base_dir = osp.join(CIFAR_ROOT, mode)
cls_id = -1
self.data_file = []
self.label = []
for cls in os.listdir(base_dir):
cls_id += 1
sub_dir = osp.join(base_dir, cls)
for file in os.listdir(sub_dir):
self.data_file.append(osp.join(sub_dir, file))
self.label.append(cls_id)
self.transform = transforms.Compose([
lambda x: Image.open(x).convert('RGB'),
transforms.Resize(84),
transforms.CenterCrop(84),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
def predict(model, image):
"""
Function name : predict
Inputs parameters :
model -> trained model
image -> image to be predicted
Output : return the predicted image
"""
global class_names
model.eval() # Update initial weights of the model
# pre-processing the image
# ------------------------
img_loader = transforms.Compose([
transforms.Resize(247),
transforms.CenterCrop(224),
transforms.ToTensor()
])
pil_image = img_loader(image).float()
np_image = np.array(pil_image)
mean = np.array([0.485, 0.456, 0.406])
std = np.array([0.229, 0.224, 0.225])
np_image = (np.transpose(np_image, (1, 2, 0)) - mean) / std
np_image = np.transpose(np_image, (2, 0, 1))
image = torch.FloatTensor(np_image)
#image = Variable(image)
image = image.unsqueeze(0).float()
outputs = model(
image) # pre-processed image is sent to model for prediction.
_, preds = torch.max(outputs,
1) # Returns the most likely class name for the image
pred = class_names[preds[0]]
return pred
def create_dataloader(args):
train_transform = transforms.Compose([
# Resize(128),
transforms.Scale(256),
transforms.RandomCrop((224, 224)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
# transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
])
test_transform = transforms.Compose([
# Resize(128),
transforms.Scale(256),
transforms.CenterCrop((224, 224)),
transforms.ToTensor(),
# transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
train_path = os.path.join(args.data_path, 'train')
test_path = os.path.join(args.data_path, 'test')
train_dataset = dataset.ImageFolder(root=train_path, ground_truth=True, transform=train_transform)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=4)
test_dataset = dataset.ImageFolder(root=test_path, ground_truth=False, transform=test_transform)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=1, shuffle=False, num_workers=4)
return train_loader, test_loader
def get_dataloader(data_root_dir):
data_transforms = {
'train':
transforms.Compose([
transforms.RandomResizedCrop(IMAGE_SIZE),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
'val':
transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(IMAGE_SIZE),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
}
image_datasets = {
x: datasets.ImageFolder(os.path.join(data_root_dir, x),
data_transforms[x])
for x in ['train', 'val']
}
dataloaders = {
x: torch.utils.data.DataLoader(image_datasets[x],
batch_size=BATCH_SIZE,
shuffle=True,
num_workers=4)
for x in ['train', 'val']
}
return dataloaders, image_datasets, image_datasets['train'].classes
def load_hymenoptera():
data_dir = 'data/hymenoptera_data'
train_transform = transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
data_transforms = {
'train':
train_transform,
'val':
transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
}
image_datasets = {
x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x])
for x in ['train', 'val']
}
dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}
class_names = image_datasets['train'].classes
dataloaders = {
x: torch.utils.data.DataLoader(image_datasets[x],
batch_size=4,
shuffle=True,
num_workers=4)
for x in ['train', 'val']
}
return dataloaders['train'], dataloaders['val'], class_names
def infer(self, img):
if isinstance(img, str):
img = Image.open(img)
preprocess = transforms.Compose([
transforms.Resize(224),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
img = preprocess(img)
img.unsqueeze_(0)
img = img.to(self.device)
outputs = self.model(img)
outputs = F.softmax(outputs, dim=1)
topK_prob, topK_label = torch.topk(outputs, self.topK)
prob = topK_prob.to("cpu").detach().numpy().tolist()
_, predicted = torch.max(outputs.data, 1)
if prob[0][0] >= cfg['thresholds']['skin_disease_recognition']:
return [{
"disease": self.mapping[int(topK_label[0][i].to("cpu"))],
"probability": round(prob[0][i], 4),
} for i in range(self.topK)]
else:
return [{
"disease": "Unknown",
"probability": round(prob[0][0], 4),
}]
def set_transform(resize=112, crop=112, normalize=None, additional=None):
if normalize is None or normalize is True:
normalize = [[0.485, 0.456, 0.406], [0.229, 0.224, 0.225]]
transform_list = [
transforms.Resize(resize),
transforms.CenterCrop(crop),
transforms.Grayscale(3)
]
if additional is not None:
transform_list.extend(additional)
transform_list.extend([transforms.ToTensor()])
if normalize is None or normalize is True:
normalize = [[0.485, 0.456, 0.406], [0.229, 0.224, 0.225]]
transform_list.extend(
[transforms.Normalize(mean=normalize[0], std=normalize[1])])
elif normalize is not False:
transform_list.extend(
[transforms.Normalize(mean=normalize[0], std=normalize[1])])
else:
pass
return transforms.Compose(transform_list)
def load_from_index(source=r'C:\datasets\google-landmarks\train\filtered_train_2.csv',
target=r'C:\datasets\google-landmarks\train\image-tensors-2',
image_size=84):
resize = transforms.Compose(
[
transforms.Resize(image_size),
transforms.CenterCrop(image_size),
]
)
normalize = transforms.Compose(
[
transforms.ToTensor(),
transforms.Normalize(mean=MEAN, std=STD)
]
)
transform = transforms.Compose(
[
resize,
normalize
]
)
index = pd.read_csv(source)
for i, row in enumerate(index.iterrows()):
done = False
url = None
attempts = 0
while not done:
attempts += 1
try:
label = str(row[1]['landmark_id'])
label_folder = os.path.join(target, label)
image_id = str(row[1]['id'])
image_path = os.path.join(label_folder, image_id + r'.pt')
if os.path.exists(image_path):
break
url = str(row[1]['url'])
os.makedirs(label_folder, exist_ok=True)
response = requests.get(url)
pil_image = Image.open(BytesIO(response.content))
pil_image = pil_image.convert('RGB')
image_tensor = transform(pil_image)
torch.save(image_tensor, image_path)
done = True
except (OSError, AttributeError):
if attempts <= ATTEMPTS:
print("Error with url %s, delay for %d second(s)" % (url, SLEEP))
time.sleep(SLEEP)
else:
done = True
print("Skipped")
if i % 50 == 0:
print(i)
def get_transform_val(self, size):
if self.crop == 'five' or self.crop == 'multi':
transform_val = [
transforms.Resize(int(size[0] * (1.14))),
transforms.FiveCrop(size)
]
transform_val.append(
transforms.Lambda(lambda crops: torch.stack(
[transforms.ToTensor()(crop) for crop in crops])))
transform_val.append(
transforms.Lambda(lambda crops: torch.stack([
transforms.Normalize([0.485, 0.456, 0.406],
[0.229, 0.224, 0.225])(crop)
for crop in crops
])))
else:
transform_val = [
transforms.Resize(int(size[0] * (1.14))),
transforms.CenterCrop(size)
]
transform_val.append(transforms.ToTensor())
transform_val.append(
transforms.Normalize([0.485, 0.456, 0.406],
[0.229, 0.224, 0.225]))
return transforms.Compose(transform_val)
def get_transforms(self)->tuple:
# MEAN, STD computed for sport8
MEAN = [0.4734, 0.4856, 0.4526]
STD = [0.2478, 0.2444, 0.2667]
# transformations match that in
# https://github.com/antoyang/NAS-Benchmark/blob/master/DARTS/preproc.py
train_transf = [
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(
brightness=0.4,
contrast=0.4,
saturation=0.4,
hue=0.2)
]
test_transf = [transforms.Resize(256), transforms.CenterCrop(224)]
normalize = [
transforms.ToTensor(),
transforms.Normalize(MEAN, STD)
]
train_transform = transforms.Compose(train_transf + normalize)
test_transform = transforms.Compose(test_transf + normalize)
return train_transform, test_transform
