def get_data_iters(batch_size):
train_set = [(name.split()[0], int(name.split()[1])) for name in open(opt.train_data).readlines()]
val_set = [(name.split()[0], int(name.split()[1])) for name in open(opt.val_data).readlines()]
normalizer = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
transform_train = transforms.Compose([
transforms.Resize(size=(opt.img_width, opt.img_height), interpolation=1),
transforms.RandomFlipLeftRight(),
Pad(10),
RandomCrop(size=(opt.img_width, opt.img_height)),
transforms.ToTensor(),
normalizer])
transform_test = transforms.Compose([
transforms.Resize(size=(opt.img_width, opt.img_height), interpolation=1),
transforms.ToTensor(),
normalizer])
train_imgs = ImageTxtDataset(opt.data_dir, train_set, transform=transform_train)
val_imgs = ImageTxtDataset(opt.data_dir, val_set, transform=transform_test)
train_data = gluon.data.DataLoader(train_imgs, batch_size, shuffle=True, last_batch='discard', num_workers=opt.num_workers)
val_data = gluon.data.DataLoader(val_imgs, batch_size, shuffle=True, last_batch='keep', num_workers=opt.num_workers)
return train_data, val_data
def get_data_iters(batch_size):
train_set, val_set = LabelList(ratio=opt.ratio, root=opt.dataset_root, name=opt.dataset)
normalizer = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
transform_train = transforms.Compose([
transforms.Resize(size=(opt.img_width, opt.img_height), interpolation=1),
transforms.RandomFlipLeftRight(),
RandomCrop(size=(opt.img_width, opt.img_height), pad=opt.pad),
transforms.ToTensor(),
normalizer])
train_imgs = ImageTxtDataset(train_set, transform=transform_train)
train_data = gluon.data.DataLoader(train_imgs, batch_size, shuffle=True, last_batch='discard', num_workers=opt.num_workers)
if opt.ratio < 1:
transform_test = transforms.Compose([
transforms.Resize(size=(opt.img_width, opt.img_height), interpolation=1),
transforms.ToTensor(),
normalizer])
val_imgs = ImageTxtDataset(val_set, transform=transform_test)
val_data = gluon.data.DataLoader(val_imgs, batch_size, shuffle=True, last_batch='discard', num_workers=opt.num_workers)
else:
val_data = None
return train_data, val_data
def _test_crop_resize_with_diff_type(dtype):
# test normal case
data_in = nd.arange(60).reshape((5, 4, 3)).astype(dtype)
out_nd = transforms.CropResize(0, 0, 3, 2)(data_in)
out_np = out_nd.asnumpy()
assert(out_np.sum() == 180)
assert((out_np[0:2,1,1].flatten() == [4, 16]).all())
# test 4D input
data_bath_in = nd.arange(180).reshape((2, 6, 5, 3)).astype(dtype)
out_batch_nd = transforms.CropResize(1, 2, 3, 4)(data_bath_in)
out_batch_np = out_batch_nd.asnumpy()
assert(out_batch_np.sum() == 7524)
assert((out_batch_np[0:2,0:4,1,1].flatten() == [37, 52, 67, 82, 127, 142, 157, 172]).all())
# test normal case with resize
data_in = nd.random.uniform(0, 255, (300, 200, 3)).astype(dtype)
out_nd = transforms.CropResize(0, 0, 100, 50, (25, 25), 1)(data_in)
data_expected = transforms.Resize(size=25, interpolation=1)(nd.slice(data_in, (0, 0, 0), (50, 100, 3)))
assert_almost_equal(out_nd.asnumpy(), data_expected.asnumpy())
# test 4D input with resize
data_bath_in = nd.random.uniform(0, 255, (3, 300, 200, 3)).astype(dtype)
out_batch_nd = transforms.CropResize(0, 0, 100, 50, (25, 25), 1)(data_bath_in)
for i in range(len(out_batch_nd)):
actual = transforms.Resize(size=25, interpolation=1)(nd.slice(data_bath_in[i], (0, 0, 0), (50, 100, 3))).asnumpy()
expected = out_batch_nd[i].asnumpy()
assert_almost_equal(expected, actual)
# test with resize height and width should be greater than 0
transformer = transforms.CropResize(0, 0, 100, 50, (-25, 25), 1)
assertRaises(MXNetError, transformer, data_in)
# test height and width should be greater than 0
transformer = transforms.CropResize(0, 0, -100, -50)
assertRaises(MXNetError, transformer, data_in)
# test cropped area is bigger than input data
transformer = transforms.CropResize(150, 200, 200, 500)
assertRaises(MXNetError, transformer, data_in)
assertRaises(MXNetError, transformer, data_bath_in)
def get_folder_data(train_path, val_path, data_shape, batch_size, num_workers=os.cpu_count()):
train_dataset = ImageFolderDataset(train_path)
val_dataset = ImageFolderDataset(val_path)
train_transformer = gluon.data.vision.transforms.Compose([
transforms.RandomFlipLeftRight(),
transforms.RandomResizedCrop(data_shape, scale=(0.5, 1.0)),
transforms.RandomBrightness(0.5),
transforms.RandomHue(0.1),
transforms.Resize(data_shape),
transforms.ToTensor()
])
val_transformer = gluon.data.vision.transforms.Compose([
transforms.Resize(data_shape),
transforms.ToTensor()
])
train_dataloader = data.DataLoader(train_dataset.transform_first(train_transformer),
batch_size=batch_size, shuffle=True, last_batch='rollover',
num_workers=num_workers)
val_dataloader = data.DataLoader(val_dataset.transform_first(val_transformer),
batch_size=batch_size, shuffle=True, last_batch='rollover',
num_workers=num_workers)
return train_dataloader, val_dataloader
def __init__(self,
name=None,
train_path=None,
val_path=None,
input_size=224,
crop_ratio=0.875,
jitter_param=0.4,
**kwargs):
self.name = name
self.train_path = train_path
self.val_path = val_path
self.input_size = input_size
resize = int(math.ceil(input_size / crop_ratio))
self.transform_train = transforms.Compose([
transforms.Resize(resize),
transforms.RandomResizedCrop(input_size),
transforms.RandomFlipLeftRight(),
transforms.RandomColorJitter(brightness=jitter_param,
contrast=jitter_param,
saturation=jitter_param),
transforms.RandomLighting(0.1),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
self.transform_val = transforms.Compose([
transforms.Resize(resize),
transforms.CenterCrop(input_size),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
self._read_dataset(**kwargs)
def get_data_raw(dataset_path, batch_size, num_workers):
train_path = os.path.join(dataset_path, 'train')
val_path = os.path.join(dataset_path, 'val')
test_path = os.path.join(dataset_path, 'test')
inp_size = (227, 170)
transform_train = transforms.Compose([
transforms.Resize(inp_size),
transforms.ToTensor(),
])
transform_test = transforms.Compose([
transforms.Resize(inp_size),
transforms.ToTensor(),
])
train_data = gluon.data.DataLoader(
gluon.data.vision.ImageFolderDataset(train_path).transform_first(transform_train),
batch_size=batch_size, shuffle=True, num_workers=num_workers)
val_data = gluon.data.DataLoader(
gluon.data.vision.ImageFolderDataset(val_path).transform_first(transform_test),
batch_size=batch_size, shuffle=False, num_workers = num_workers)
test_data = gluon.data.DataLoader(
gluon.data.vision.ImageFolderDataset(test_path).transform_first(transform_test),
batch_size=batch_size, shuffle=False, num_workers = num_workers)
return train_data, val_data, test_data
def DogDataLoader(opt):
transform_train = T.Compose([
T.Resize(256),
T.CenterCrop(224),
T.RandomFlipLeftRight(),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
transform_valid = T.Compose([
T.Resize(224),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
train_set = vision.ImageFolderDataset(opt.train_dir, flag=1)
valid_set = vision.ImageFolderDataset(opt.valid_dir, flag=1)
loader = gluon.data.DataLoader
train_loader = loader(train_set.transform_first(transform_train),
batch_size=opt.batch_size,
shuffle=True,
num_workers=opt.num_workers,
last_batch='rollover')
valid_loader = loader(valid_set.transform_first(transform_valid),
batch_size=opt.batch_size,
shuffle=False,
num_workers=opt.num_workers,
last_batch='keep')
return train_loader, valid_loader
def create_transformer(self):
train_tforms, eval_tforms = [transforms.Resize(self.args.resize)
], [transforms.Resize(self.args.resize)]
if self.args.random_crop:
train_tforms.append(
transforms.RandomResizedCrop(self.args.size, scale=(0.8, 1.2)))
else:
train_tforms.append(transforms.CenterCrop(self.args.size))
eval_tforms.append(transforms.CenterCrop(self.args.size))
if self.args.flip:
train_tforms.append(transforms.RandomFlipLeftRight())
if self.args.random_color:
train_tforms.append(
transforms.RandomColorJitter(self.args.color_jitter,
self.args.color_jitter,
self.args.color_jitter, 0.1))
train_tforms.extend([
transforms.ToTensor(),
transforms.Normalize(self.args.mean, self.args.std)
])
eval_tforms.extend([
transforms.ToTensor(),
transforms.Normalize(self.args.mean, self.args.std)
])
train_tforms = transforms.Compose(train_tforms)
eval_tforms = transforms.Compose(eval_tforms)
return train_tforms, eval_tforms
def test_resize_gpu():
# Test with normal case 3D input float type
data_in_3d = mx.np.random.uniform(0, 255, (300, 300, 3))
out_nd_3d = transforms.Resize((100, 100))(data_in_3d)
data_in_4d_nchw = mx.np.moveaxis(mx.np.expand_dims(data_in_3d, axis=0), 3,
1)
data_expected_3d = (mx.np.moveaxis(
nd.contrib.BilinearResize2D(data_in_4d_nchw.as_nd_ndarray(),
height=100,
width=100,
align_corners=False), 1, 3))[0]
assert_almost_equal(out_nd_3d.asnumpy(), data_expected_3d.asnumpy())
# Test with normal case 4D input float type
data_in_4d = mx.np.random.uniform(0, 255, (2, 300, 300, 3))
out_nd_4d = transforms.Resize((100, 100))(data_in_4d)
data_in_4d_nchw = mx.np.moveaxis(data_in_4d, 3, 1)
data_expected_4d = mx.np.moveaxis(
nd.contrib.BilinearResize2D(data_in_4d_nchw.as_nd_ndarray(),
height=100,
width=100,
align_corners=False), 1, 3)
assert_almost_equal(out_nd_4d.asnumpy(), data_expected_4d.asnumpy())
# Test invalid interp
data_in_3d = mx.np.random.uniform(0, 255, (300, 300, 3))
invalid_transform = transforms.Resize(-150,
keep_ratio=False,
interpolation=2)
assertRaises(MXNetError, invalid_transform, data_in_3d)
# Credited to Hang Zhang
def py_bilinear_resize_nhwc(x, outputHeight, outputWidth):
batch, inputHeight, inputWidth, channel = x.shape
if outputHeight == inputHeight and outputWidth == inputWidth:
return x
y = np.empty([batch, outputHeight, outputWidth,
channel]).astype('uint8')
rheight = 1.0 * (inputHeight - 1) / (outputHeight -
1) if outputHeight > 1 else 0.0
rwidth = 1.0 * (inputWidth - 1) / (outputWidth -
1) if outputWidth > 1 else 0.0
for h2 in range(outputHeight):
h1r = 1.0 * h2 * rheight
h1 = int(np.floor(h1r))
h1lambda = h1r - h1
h1p = 1 if h1 < (inputHeight - 1) else 0
for w2 in range(outputWidth):
w1r = 1.0 * w2 * rwidth
w1 = int(np.floor(w1r))
w1lambda = w1r - w1
w1p = 1 if w1 < (inputHeight - 1) else 0
for b in range(batch):
for c in range(channel):
y[b][h2][w2][c] = (1-h1lambda)*((1-w1lambda)*x[b][h1][w1][c] + \
w1lambda*x[b][h1][w1+w1p][c]) + \
h1lambda*((1-w1lambda)*x[b][h1+h1p][w1][c] + \
w1lambda*x[b][h1+h1p][w1+w1p][c])
return y
def __call__(self, img):
osize = [self.opt.image_size, self.opt.image_size]
if 'resize' in self.opt.preprocess:
return transforms.Resize(osize,
interpolation=self.interpolation)(img)
elif 'scale_width' in self.opt.preprocess:
return transforms.Resize(osize,
keep_ratio=True,
interpolation=self.interpolation)(img)
return img
def __call__(self, img):
if random.random() < self.p:
return transforms.Resize((self.width, self.height),
interpolation=self.interpolation)(img)
new_width, new_height = int(round(self.width * 1.125)), int(
round(self.height * 1.125))
resized_img = transforms.Resize((new_width, new_height),
interpolation=self.interpolation)(img)
x_maxrange = new_width - self.width
y_maxrange = new_height - self.height
x1 = int(round(random.uniform(0, x_maxrange)))
y1 = int(round(random.uniform(0, y_maxrange)))
croped_img = mx.image.fixed_crop(resized_img, x1, y1, self.width,
self.height)
return croped_img
def _evaluate(self, val_data):
"""Test on validation dataset."""
acc_top1 = mx.metric.Accuracy()
acc_top5 = mx.metric.TopKAccuracy(min(5, self.num_class))
if not isinstance(val_data, (gluon.data.DataLoader, mx.io.MXDataIter)):
if hasattr(val_data, 'to_mxnet'):
val_data = val_data.to_mxnet()
resize = int(
math.ceil(self.input_size / self._cfg.train.crop_ratio))
normalize = transforms.Normalize([0.485, 0.456, 0.406],
[0.229, 0.224, 0.225])
transform_test = transforms.Compose([
transforms.Resize(resize, keep_ratio=True),
transforms.CenterCrop(self.input_size),
transforms.ToTensor(), normalize
])
val_data = gluon.data.DataLoader(
val_data.transform_first(transform_test),
batch_size=self._cfg.valid.batch_size,
shuffle=False,
last_batch='keep',
num_workers=self._cfg.valid.num_workers)
for _, batch in enumerate(val_data):
data, label = self.batch_fn(batch, self.ctx)
outputs = [
self.net(X.astype(self._cfg.train.dtype, copy=False))
for X in data
]
acc_top1.update(label, outputs)
acc_top5.update(label, outputs)
_, top1 = acc_top1.get()
_, top5 = acc_top5.get()
return top1, top5
def transform_image(array):
"""
Should transform image by:
1) Resizing the shortest dimension to 224. e.g (448, 1792) -> (224, 896).
2) Cropping to a center square of dimension (224, 224).
3) Converting the image from HWC layout to CHW layout.
4) Normalizing the image using ImageNet statistics (i.e. per colour channel mean and variance).
5) Creating a batch of 1 image.
:param filepath: array (in HWC layout).
:type filepath: mx.nd.NDArray
:return: a batch of a single transformed images (in NCHW layout)
:rtype: mx.nd.NDArray
"""
# YOUR CODE HERE
train_trans = transforms.Compose([
transforms.Resize(224, keep_ratio=True),
transforms.CenterCrop((224, 224)),
transforms.ToTensor(),
transforms.Normalize([.485, .456, .606], [.229, .224, .225])
])
return (train_trans(array).expand_dims(0))
raise NotImplementedError()
def test(opt):
# Load dataset
dataset = Dataset(opt.data_dir, opt.train_txt, opt.test_txt, opt.bbox_txt)
dataset.print_stats()
# Load image transform
test_transform = transforms.Compose([
transforms.Resize((opt.image_width, opt.image_height)),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
# Load data loader
test_loader = mx.gluon.data.DataLoader(dataset=ImageData(
dataset.test, test_transform),
batch_size=opt.batch_size,
num_workers=opt.num_workers)
# Load model
model = Model(opt)
# Load evaluator
evaluator = Evaluator(model, test_loader, opt.ctx)
# Evaluate
recalls = evaluator.evaluate(ranks=opt.recallk)
for recallk, recall in zip(opt.recallk, recalls):
print("R@{:4d}: {:.4f}".format(recallk, recall))
def preprocess_test_data(normalize):
transform_test = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(), normalize
])
return transform_test
def transform_test(image):
transform = T.Compose([
T.Resize(224),
T.ToTensor(),
T.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])])
return transform(image)
def get_data_loader(data_dir, batch_size, num_workers):
normalize = transforms.Normalize([0.485, 0.456, 0.406],
[0.229, 0.224, 0.225])
input_size = opt.input_size
crop_ratio = opt.crop_ratio if opt.crop_ratio > 0 else 0.875
resize = int(math.ceil(input_size / crop_ratio))
def batch_fn(batch, ctx):
data = gluon.utils.split_and_load(batch[0],
ctx_list=ctx,
batch_axis=0)
label = gluon.utils.split_and_load(batch[1],
ctx_list=ctx,
batch_axis=0)
return data, label
transform_test = transforms.Compose([
transforms.Resize(resize, keep_ratio=True),
transforms.CenterCrop(input_size),
transforms.ToTensor(), normalize
])
val_data = gluon.data.DataLoader(imagenet.classification.ImageNet(
data_dir, train=False).transform_first(transform_test),
batch_size=batch_size,
shuffle=False,
num_workers=num_workers)
return val_data, batch_fn
def get_val_data_source(dataset_dir,
batch_size,
num_workers,
input_image_size=(224, 224),
resize_inv_factor=0.875):
assert (resize_inv_factor > 0.0)
if isinstance(input_image_size, int):
input_image_size = (input_image_size, input_image_size)
resize_value = int(
math.ceil(float(input_image_size[0]) / resize_inv_factor))
mean_rgb = (0.485, 0.456, 0.406)
std_rgb = (0.229, 0.224, 0.225)
transform_val = transforms.Compose([
transforms.Resize(resize_value, keep_ratio=True),
transforms.CenterCrop(input_image_size),
transforms.ToTensor(),
transforms.Normalize(mean=mean_rgb, std=std_rgb)
])
return gluon.data.DataLoader(dataset=CUB200_2011(
root=dataset_dir, train=False).transform_first(fn=transform_val),
batch_size=batch_size,
shuffle=False,
num_workers=num_workers)
def test_model_for_ml(self):
net_path = os.path.join(
DATA_DIR, 'model',
'epoch-3-0.48-20180920164709.params-symbol.json')
params_path = os.path.join(
DATA_DIR, 'model',
'epoch-3-0.48-20180920164709.params-0003.params')
net = gluon.nn.SymbolBlock.imports(net_path, ['data'], params_path)
im_path = os.path.join(DATA_DIR, 'imgs_data',
'd4YE10xHdvbwKJV5yBYsoJJke6K9b.jpg')
img = image.imread(im_path)
# plt.imshow(img.asnumpy())
# plt.show()
transform_fn = transforms.Compose([
transforms.Resize(224, keep_ratio=True),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
])
img = transform_fn(img)
img = nd.expand_dims(img, axis=0)
res = net(img.as_in_context(self.ctx[0]))
res = sigmoid(nd.squeeze(res)).asnumpy()
res = np.where(res > 0.5, 1, 0)
indexes, = np.where(res == 1)
res_classes = [self.class_names[i] for i in indexes.tolist()]
# print(indexes.tolist())
print('测试类别: {}'.format(res_classes))
def _evaluate(self, val_data):
"""Test on validation dataset."""
acc_top1 = mx.metric.Accuracy()
acc_top5 = mx.metric.TopKAccuracy(min(5, self.num_class))
if not isinstance(val_data, (gluon.data.DataLoader, mx.io.ImageRecordIter)):
from ...tasks.dataset import ImageClassificationDataset
if isinstance(val_data, ImageClassificationDataset):
val_data = val_data.to_mxnet()
transform_test = transforms.Compose([
transforms.Resize(resize, keep_ratio=True),
transforms.CenterCrop(self.input_size),
transforms.ToTensor(),
normalize
])
val_data = gluon.data.DataLoader(
val_data.transform_first(transform_test),
batch_size=self._cfg.valid.batch_size, shuffle=False, last_batch='keep',
num_workers=self._cfg.valid.num_workers)
for _, batch in enumerate(val_data):
data, label = self.batch_fn(batch, self.ctx)
outputs = [self.net(X.astype(self._cfg.train.dtype, copy=False)) for X in data]
acc_top1.update(label, outputs)
acc_top5.update(label, outputs)
_, top1 = acc_top1.get()
_, top5 = acc_top5.get()
return top1, top5
def get_data_loader(data_dir, batch_size, num_workers):
normalize = transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
jitter_param = 0.4
lighting_param = 0.1
input_size = opt.input_size
def batch_fn(batch, ctx):
data = gluon.utils.split_and_load(batch[0], ctx_list=ctx, batch_axis=0)
label = gluon.utils.split_and_load(batch[1], ctx_list=ctx, batch_axis=0)
return data, label
transform_train = transforms.Compose([
transforms.RandomResizedCrop(input_size),
transforms.RandomFlipLeftRight(),
transforms.RandomColorJitter(brightness=jitter_param, contrast=jitter_param,
saturation=jitter_param),
transforms.RandomLighting(lighting_param),
transforms.ToTensor(),
normalize
])
transform_test = transforms.Compose([
transforms.Resize(256, keep_ratio=True),
transforms.CenterCrop(input_size),
transforms.ToTensor(),
normalize
])
train_data = gluon.data.DataLoader(
imagenet.classification.ImageNet(data_dir, train=True).transform_first(transform_train),
batch_size=batch_size, shuffle=True, last_batch='discard', num_workers=num_workers)
val_data = gluon.data.DataLoader(
imagenet.classification.ImageNet(data_dir, train=False).transform_first(transform_test),
batch_size=batch_size, shuffle=False, num_workers=num_workers)
return train_data, val_data, batch_fn
def mxnet_cifar10(im):
img = image.imread(im)
# plt.imshow(img.asnumpy())
# plt.show()
# transform image
transform_fn = transforms.Compose([
transforms.Resize(32),
transforms.CenterCrop(32),
transforms.ToTensor(),
transforms.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010])
])
img = transform_fn(img)
# plt.imshow(nd.transpose(img, (1,2,0)).asnumpy())
# plt.show()
# load pre-trained model
net = get_model('cifar_resnet110_v1', classes=10, pretrained=True)
# predict class
pred = net(img.expand_dims(axis=0))
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',
'dog', 'frog', 'horse', 'ship', 'truck']
ind = nd.argmax(pred, axis=1).astype('int')
return [str(class_names[ind.asscalar()]), str(round(nd.softmax(pred)[0][ind].asscalar(), 2))]
def imagenet_val_transform(ds_metainfo,
mean_rgb=(0.485, 0.456, 0.406),
std_rgb=(0.229, 0.224, 0.225)):
"""
Create image transform sequence for validation subset.
Parameters:
----------
ds_metainfo : DatasetMetaInfo
ImageNet-1K dataset metainfo.
mean_rgb : tuple of 3 float
Mean of RGB channels in the dataset.
std_rgb : tuple of 3 float
STD of RGB channels in the dataset.
Returns
-------
Sequential
Image transform sequence.
"""
input_image_size = ds_metainfo.input_image_size
resize_value = calc_val_resize_value(
input_image_size=ds_metainfo.input_image_size,
resize_inv_factor=ds_metainfo.resize_inv_factor)
return transforms.Compose([
transforms.Resize(
size=resize_value,
keep_ratio=True),
transforms.CenterCrop(size=input_image_size),
transforms.ToTensor(),
transforms.Normalize(
mean=mean_rgb,
std=std_rgb)
])
def load_img_batch(dataset, batch_size, type):
if type == 'train':
transform=img_transforms.Compose([\
#随机对图像裁剪出面积为原图像面积的0.08~1倍
#高/宽：3/4 ~ 4/3，最后高度与宽度都缩放到224像素
img_transforms.RandomResizedCrop(224,scale=(0.08,1.0),ratio=(3.0/4.0,4.0/3.0)),\
#随机左右翻转
img_transforms.RandomFlipLeftRight(),\
#随机变化亮度、对比度、饱和度
img_transforms.RandomColorJitter(brightness=0.4,contrast=0.4,saturation=0.4),\
#随机噪声
img_transforms.RandomLighting(0.1),\
img_transforms.ToTensor(),\
# 对图像的每个通道做标准化
img_transforms.Normalize([0.485,0.456,0.406],[0.229,0.224,0.225])])
return gdata.DataLoader(dataset.transform_first(transform),
batch_size=batch_size,
shuffle=True,
last_batch='keep')
elif type == 'test':
transform=img_transforms.Compose([\
img_transforms.Resize(256),\
img_transforms.CenterCrop(224),\
img_transforms.ToTensor(),\
img_transforms.Normalize([0.485,0.456,0.406],[0.229,0.224,0.225])])
return gdata.DataLoader(dataset.transform_first(transform),
batch_size=batch_size,
shuffle=False,
last_batch='keep')
def get_data(batch_size, test_set, query_set):
normalizer = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
transform_test = transforms.Compose([
transforms.Resize(size=(128, 384), interpolation=1),
transforms.ToTensor(), normalizer
])
test_imgs = ImageTxtDataset(data_dir + 'test',
test_set,
transform=transform_test)
query_imgs = ImageTxtDataset(data_dir + 'query',
query_set,
transform=transform_test)
test_data = gluon.data.DataLoader(test_imgs,
batch_size,
shuffle=False,
last_batch='keep',
num_workers=4)
query_data = gluon.data.DataLoader(query_imgs,
batch_size,
shuffle=False,
last_batch='keep',
num_workers=4)
return test_data, query_data
def getNdFromFrame(self):
#use cv2 to capture a frame at self.second from self.source to return imagedata [H x W x RGB]
RootSrc = "C:/Users/samta/TurtleCam" + self.source
vidcap = cv2.VideoCapture(RootSrc)
#perhaps a much quicker method for grabbing frames https://gist.github.com/kylemcdonald/85d70bf53e207bab3775
#This function takes an incredibly long time to execute
vidcap.set(cv2.CAP_PROP_POS_MSEC, self.second * 1000)
(hasFrames, image) = vidcap.read() #stored as 3-D list [H][W][RGB]
if hasFrames:
#reorganize later.. make class in dataAnalyze
img_nump = np.asarray(image)
temp_nd = nd.array(img_nump)
transformer = trans.Compose([
trans.Resize(300),
trans.CenterCrop(255),
trans.ToTensor(),
trans.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
norm_nd_img = transformer(temp_nd)
return hasFrames, norm_nd_img
else:
return hasFrames, 'null'
def predict(self, X, input_size=224, plot=True):
""" This method should be able to produce predictions regardless if:
X = single data example (e.g. single image, single document),
X = batch of many examples, X = task.Dataset object
"""
"""The task predict function given an input.
Args:
img: the input
Example:
>>> ind, prob = classifier.predict('example.jpg')
"""
# load and display the image
img = mx.image.imread(X) if isinstance(
X, str) and os.path.isfile(X) else X
if plot:
plt.imshow(img.asnumpy())
plt.show()
# model inference
input_size = self.model.input_size if hasattr(
self.model, 'input_size') else input_size
resize = int(math.ceil(input_size / 0.875))
transform_fn = transforms.Compose([
transforms.Resize(resize),
transforms.CenterCrop(input_size),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
img = transform_fn(img)
proba = self.predict_proba(img)
ind = mx.nd.argmax(proba, axis=1).astype('int')
idx = mx.nd.stack(mx.nd.arange(proba.shape[0], ctx=proba.context),
ind.astype('float32'))
return ind, mx.nd.gather_nd(proba, idx)
def imagenet_val_transform(ds_metainfo):
"""
Create image transform sequence for validation subset.
Parameters:
----------
ds_metainfo : DatasetMetaInfo
ImageNet-1K dataset metainfo.
Returns
-------
Sequential
Image transform sequence.
"""
input_image_size = ds_metainfo.input_image_size
resize_value = calc_val_resize_value(
input_image_size=ds_metainfo.input_image_size,
resize_inv_factor=ds_metainfo.resize_inv_factor)
return transforms.Compose([
transforms.Resize(size=resize_value,
keep_ratio=True,
interpolation=ds_metainfo.interpolation),
transforms.CenterCrop(size=input_image_size),
transforms.ToTensor(),
transforms.Normalize(mean=ds_metainfo.mean_rgb,
std=ds_metainfo.std_rgb)
])
def __init__(self,
params_file,
input_size=320,
gpu_id=0,
nms_thresh=None,
nms_topk=400,
force_suppress=False):
if isinstance(input_size, int):
self.width, self.height = input_size, input_size
elif isinstance(input_size, (list, tuple)):
self.width, self.height = input_size
else:
raise ValueError('Expected int or tuple for input size')
self.ctx = mx.gpu(gpu_id)
self.transform_fn = transforms.Compose([
transforms.Resize(input_size),
transforms.ToTensor(),
transforms.Normalize([.485, .456, .406], [.229, .224, .225]),
])
symbol_file = params_file[:params_file.rfind('-')] + "-symbol.json"
# self.net = gluon.nn.SymbolBlock.imports(symbol_file, ['data'], params_file, ctx=self.ctx)
self.net = CustomSymbolBlock.imports(symbol_file, ['data'],
params_file,
ctx=self.ctx,
nms_thresh=nms_thresh,
nms_topk=nms_topk,
force_suppress=force_suppress)
self.net.hybridize()
def __init__(self,
datasetroot=None,
istrain=False,
resize_size=None,
crop_size=None,
interpolation=INTERPOLATION,
mean=MEAN,
std=STD):
self.datasetroot = datasetroot
self.istrain = istrain
transform_list = [ImageRead()]
if resize_size is not None:
transform_list.append(
transforms.Resize(resize_size, interpolation=interpolation))
if crop_size is not None:
if self.istrain:
transform_list.append(
RandomCrop(crop_size, interpolation=interpolation))
else:
transform_list.append(
transforms.CenterCrop(crop_size,
interpolation=interpolation))
if self.istrain:
transform_list.append(transforms.RandomFlipLeftRight())
transform_list.append(transforms.ToTensor())
transform_list.append(transforms.Normalize(mean, std))
self.transformer = transforms.Compose(transform_list)
